Herramientas de usuario

Herramientas del sitio


clase:iabd:pia:2eval:tema07.metricas

7. Entrenamiento de redes neuronales c) Métricas

Métricas

Hasta ahora hemos visto como definir una red neuronal y como entrenarla. El último paso que nos queda es saber si la red ha funcionado correctamente. Pero ¿Eso no se hacía con la función de coste? Pues no exactamente. La función de coste se usa para ayudar a ajustar los parámetros durante el entrenamiento mediante los datos de entrada pero no para saber si el modelo es bueno. Para saber si el modelo es bueno , se usan las métricas.

Las métricas son muy parecidas a las funciones de coste pero hay métricas que no existen como función de coste. El muchos casos la métrica será la misma que la función de coste.

En el método fit de Keras tenemos un nuevo parámetro para indicar la métrica y luego nos retorna u objeto con el resultado de las métricas en cada época.

model.compile(loss="binary_crossentropy",optimizer=tf.keras.optimizers.SGD(learning_rate=0.01),metrics=[tf.keras.metrics.BinaryCrossentropy()])
history=model.fit(x,y_true,epochs=20,verbose=False)

Para obtener los valores de la métrica en cada época se usa la siguiente línea

history.history['binary_crossentropy']

Notar que del objeto history hay una propiedad que también se llama history.

Ahora que sabemos como obtener el coste de la red neuronal , vamos a mostrarla en una gráfica en función de la época.

figure=plt.figure()
axes = figure.add_subplot()

axes.plot(history.history['binary_crossentropy'],label="SGS lr=0.01")

axes.legend()
axes.set_xlabel('Época', fontsize=15,labelpad=20,color="#003B80")  
axes.set_ylabel('Valor métrica', fontsize=15,labelpad=20,color="#003B80")
axes.set_title("Métricas en épocas", fontsize=20,pad=30,color="#003B80")
axes.set_facecolor("#F0F7FF")
axes.grid(b=True, which='major', axis='both',color="#FFFFFF",linewidth=1)

Vemos que la métrica tiene un valor aun está lejos de llegar a cero.

Lo siguiente que vamos a hacer ahora es mirar si podemos mejorar el valor de la métrica, buscando un mejor optimizador. Para ellos vamos a crear un par de funciones que nos van a ayudar en nuestro trabajo:

def compile_and_fit(optimizer,epochs):
    np.random.seed(5)
    tf.random.set_seed(5)

    model=Sequential()
    model.add(Dense(3, input_dim=1,activation="sigmoid",kernel_initializer="glorot_normal"))
    model.add(Dense(1,activation="sigmoid",kernel_initializer="glorot_normal"))
    model.compile(loss="binary_crossentropy",optimizer=optimizer,metrics=[tf.keras.metrics.BinaryCrossentropy()])
    history=model.fit(x,y_true,epochs=epochs,verbose=False)

    return history

def format_axes(axes):
    axes.legend()
    axes.set_xlabel('Época', fontsize=15,labelpad=20,color="#003B80")  
    axes.set_ylabel('Valor métrica', fontsize=15,labelpad=20,color="#003B80")
    axes.set_title("Métricas en épocas", fontsize=20,pad=30,color="#003B80")
    axes.set_facecolor("#F0F7FF")
    axes.grid(b=True, which='major', axis='both',color="#FFFFFF",linewidth=1)
    

Vamos a usarlas ahora para obtener la gráfica pero entrenando la red durante 100 épocas:

history=compile_and_fit(tf.keras.optimizers.SGD(learning_rate=0.01),500)

figure=plt.figure()
axes = figure.add_subplot()

axes.plot(history.history['binary_crossentropy'],label="SGS lr=0.01")

format_axes(axes)

Pero vemos que tampoco ha mejorado mucho.

¿Y si usamos el optimizador Nadam con el mismo learning_rate de 0.01 y además los comparamos?

optimizers=[
    [tf.keras.optimizers.SGD(learning_rate=0.01),"SGD lr=0.01"],      
    [tf.keras.optimizers.Nadam(learning_rate=0.01),"Nadam lr=0.01"]        
]

