¿Qué función define la precisión en Keras cuando la pérdida es el error cuadrático medio (MSE)?

Resuelto Endre Moen asked hace 6 años • 3 respuestas

¿Cómo se define la precisión cuando la función de pérdida es el error cuadrático medio? ¿Es un error porcentual absoluto ?

El modelo que uso tiene activación de salida lineal y está compilado conloss= mean_squared_error

model.add(Dense(1))
model.add(Activation('linear'))  # number

model.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy'])

y la salida se ve así:

Epoch 99/100
1000/1000 [==============================] - 687s 687ms/step - loss: 0.0463 - acc: 0.9689 - val_loss: 3.7303 - val_acc: 0.3250
Epoch 100/100
1000/1000 [==============================] - 688s 688ms/step - loss: 0.0424 - acc: 0.9740 - val_loss: 3.4221 - val_acc: 0.3701

Entonces, ¿qué significa, por ejemplo, val_acc: 0,3250? Mean_squared_error debería ser un escalar, no un porcentaje, ¿no es así? Entonces, ¿val_acc es error cuadrático medio, error porcentual medio u otra función?

De la definición de MSE en wikipedia: https://en.wikipedia.org/wiki/Mean_squared_error

El MSE es una medida de la calidad de un estimador; siempre es no negativo y los valores más cercanos a cero son mejores.

¿Eso significa que un valor de val_acc: 0.0es mejor que val_acc: 0.325?

editar: más ejemplos del resultado de la métrica de precisión cuando entreno, donde la precisión aumenta a medida que entreno más. Mientras que la función de pérdida, mse debería disminuir. ¿Está bien definida la precisión para mse y cómo se define en Keras?

lAllocator: After 14014 get requests, put_count=14032 evicted_count=1000 eviction_rate=0.0712657 and unsatisfied allocation rate=0.071714
1000/1000 [==============================] - 453s 453ms/step - loss: 17.4875 - acc: 0.1443 - val_loss: 98.0973 - val_acc: 0.0333
Epoch 2/100
1000/1000 [==============================] - 443s 443ms/step - loss: 6.6793 - acc: 0.1973 - val_loss: 11.9101 - val_acc: 0.1500
Epoch 3/100
1000/1000 [==============================] - 444s 444ms/step - loss: 6.3867 - acc: 0.1980 - val_loss: 6.8647 - val_acc: 0.1667
Epoch 4/100
1000/1000 [==============================] - 445s 445ms/step - loss: 5.4062 - acc: 0.2255 - val_loss: 5.6029 - val_acc: 0.1600
Epoch 5/100
783/1000 [======================>.......] - ETA: 1:36 - loss: 5.0148 - acc: 0.2306
Endre Moen avatar Feb 14 '18 03:02 Endre Moen
Aceptado

Hay al menos dos problemas distintos con su pregunta.

La primera ya debería quedar clara a partir de los comentarios del Dr. Snoopy y la otra respuesta: la precisión no tiene sentido en un problema de regresión, como el suyo; vea también el comentario de patyork en este hilo de Keras . Para bien o para mal, el hecho es que Keras no le "protegerá" ni a usted ni a ningún otro usuario de introducir solicitudes sin sentido en su código, es decir, no recibirá ningún error, ni siquiera una advertencia, de que está intentando algo que no lo hace. no tiene sentido, como solicitar la precisión en un entorno de regresión.

Aclarado eso, la otra cuestión es:

Dado que Keras efectivamente devuelve una "precisión", incluso en una configuración de regresión, ¿qué es exactamente y cómo se calcula?

Para arrojar algo de luz aquí, volvamos a un conjunto de datos público (ya que no proporciona ningún detalle sobre sus datos), es decir, el conjunto de datos de precios de la vivienda de Boston (guardado localmente como housing.csv), y ejecutemos un experimento simple de la siguiente manera:

import numpy as np
import pandas
import keras

from keras.models import Sequential
from keras.layers import Dense

# load dataset
dataframe = pandas.read_csv("housing.csv", delim_whitespace=True, header=None)
dataset = dataframe.values
# split into input (X) and output (Y) variables
X = dataset[:,0:13]
Y = dataset[:,13]

