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

machine-learning regression

Question

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

El modelo que uso tiene activación de salida lineal y está compilado con loss= 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? Entonces, ¿es val_acc: error cuadrático medio o error de porcentaje 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.

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

editar: más ejemplos de la salida 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. ¿La precisión está bien definida 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

Answer 1

Hay al menos dos problemas separados con su pregunta.

El primero debería estar claro a partir de los comentarios de Matias y la otra respuesta: la precisión no es significativa 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 lo "protegerá" a usted ni a ningún otro usuario para que no presente solicitudes no significativas en su código, es decir, no recibirá ningún error, ni siquiera una advertencia, de que está intentando algo que sí lo hace. no tiene sentido, como solicitar la precisión en una configuración de regresión.

Habiendo aclarado eso, el otro problema es:

Dado que Keras realmente 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 del precio de la vivienda de Boston (guardado localmente como housing.csv ), y realice 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 (no mostrado aquí) muestra una pérdida decreciente y una precisión que aumenta aproximadamente. Vamos a evaluar ahora el rendimiento del modelo en el mismo conjunto de entrenamiento, utilizando la función incorporada Keras adecuada:

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

El contenido exacto de la matriz de score depende de lo que hayamos solicitado exactamente durante la compilación del modelo; en nuestro caso aquí, 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_accuracy en el archivo binary_accuracy :

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 ha 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 de 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])

Bueno, bingo! Este es en realidad el mismo valor devuelto por la score[1] anterior ...

En resumen: dado que usted (erróneamente) solicita 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 esto ser completamente sin sentido en su entorno.

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

• Dando resultados sin sentido cuando, en un entorno de múltiples clases, uno solicita la loss=''binary_crossentropy'' (en lugar de categorical_crossentropy ) con metrics=[''accuracy''] - ¿ve mis respuestas en Keras binary_crossentropy vs categorical_crossentropy performance? y ¿Por qué la binary_crossentropy es más precisa 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 (descartando todas las unidades de entrada) no como se esperaba

Answer 2

La función de pérdida (error cuadrático medio en este caso) se utiliza para indicar qué tan lejos 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. Monitorea 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 una decisión correcta y 1.0 solo decisiones correctas. Mientras su red está entrenando, la pérdida disminuye y, por lo general, aumenta la precisión.

Tenga en cuenta que, en contraste con 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.

Answer 3

@desertnaut ha dicho muy claramente

Considere las siguientes dos piezas 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)

Tus etiquetas deben ser enteras, porque keras no redondea y_verdadero , y obtienes una alta precisión .......