figure=plt.figure(figsize=(8,6))
axes = figure.add_subplot()


for optimizer in optimizers:
    history=compile_and_fit(optimizer[0],500)
    axes.plot(history.history['binary_crossentropy'],label=optimizer[1])

format_axes(axes)

¡¡¡Ahora si que ha mejorado mucho!!!!, ya hemos llegado a un valor cercano a cero y además no nos hacen falta tantas épocas.

Probemos ahora con el resto de optimizadores pero con 40 épocas y valores aun mayores de learning_rate

optimizers=[
    [tf.keras.optimizers.Adagrad(learning_rate=0.1),"Adagrad lr=0.1"],
    [tf.keras.optimizers.RMSprop(learning_rate=0.1),"RMSprop lr=0.1"],
    [tf.keras.optimizers.Adadelta(learning_rate=0.1),"Adadelta lr=0.1"],   
    [tf.keras.optimizers.Adam(learning_rate=0.1),"Adam lr=0.1"],
    [tf.keras.optimizers.Adamax(learning_rate=0.1),"Adamax lr=0.1"], 
    [tf.keras.optimizers.Nadam(learning_rate=0.1),"Nadam lr=0.1"],
    [tf.keras.optimizers.Adam(learning_rate=0.1,amsgrad=True),"AMSGrad lr=0.1"]           
]

figure=plt.figure(figsize=(15,10))
axes = figure.add_subplot()

for optimizer in optimizers:
    history=compile_and_fit(optimizer[0],40)
    axes.plot(history.history['binary_crossentropy'],label=optimizer[1])

format_axes(axes)

Por orden , éstos son los mejores optimizadores (de mejor a peor):

  • RMSprop
  • Nadam y AMSGrad son muy similares; AMSGRad y Adam son identicos.
  • Adamax
  • AdaGrad
  • El peor de todos es Adadelta que parece que no convergen nada.

Como se puede ver, mostrar en una gráfica los valores de las métricas es de gran ayuda. Existen muchas métricas que veremos un poco después pero antes pasemos a ver un nuevo concepto que el la validación

Validación

Acabamos de ver que entrenando la red neuronal , el error se consigue bajar a prácticamente cero. Es decir que los valores de los parámetros , pesos (weight) y sesgos bias, debe ser muy buenos. No exactamente. Resulta que los parámetros se han ajustado a los datos que le hemos pasado, pero ¿Como es de bueno el modelo para nuevos datos que no ha visto? Realmente ver como se comporta con datos nuevos y con los datos que ha ya visto es lo que nos va a decir como es de bueno nuestro modelo. Así que pasemos a ver como sacar las métricas también con datos nuevos.

Lo primero es averiguar de donde obtenemos nuevos datos. Normalmente no tenemos nuevos datos así que lo que hacemos es que solo vamos a entrenar nuestra red neuronal con el 80% de los datos y el 20% restante los guardaremos para validar la red neuronal. Eso lo vamos a hacer con la función train_test_split de scikit-learn

from sklearn.model_selection import train_test_split

x_train, x_test, y_train, y_test = train_test_split(x, y_true, test_size=0.2, random_state=42)

La función train_test_split tiene los siguientes argumentos:

  • Los primeros arrays son los datos a dividir entre los datos de entrenamiento o de validación (test en inglés).
  • test_size: La fracción de datos que se va a usar para la validación.Es un valor de 0.0 a 1.0. Siendo 0.0 que no hay datos para validación y 1.0 que todos sería para validación.
  • random_state: Es para que sea reproducible el generador de los números aleatorios.
  • retorna los 4 array:
    • x_train: Array con la x de los datos de entrenamiento
    • x_test: Array con la x de los datos de validación
    • y_train: Array con la y de los datos de entrenamiento
    • y_test: Array con la y de los datos de validación

Y ahora a Keras se los tenemos que pasar así:

history=model.fit(x_train,y_train,validation_data=(x_test,y_test),epochs=epochs,verbose=False)

Lo datos de entrenamiento se pasan igual que antes pero los de validación se pasan en en un tupla en un parámetro llamado validation_data.