model = Sequential()
model.add(Dense(13, input_dim=13, kernel_initializer='normal', activation='relu'))
model.add(Dense(1, kernel_initializer='normal'))
# Compile model asking for accuracy, too:
model.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy'])

model.fit(X, Y,
     batch_size=5,
     epochs=100,
     verbose=1)

Como en su caso, el historial de ajuste del modelo (que no se muestra aquí) muestra una pérdida decreciente y una precisión que aumenta aproximadamente. Evaluemos ahora el rendimiento del modelo en el mismo conjunto de entrenamiento, utilizando la función incorporada de Keras adecuada:

score = model.evaluate(X, Y, verbose=0)
score
# [16.863721372581754, 0.013833992168483997]

El contenido exacto de la scorematriz depende de lo que hayamos solicitado exactamente durante la compilación del modelo; En nuestro caso, el primer elemento es la pérdida (MSE) y el segundo es la "precisión".

En este punto, echemos un vistazo a la definición de Keras binary_accuracyen el metrics.pyarchivo :

def binary_accuracy(y_true, y_pred):
    return K.mean(K.equal(y_true, K.round(y_pred)), axis=-1)

Entonces, después de que Keras haya generado las predicciones y_pred, primero las redondea y luego verifica cuántas de ellas son iguales a las etiquetas verdaderas y_true, antes de obtener la media.

Repitamos esta operación usando código simple Python y Numpy en nuestro caso, donde las etiquetas verdaderas son Y:

y_pred = model.predict(X)
l = len(Y)
acc = sum([np.round(y_pred[i])==Y[i] for i in range(l)])/l
acc
# array([0.01383399])

¡Pues bingo! En realidad, este es el mismo valor devuelto por score[1]arriba...

Para abreviar la historia: dado que usted solicita (erróneamente) metrics=['accuracy']en la compilación de su modelo, Keras hará todo lo posible para satisfacerlo y le devolverá cierta "precisión", calculada como se muestra arriba, a pesar de que esto no tiene ningún significado en su entorno.


Hay bastantes configuraciones en las que Keras, bajo el capó, realiza operaciones bastante sin sentido sin dar ninguna pista o advertencia al usuario; dos de ellos que me he encontrado son:

  • Dando resultados sin sentido cuando, en una configuración de múltiples clases, uno solicita loss='binary_crossentropy'(en lugar de categorical_crossentropy) con metrics=['accuracy']: ¿ve mis respuestas en Rendimiento de Keras binario_crossentropy vs categorical_crossentropy? y ¿ Por qué binario_crossentropy es más preciso que categorical_crossentropy para la clasificación multiclase en Keras?

  • Deshabilitar completamente el abandono, en el caso extremo cuando uno solicita una tasa de abandono de 1.0; vea mi respuesta en Comportamiento de abandono en Keras con tasa = 1 (eliminando todas las unidades de entrada) no como se esperaba

desertnaut avatar Feb 14 '2018 13:02 desertnaut

La función de pérdida (error cuadrático medio en este caso) se utiliza para indicar en qué medida se desvían sus predicciones de los valores objetivo. En la fase de entrenamiento, los pesos se actualizan en función de esta cantidad. Si se trata de un problema de clasificación, es bastante común definir una métrica adicional llamada precisión. Supervisa en cuántos casos se predijo la clase correcta. Esto se expresa como un valor porcentual. En consecuencia, un valor de 0,0 significa que no hay ninguna decisión correcta y 1,0 sólo significa que hay decisiones correctas. Mientras su red se entrena, la pérdida disminuye y, por lo general, la precisión aumenta.

Tenga en cuenta que, a diferencia de la pérdida, la precisión generalmente no se utiliza para actualizar los parámetros de su red. Ayuda a monitorear el progreso del aprendizaje y el rendimiento actual de la red.

BGraf avatar Feb 13 '2018 22:02 BGraf

@desertnaut lo ha dicho muy claro.

Considere los siguientes dos fragmentos de código

compilar código

código de precisión binaria

def binary_accuracy(y_true, y_pred):
    return K.mean(K.equal(y_true, K.round(y_pred)), axis=-1)

Sus etiquetas deben ser números enteros, porque keras no redondea y_true y obtiene una alta precisión...

minghigh avatar Feb 14 '2018 14:02 minghigh