tfa.metrics.KendallsTauC  | Complementos do TensorFlow (2023)

Veja a fonte no GitHub

Calcula o coeficiente de correlação de classificação Tau-c de Kendall.

tfa.metrics.KendallsTauC( actual_min: float = 0.0, actual_max: float = 1.0, preds_min: float = 0.0, preds_max: float = 1.0, actual_cutpoints: int = 100, preds_cutpoints: int = 100, name: str = None, dtype:tfa.types.AcceptableDTypes= Nenhum)

Uso:

reais = tf.constant([12, 2, 1, 12, 2], dtype=tf.int32)preds = tf.constant([1, 4, 7, 1, 0], dtype=tf.int32)m = tfa.metrics.KendallsTauC(0, 13, 0, 8)m.update_state(reais, preds)m.result().numpy()-0,48000002

self.input_spec = tf.keras.layers.InputSpec(ndim=4)

ValueError: A entrada 0 da camada conv2d é incompatível com a camada: esperado ndim=4, encontrado ndim=1. Forma completa recebida: [2]

class MyLayer(tf.keras.layers.Layer):def chamada(auto, entradas):self.add_loss(tf.abs(tf.reduce_mean(entradas)))entradas de retornol = MinhaCamada()l(np.ones((10, 1)))l.perdas[1.0]

entradas = tf.keras.Input(forma=(10,))x = tf.keras.layers.Dense(10)(entradas)saídas = tf.keras.layers.Dense(1)(x)modelo = tf.keras.Model(entradas, saídas)# Regularização da atividade.len(model.perdas)0model.add_loss(tf.abs(tf.reduce_mean(x)))len(model.perdas)1

entradas = tf.keras.Input(forma=(10,))d = tf.keras.layers.Dense(10, kernel_initializer='ones')x = d(entradas)saídas = tf.keras.layers.Dense(1)(x)modelo = tf.keras.Model(entradas, saídas)# Regularização do peso.model.add_loss(lambda: tf.reduce_mean(d.kernel))model.losses[]

input = tf.keras.layers.Input(shape=(3,))d = tf.keras.layers.Dense(2)saída = d(entrada)d.add_metric(tf.reduce_max(saída), nome='max')d.add_metric(tf.reduce_min(saída), nome='min')[m.name para m em d.metrics]['max', 'min']

a = tf.Module()b = tf.Module()c = tf.Module()a.b = bb.c = clista(a.submodules) == [b, c]Verdadeirolista(b.submódulos) == [c]Verdadeirolista(c.submodules) == []Verdadeiro

Métodos

add_loss

add_loss(perdas, **kwargs)

Adicione o(s) tensor(es) de perda, potencialmente dependentes das entradas da camada.

Algumas perdas (por exemplo, perdas de regularização de atividade) podem ser dependentes das entradas passadas na chamada de uma camada. Portanto, ao reutilizar a mesma camada em diferentes entradasaeb, algumas entradas emcamada.perdaspode ser dependente deae alguns emb. Esse método automaticamente acompanha as dependências.

Este método pode ser usado dentro de uma camada de subclasse ou modelochamarfunção, caso em queperdasdeve ser um tensor ou uma lista de tensores.

Exemplo:

class MyLayer(tf.keras.layers.Layer): def call(self, inputs): self.add_loss(tf.abs(tf.reduce_mean(inputs))) return inputs

O mesmo código funciona no treinamento distribuído: a entrada paraadd_loss()é tratado como uma perda de regularização e é calculada a média entre as réplicas pelo loop de treinamento (ambos integradosModel.fit()e loops de treinamento personalizados compatíveis).

Oadd_lossO método também pode ser chamado diretamente em um Modelo Funcional durante a construção. Nesse caso, qualquer tensor de perda passado para este modelo deve ser simbólico e poder ser rastreado até o modeloEntradas. Essas perdas passam a fazer parte da topologia do modelo e são rastreadas emget_config.

Exemplo:

entradas = tf.keras.Input(shape=(10,))x = tf.keras.layers.Dense(10)(entradas)saídas = tf.keras.layers.Dense(1)(x)model = tf.keras .Model(inputs, outputs)# Activity regularization.model.add_loss(tf.abs(tf.reduce_mean(x)))