Por último tenemos que obtener la métrica para los datos de validación. Se obtiene igual que antes pero el nombre de la métrica empieza por val_

history.history['val_binary_crossentropy']

Veamos un ejemplo completo:

import numpy as np
import tensorflow as tf
import numpy as np
import pandas as pd
import keras
from keras.models import Sequential
from keras.layers import Dense
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split

iris=load_iris()
x=iris.data[0:99,2]
y_true=iris.target[0:99]

np.random.seed(5)
tf.random.set_seed(5)
x_train, x_test, y_train, y_test = train_test_split(x, y_true, test_size=0.2, random_state=42)

model=Sequential()
model.add(Dense(3, input_dim=1,activation="sigmoid",kernel_initializer="glorot_normal"))
model.add(Dense(1,activation="sigmoid",kernel_initializer="glorot_normal"))
model.compile(loss="binary_crossentropy",optimizer=tf.keras.optimizers.Adam(learning_rate=0.1),metrics=[tf.keras.metrics.BinaryCrossentropy()])
history=model.fit(x_train,y_train,validation_data=(x_test,y_test),epochs=40,verbose=False)

figure=plt.figure(figsize=(8,6))
axes = figure.add_subplot()

axes.plot(history.history['binary_crossentropy'],label="Training")
axes.plot(history.history['val_binary_crossentropy'],label="Test")

axes.legend()
axes.set_xlabel('Época', fontsize=15,labelpad=20,color="#003B80")  
axes.set_ylabel('Valor métrica', fontsize=15,labelpad=20,color="#003B80")
axes.set_facecolor("#F0F7FF")
axes.grid(b=True, which='major', axis='both',color="#FFFFFF",linewidth=1)

Podemos ver en el gráfico que la métrica es muy similar con los datos de test que con los de entrenamiento. Por lo que el modelo es bueno.

¿Cual es un valor aceptable de test_size, pues lo normal es 0.2 y 0.3.

En la siguiente gráfica podemos ver un ejemplo de como cambian las métricas según el valor de test_size:

Pero ahora vamos a cambiar la línea en la que aleatoriamente se eligen los datos de entrenamiento y validación, es decir la línea de train_test_split por las siguiente:

x_train=x[0:52]
y_train=y_true[0:52]
x_test=x[53:99]
y_test=y_true[53:99]

Y si ejecutamos el código se obtiene:

8-O ¡Se ha obtenido en la métrica de validación un resultado horrible aunque en el entrenamiento estaba dando muy buen resultado!

El motivo del mal rendimiento en validación es muy sencillo. Al entrenar, la mayoría de las flores eran de un tipo , mientras que en la validación eran del otro. Así que de esa forma es difícil aprender.

Tipos de métricas

Para acabar el tema vamos a ver las distintas métricas que existen. Lo primero es indicar nombres tanto en inglés como en español ya que vamos a usar los nombres en inglés

Inglés Español
Precision Precisión
Recall Exhaustividad
F1-score Valor-F
Accuracy Exactitud
Sensitivity Sensibilidad
Confusion Matrix Matriz de Confusión
True Positive Positivos Verdaderos
True Negative Negativos Verdaderos
False Positive Positivos Falsos
False Negative Negativos Falsos
  • Regresión
    • Mean Absolute Error (MAE)
    • Mean Squared Error (MSE)
    • Distancia del coseno
    • Root Mean Squared Error (RMSE)
  • Clasificación con 2 posibles valores
    • Binary Crossentropy
    • Accuracy
    • Precision
    • Recall o Sensitivity
    • F1-score
    • Area under the curve (AUC)
  • Clasificación con más de 2 posibles valores
    • Categorical Crossentropy
    • Categorical Accuracy

Hay métricas que son exactamente iguales a las funciones de coste como MEA o MSE en los problemas de regresión MAE, MSE. Si ya las usamos como función de coste y queremos usarlas como métricas no es necesario indicarlas como métricas, se puede acceder a ellas de la siguiente forma:

Para mostrar la función de coste en el entrenamiento:

history.history['loss']

Para mostrar la función de coste en la validación:

history.history['val_loss']

Métricas de regresión

Son las métricas que se usan en problemas de regresión. Son casi las mismas que usábamos como funciones de coste.

Mean Absolute Error (MAE)

Es igual que la función de coste de Mean Absolute Error (MAE), así que no explicaremos nada mas sobre ella excepto como se usa en Keras como métrica

Se define como:

metrics=[tf.keras.metrics.MeanAbsoluteError()]
metrics=["mean_absolute_error"]
metrics=["mae"]

y usarla como

history.history['mean_absolute_error']
history.history['val_mean_absolute_error']

history.history["mae"]
history.history["val_mae"]

Mas información:

Mean Squared Error (MSE)

Es igual que la función de coste de Mean Squared Error (MSE), así que no explicaremos nada mas sobre ella excepto como se usa en Keras como métrica

Se define como:

metrics=[tf.keras.metrics.MeanSquaredError()]
metrics=["mean_squared_error"]
metrics=["mse"]

y usarla como

history.history['mean_squared_error']
history.history['val_mean_squared_error']

history.history["mse"]
history.history["val_mse"]

Mas información:

Distancia del coseno

Es igual que la función de coste de Distancia del coseno, así que no explicaremos nada mas sobre ella excepto como se usa en Keras como métrica

Se define como:

metrics=[tf.keras.metrics.CosineSimilarity()]
metrics=["cosine_similarity"]

y usarla como

history.history['cosine_similarity']
history.history['val_cosine_similarity']

Mas información:

Root Mean Squared Error (RMSE)

La Root Mean Squared Error (RMSE) o Raiz cuadrada del error cuadrático medio se calcula igual que el MSE pero se le aplica la raíz cuadrada.

Por lo tanto su fórmula es

$$RMSE = \sqrt{MSE}= \sqrt{\frac{1}{N} \sum\limits_{i=1}^{N}(y_{i} - \hat{y_{i}})^2}$$

Ahora vamos a explicar algunas cosas de RMSE.

  • ¿Por qué se hace la raíz cuadrada? Pues porque antes habíamos elevado al cuadrado los errores
  • ¿Pero que ventaja tiene esa raíz cuadrada? La raíz cuadrada se hace para que el error esté en las mismas unidades que los datos. Es para que como humanos entendamos mejor el valor. Es decir que nosotros entendemos mejor el resultado de RMSE que el de MSE
  • ¿Por qué no existe la RMSE como función de coste? Por ahorrarnos el trabajo de hacer la raíz cuadrada. Como función de coste nos da igual el valor de MSE que la raíz cuadrada de MSE, la red va a funcionar igual.
  • ¿Por qué no existe RMAE? Por que con MAE no elevábamos nada al cuadrado así que no tiene sentido RMAE
  • A veces se intenta comprar los resultados de RMSE con MAE ya que ambos están en las mismas unidades.
  • Por lo que si queremos usar MSE como métrica es mejor usar RMSE y como función de coste es mejor MSE

Mas información:

Coeficiente de determinación o R²

El coeficiente de determinación o R² se calcula de la siguiente forma:

$$R^{2} = 1- \frac {\sum\limits_{i=1}^{N} (y_{i} - \hat{y_{i}})^2} {\sum\limits_{i=1}^{N} (y_{i} - \bar{y})^2}$$ $$\bar{y}=\frac {1}{N} \sum\limits_{i=1}^{N} y_{i} - \hat{y_{i}}$$

Siendo:

Ahora vamos a explicar algunas cosas de R²

  • MAE, MSE y RMSE son mejor cuanto menor es el valor, mientras que R² es mejor cuanto más se acerca a 1.
  • Un problema de R² es que aumenta su valor cuantas más variables tengamos de entrada (es decir el tamaño del vector de cada muestra) por eso se suele usar la métrica de R² ajustada. Para ello en Keras le pasaremos el argumento num_regressors a la clase RSquare

Mas información:

Selección de métricas de regresión