Se este não for o caso da sua perda (se, por exemplo, a sua perda se referir a umVariávelde uma das camadas do modelo), você pode agrupar sua perda em um lambda sem argumentos. Essas perdas não são rastreadas como parte da topologia do modelo, pois não podem ser serializadas.

Exemplo:

entradas = tf.keras.Input(shape=(10,))d = tf.keras.layers.Dense(10)x = d(entradas)saídas = tf.keras.layers.Dense(1)(x)model = tf.keras.Model(inputs, outputs)# Weight regularization.model.add_loss(lambda: tf.reduce_mean(d.kernel))

add_metric

add_metric(valor, nome=Nenhum, **kwargs)

Adiciona tensor métrico à camada.

Este método pode ser usado dentro dochamar()método de uma camada subclassificada ou modelo.

class MyMetricLayer(tf.keras.layers.Layer): def __init__(self): super(MyMetricLayer, self).__init__(name='my_metric_layer') self.mean = tf.keras.metrics.Mean(name='metric_1' ) def call(self, inputs): self.add_metric(self.mean(inputs)) self.add_metric(tf.reduce_sum(inputs), name='metric_2') return inputs

Este método também pode ser chamado diretamente em um Modelo Funcional durante a construção. Nesse caso, qualquer tensor passado para este modelo deve ser simbólico e poder ser rastreado até o modeloEntradas. Essas métricas tornam-se parte da topologia do modelo e são rastreadas quando você salva o modelo viasalvar().

entradas = tf.keras.Input(shape=(10,))x = tf.keras.layers.Dense(10)(entradas)saídas = tf.keras.layers.Dense(1)(x)model = tf.keras .Model(entradas, saídas)model.add_metric(math_ops.reduce_sum(x), name='metric_1')

entradas = tf.keras.Input(shape=(10,))x = tf.keras.layers.Dense(10)(entradas)saídas = tf.keras.layers.Dense(1)(x)model = tf.keras .Model(entradas, saídas)model.add_metric(tf.keras.metrics.Mean()(x), name='metric_1')

construir

build(forma_de_entrada)

Cria as variáveis ​​da camada (para implementadores de subclasse).

Este é um método que implementadores de subclasses deCamadaouModelopodem substituir se precisarem de uma etapa de criação de estado entre a instanciação da camada e a chamada da camada. Ele é invocado automaticamente antes da primeira execução dechamar().

Isso é normalmente usado para criar os pesos deCamadasubclasses (a critério do implementador da subclasse).

build_from_config

build_from_config (configuração)

computa_mask

compute_mask (entradas, máscara = Nenhum)

Calcula um tensor de máscara de saída.

compute_output_shape

computer_output_shape (input_shape)

Calcula a forma de saída da camada.

Este método fará com que o estado da camada seja construído, caso isso não tenha acontecido antes. Isso requer que a camada seja usada posteriormente em entradas que correspondam à forma de entrada fornecida aqui.

count_params

count_params()

Conte o número total de escalares que compõem os pesos.

from_config

@classmethodfrom_config (configuração)

Cria uma camada a partir de sua configuração.

Este método é o inverso doget_config,capaz de instanciar a mesma camada do configdictionary. Não lida com conectividade de camada (tratada pela rede), nem pesos (tratada porset_weights).

get_build_config

get_build_config()

get_config

Ver fonte

get_config()

Retorna a configuração serializável da métrica.

get_weights

get_weights()

Retorna os pesos atuais da camada, como matrizes NumPy.

Os pesos de uma camada representam o estado da camada. Essa função retorna valores de peso treináveis ​​e não treináveis ​​associados a essa camada como uma lista de arrays NumPy, que por sua vez podem ser usados ​​para carregar o estado em camadas com parâmetros semelhantes.

Por exemplo, umDensolayer retorna uma lista de dois valores: a kernelmatrix e o vetor bias. Estes podem ser usados ​​para definir os pesos de outroDensocamada:

layer_a = tf.keras.layers.Dense(1,kernel_initializer=tf.constant_initializer(1.))a_out = layer_a(tf.convert_to_tensor([[1., 2., 3.]]))layer_a.get_weights()[matriz([[1.],[1.],[1.]], dtype=float32), array([0.], dtype=float32)]layer_b = tf.keras.layers.Dense(1,kernel_initializer=tf.constant_initializer(2.))b_out = layer_b(tf.convert_to_tensor([[10., 20., 30.]]))layer_b.get_weights()[matriz([[2.],[2.],[2.]], dtype=float32), array([0.], dtype=float32)]layer_b.set_weights(layer_a.get_weights())layer_b.get_weights()[matriz([[1.],[1.],[1.]], dtype=float32), array([0.], dtype=float32)]

mesclar_estado

merge_state (métricas)

Mescla o estado de uma ou mais métricas.

Este método pode ser usado por sistemas distribuídos para mesclar o estado computado por diferentes instâncias de métricas. Normalmente, o estado será armazenado na forma dos pesos da métrica. Por exemplo, a métrica atf.keras.metrics.Mean contém uma lista de dois valores de ponderação: um total e uma contagem. Se houvesse duas instâncias de atf.keras.metrics.Accuracy em que cada estado parcial agregado independentemente para um cálculo de precisão geral, esses dois estados de métrica poderiam ser combinados da seguinte forma:

m1 = tf.keras.metrics.Accuracy()_ = m1.update_state([[1], [2]], [[0], [2]])

m2 = tf.keras.metrics.Accuracy()_ = m2.update_state([[3], [4]], [[3], [4]])

m2.merge_state([m1])m2.result().numpy()0,75

reset_state

Ver fonte

reset_state()

Redefine todas as variáveis ​​de estado da métrica.

reset_states

Ver fonte

reset_states()

resultado

Ver fonte

resultado()

Calcula e retorna o tensor do valor métrico escalar ou um dict de escalares.

A computação do resultado é uma operação idempotente que simplesmente calcula o valor da métrica usando as variáveis ​​de estado.

set_weights

set_weights (pesos)

Define os pesos da camada, de matrizes NumPy.

Os pesos de uma camada representam o estado da camada. Essa função define os valores de peso de matrizes numpy. Os valores de peso devem ser passados ​​na ordem em que são criados pela camada. Observe que os pesos da camada devem ser instanciados antes de chamar esta função, chamando a camada.

Por exemplo, umDensolayer retorna uma lista de dois valores: a kernelmatrix e o vetor bias. Estes podem ser usados ​​para definir os pesos de outroDensocamada:

layer_a = tf.keras.layers.Dense(1,kernel_initializer=tf.constant_initializer(1.))a_out = layer_a(tf.convert_to_tensor([[1., 2., 3.]]))layer_a.get_weights()[matriz([[1.],[1.],[1.]], dtype=float32), array([0.], dtype=float32)]layer_b = tf.keras.layers.Dense(1,kernel_initializer=tf.constant_initializer(2.))b_out = layer_b(tf.convert_to_tensor([[10., 20., 30.]]))layer_b.get_weights()[matriz([[2.],[2.],[2.]], dtype=float32), array([0.], dtype=float32)]layer_b.set_weights(layer_a.get_weights())layer_b.get_weights()[matriz([[1.],[1.],[1.]], dtype=float32), array([0.], dtype=float32)]

update_state

Ver fonte

update_state(y_true, y_pred, sample_weight=None)

Atualizaçõesm,nrow,ncolrespectivamente, os histogramas conjuntos e marginais de (y_true,y_pred)

with_name_scope

@classmethodwith_name_scope (método)

Decorator para inserir automaticamente o escopo do nome do módulo.

class MeuMódulo(tf.Módulo):@tf.Module.with_name_scopedef __call__(self, x):se não hasattr(self, 'w'):self.w = tf.Variable(tf.random.normal([x.shape[1], 3]))return tf.matmul(x, self.w)

Usar o módulo acima produziriatf.Variávelareiatf.Tensors cujos nomes incluíam o nome do módulo:

mod = MeuMódulo()mod(tf.ones([1, 2]))mod.wnumpy=..., dtype=float32)>

__chamar__

__call__( *args, **kwargs)

Acumula estatísticas e, em seguida, calcula o valor do resultado métrico.