La elección de una métrica u otra se puede ver en MAE, MSE, RMSE, Coefficient of Determination, Adjusted R Squared — Which Metric is Better? y Know The Best Evaluation Metrics for Your Regression Model

  • RMSE es mejor que MSE ya que está en las mismas unidades que el resultado y no al cuadrado.
  • MAE es mas robusto que MSE ante datos anómalos ya que MSE eleva el error al cuadrado y la regresión al intentar minimizar dicho error , tiende a ir hacia ese dato anómalo.

Métricas de clasificación con 2 posibles valores

Clasificación con 2 posibles valores es cuando la salida de nuestra red neuronal solo puede tener 2 posibles valores, que deben se obligatoriamente los valores 0 y 1 debido a que las funciones de Keras funcionan con esos valores.

Antes de entrar a ver las métricas , es necesario entender lo que son:

  • True Positives (TP)
  • True Negatives (TN)
  • False Positives (FP): También llamados errores de Tipo I
  • False Negatives (FN): También llamados errores de Tipo II
Predicción
1 0
Realidad 1 TP FN
0 FP TN

Puesto con imágenes:

Predicción
1 0
Realidad 1
0

Para explicar todos estos conceptos véase el artículo Precision, Recall, F1, Accuracy en clasificación donde está muy bien explicado.

Binary Crossentropy

Es igual que la función de coste de Binary Crossentropy, así que no explicaremos nada mas sobre ella excepto como se usa en Keras como métrica excepto recordar que cuanto menor sea su valor es mejor la métrica.

Se define como:

metrics=[tf.keras.metrics.BinaryCrossentropy()]
metrics=["binary_crossentropy"]

y usarla como

history.history['binary_crossentropy']
history.history['val_binary_crossentropy']

Mas información:

Accuracy

Accuracy nos indica la proporción de aciertos que ha tenido. Es decir el porcentaje (en tanto por uno) de TP y TN respecto al total

Predicción
1 0
Realidad 1 TP FN
0 FP TN

$$Binary \: Accuracy = \frac{TN+TP}{TN+TP+FN+FP}$$

La métrica de Accuracy no funciona bien cuando no hay el mismo número de clases del tipo 0 y del tipo 1.

Su uso en Keras es

metrics=[tf.keras.metrics.BinaryAccuracy()]
metrics=["binary_accuracy"]

y usarla como

history.history['binary_accuracy']
history.history['val_binary_accuracy']

No confundir tf.keras.metrics.BinaryAccuracy() con tf.keras.metrics.Accuracy() ya que esta última necesita que los valores de $y$ e $\hat{y}$ sean exactamente iguales

Un ejemplo:

y_true = np.array([0.0, 1.0, 0.0, 1.0])
y_pred = np.array([0.1, 0.9, 0.9, 0.1])
metric = tf.keras.metrics.BinaryAccuracy()
metric(y_true, y_pred).numpy()

0.5

Más información:

Precision

Nos dice el porcentaje (en tanto por uno) de los que hemos acertado como verdaderos respecto a los predichos como verdaderos

Predicción
1 0
Realidad 1 TP FN
0 FP TN

$$Precision = \frac{TP}{TP+FP}$$

La métrica de Precision es importante cuando nos interesa que no haya muchos falsos positivos. Un ejemplo sería un modelo que predice donde hay yacimientos de petroleo. Un falso positivo implicaría invertir mucho dinero en montar el sistema de extracción de petroleo para que luego no hubiera petroleo.

Su uso en Keras es

metrics=[tf.keras.metrics.Precision()]
metrics=["Precision"]

y usarla como

history.history['precision']
history.history['val_precision']

Ejemplo:

y_true = np.array([0.0, 1.0, 1.0, 1.0])
y_pred = np.array([0.9, 0.9, 0.9, 0.1])
metric = tf.keras.metrics.Precision()
metric(y_true, y_pred).numpy()

0.6666667

Más información:

Recall o Sensitivity

Nos dice el porcentaje (en tanto por uno) de los que hemos acertado como verdaderos respecto a los que realmente eran verdaderos

Esta métrica también se suele llamar TPR (True Positive Rate) o Recall o Sensitivity
Predicción
1 0
Realidad 1 TP FN
0 FP TN

$$Precision = \frac{TP}{TP+FN}$$

La métrica de Recall es importante cuando nos interesa que no haya muchos falsos negativos. Un ejemplo sería un modelo que predice si tenemos cáncer. Un falso positivo implicaría que dejaremos sin tratar a una persona que si que tiene cancer.

Su uso en Keras es

metrics=[tf.keras.metrics.Recall()]
metrics=["Recall"]

y usarla como

history.history['recall']
history.history['val_recall']

Ejemplo:

y_true = np.array([1.0, 1.0, 1.0, 0.0])
y_pred = np.array([0.9, 0.0, 0.0, 0.9])
metric = tf.keras.metrics.Recall()
metric(y_true, y_pred).numpy()

0.33333334

Más información:

En la siguiente tabla se pueden ver las 5 principales métricas.

F1-score

Es la media armónica entre Recall y Precision que permite combinar en una única métrica ambos valores. Se usa cuando nos interesa un compromiso entre los errores de tipo I (Falsos positivos) y los de tipo II (Falsos negativos). Se ha usado la media armónica ya que tiende atener un valor muy bajo para valores bajos. Por ello no se "cancelan" valores buenos de Recall con valores malos de Precision ya que en ese caso F1-score tenderá a ser bajo por lo que indicará que nuestro modelo es malo.

$$F1{\text -}score=\frac{2}{\frac{1}{Recall}+\frac{1}{Precision}}$$

Pero si sumamos las fracciones y hacemos la división:

$$F1{\text -}score=\frac{2}{\frac{1}{Recall}+\frac{1}{Precision}}= \frac{2}{\frac{Precision}{Recall \cdot Precision}+\frac{Recall}{Precision \cdot Recall}}= \frac{2}{\frac{Precision+Recall}{Recall \cdot Precision}} = \frac{2}{1}: \frac{Precision+Recall}{Recall \cdot Precision} = \frac { 2 \cdot Recall \cdot Precision}{Recall + Precision}$$

Siendo el resultado la formula que se ve como definición de F1-score:

$$F1{\text -}score=2 \cdot \frac {Recall \cdot Precision}{Recall + Precision}$$

La métrica de F1-score no está directamente en Keras pero podemos crearla fácilmente nosotros con el siguiente código:


def f1_score(recall,precision):
    epsilon=0.000001
    return (2*np.asarray(recall)*np.asarray(precision))/((np.asarray(recall)+np.asarray(precision))+epsilon)

history.history["f1score"]=f1_score(history.history['recall'],history.history['precision'])
history.history["val_f1score"]=f1_score(history.history['val_recall'],history.history['val_precision'])

Existe un paquete extra llamado "tensorflow-addons" que contiene la métrica F1-score

Lo primero es instalar el paquete "tensorflow-addons" con:

conda install --channel esri tensorflow-addons

Ahora ya podemos usarlo previa importación del módulo tensorflow_addons

import tensorflow_addons as tfa

metrics=[tfa.metrics.F1Score()]

Area under the curve (AUC)

La Area under the curve (AUC) es una métrica que nos dice el área de una curva ROC. Pero pasemos primero a explicar que es una curva ROC.

Lo primero es que cuando predecimos que ciertos valores son Positivos o Negativos, lo hacemos en base a un umbral. Normalmente si algo es menor o igual que 0.5 decimos que es Negativo y si es mayor que 0.5 decimos que es Positivo. Pero ese umbral es arbitrario.

La siguiente imagen muestra la distribución de valores que hemos definido como presuntamente Positivos y los presuntamente Negativos. Si superan ese umbral se convierten en Falsos Positivos o Falsos Negativos.

En las siguientes gráficas vamos a ver como afecta a nuestro modelo el variar el umbral.

Vamos a explicar cada columna de la imagen anterior:

  • 1º Columna: Se muestra la distribución de los Positivos y los Negativos que ha hecho el modelo. Pero según el umbral podrán ser True Positive (TP), True Negative (TN),False Positive (FP) y False Negative (FN)
  • 2º Columna: Se muestra como evolucionan los True Positive (TP), True Negative (TN),False Positive (FP) y False Negative (FN) según se modificara el umbral. Para ello para cada umbral entre 0 y 1:
    • Se cuenta cuantos Positivos hay bajo el umbral que serán los False Positive (FP)
    • Se cuenta cuantos Positivos hay sobre el umbral que serán los True Positive (TP)
    • Se cuenta cuantos Negativos hay bajo el umbral que serán los True Negative (TN)
    • Se cuenta cuantos Negativos hay sobre el umbral que serán los False Negative (FN)
  • 3º Columna: Se calculan las métricas de True Positive Rate (TPR) y False Positive Rate (FPR) según las siguientes fórmulas:

\begin{align} True \: Positive \: Rate \: (TPR) &= \frac{TP}{TP+FN} \\ False \: Positive \: Rate \: (FPR) &= \frac{FP}{FP+TN} \end{align}

  • 4º Columna: Muestra el True Positive Rate (TPR) frente a False Positive Rate (FPR). Es decir que cada punto la X de la gráfica es el FPR y la Y de la gráfica es el TPR.

Cada una de las filas de la imagen son predicciones distintas, siendo:

  • 1º Fila: Una predicción perfecta.
  • 2º Fila: Una predicción buena
  • 3º Fila: Una predicción mala en la que falla lo mismo que acierta. Sería como hacerlo aleatorio con un 50% de probabilidades de acertar.
  • 4º Fila: Una predicción nefasta que falla la mayoría de las veces.
  • 5º Fila: Una predicción lamentable que nunca acierta.

Entonces, ¿Que es la Area under the curve (AUC)? Es el área de la curva ROC es decir el área rosa de las gráficas de la última columna. Si nos fijamos cuanto mejor es la predicción, mayor es el área rosa y por lo tanto mayor es la métrica de AUC.

Destacar que se hace uso de la métrica AUC que es una métrica como cualquier otra que tiende a 1 si es buena y a 0 si es mala pero lo que no vas a ver al usar la métrica de AUC es la curva ROC. La curva ROC se muestra para entender que significa la métrica AUC pero no se dibuja normalmente.

En keras podemos usar la métrica de AUC de la siguiente forma: Su uso en Keras es

metrics=[tf.keras.metrics.AUC()]
metrics=["AUC"]

y usarla como

history.history['auc']
history.history['val_auc']

¿que métrica es mejor? Depende del objetivo de tu red neuronal pero si comparamos F1-score vs ROC AUC la regla más sencilla es la siguiente:
  • Si tenemos aproximadamente la misma cantidad de positivos y negativos: Usar ROC AUC
  • Si tenemos más positivos o mas negativos: Usar F1-score

Mas información:

Mas información:

Métricas de clasificación con más de 2 posibles valores

Categorical Crossentropy

Es igual que la función de coste de Categorical Crossentropy, así que no explicaremos nada mas sobre ella excepto como se usa en Keras como métrica excepto recordar que cuanto menor sea su valor es mejor la métrica.

Su uso en keras es:

metrics=[tf.keras.metrics.CategoricalCrossentropy()]
metrics=["categorical_crossentropy"]

y usarla como

history.history['categorical_crossentropy']
history.history['val_categorical_crossentropy']

Mas información:

Categorical Accuracy

Accuracy nos indica la proporción de aciertos que ha tenido. Es decir el porcentaje (en tanto por uno) de verdaderos positivos y verdaderos negativos

Su uso en keras es:

metrics=[tf.keras.metrics.CategoricalAccuracy()]
metrics=["categorical_accuracy"]

y usarla como

history.history['categorical_accuracy']
history.history['val_categorical_accuracy']

Mas información:

Ejercicios

Ejercicio: Media armónica.

Suponemos que un coche hace un viaje de 300 Km y los primeros 100 km va a 70 km/h, los siguientes 100 km a 80 km/h y los últimos 100 km a 90 km/h.

  • Calcula la media aritmética
  • Calcula la media armónica

Repite los cálculos pero ahora con las siguiente velocidades: 40, 80 y 90

clase/iabd/pia/2eval/tema07.metricas.txt · Última modificación: 2022/01/16 19:33 por admin