1. Introduction de la version du package Keras et du package tensorflow
Parce que les versions du package Keras et du package tensorflow doivent correspondre avant de pouvoir être utilisées, et elles doivent également correspondre à la version python avant de pouvoir être utilisées. Mon environnement actuel est python3.5+keras2.1.0+tensorflow1.4.0. Je suggère que si vous ne savez pas comment faire correspondre chaque version, vous pouvez utiliser mon package de support.J'ai utilisé python3.8 avant, et après avoir installé keras et tensorflow, j'ai toujours signalé des erreurs.Il a fallu plusieurs jours d'expérimentation pour configurer avec succès l'environnement. . Veillez ensuite à ne pas installer le package gdal dans cet environnement.Après l'installation du package gdal, une erreur sera signalée.La raison semble être que le package gdal a rétrogradé la version numpy, ce qui a amené keras et tensorflow à signaler des erreurs. C'est mon expérience, vous pouvez vous y référer.
2. Introduction aux fonctions de perte
Le fichier de fonction de perte (losses.py) se trouve dans le dossier du package keras (le mien est dans "D:\Anaconda3\setup\envs\py35_tf1.4.0_keras2.1.0\Lib\site-packages\keras"). Il y a au total
2.1, fonction mean_squared_error
Le code source est :
def mean_squared_error(y_true, y_pred):
return K.mean(K.square(y_pred - y_true), axis=-1)
La formule est :
Donnons un exemple pour voir comment il est calculé.
Hypothèses:
y_true = [[0., 1., 1.], [0., 0., 1.]] ##真实标签
y_pred = [[1., 1., 0], [1., 0., 1]] #预测标签，可见第一个列表里错了2个，第一个列表里错了1个
y_true = tf.convert_to_tensor(y_true) #将列表转成张量
y_pred = tf.convert_to_tensor(y_pred) #将列表转成张量，因为K.square和K.mean的输入类型为张量。
Nous pouvons regarder les types de y_true et y_pred , comme des tenseurs :
type(y_true)
#tensorflow.python.framework.ops.Tensor
type(y_pred)
#tensorflow.python.framework.ops.Tensor
Appelez la fonction mean_squared_error pour calculer :
def mean_squared_error(y_true, y_pred):
return K.mean(K.square(y_pred - y_true),axis=-1)
result = mean_squared_error(y_true, y_pred)
type(result) #查看结果类型，也为张量
#tensorflow.python.framework.ops.Tensor
Ensuite, vérifiez les valeurs spécifiques dans le tenseur de résultat, où tf.Session() doit être appelée en premier. Étant donné que les définitions et les appels de fonction ci-dessus visent uniquement à préparer le contenu requis pour le calcul, à configurer un cadre et à ne pas effectuer de calculs réels, la session peut démarrer les calculs immédiatement. Le résultat d'impression ci-dessous est [0,6666667 0,33333334], indiquant que la perte de la première liste est de 0,67 et celle de la seconde est de 0,33. Cet algorithme est un peu comme le calcul de la variance.
with tf.Session() as sess:
print (result.eval())
#[0.6666667 0.33333334]
2.2, fonction mean_absolute_error
Le code source est :
def mean_absolute_error(y_true, y_pred):
return K.mean(K.abs(y_pred - y_true), axis=-1)
La formule est la suivante :
Identique à l'exemple ci-dessus, la méthode de fonctionnement est la même. Le résultat est [0.6666667 0.33333334], cet algorithme est équivalent au calcul de l'erreur absolue moyenne.
2.3、mean_absolute_percentage_error函数
Le code source est :
def mean_absolute_percentage_error(y_true, y_pred):
diff = K.abs((y_true - y_pred) / K.clip(K.abs(y_true),K.epsilon(),None))
return 100. * K.mean(diff, axis=-1)
La formule est :
Identique à l'exemple ci-dessus, le mode de fonctionnement est le même. Le résultat est [3.3333338e+08 3.3333331e+08]. Ce résultat n'est pas très significatif, mais la formule ressemble au pourcentage d'erreur de prédiction dans l'étiquette réelle.
2.4, fonction mean_squared_logarithmic_error
Le code source est :
def mean_squared_logarithmic_error(y_true, y_pred):
first_log = K.log(K.clip(y_pred, K.epsilon(), None) + 1.)
second_log = K.log(K.clip(y_true, K.epsilon(), None) + 1.)
return K.mean(K.square(first_log - second_log), axis=-1)
La formule est la suivante :
Identique à l'exemple ci-dessus, la méthode de fonctionnement est la même. Le résultat est [0,32030192 0,16015096].
2.5, fonction squared_hinge
Le code source est :
def squared_hinge(y_true, y_pred):
return K.mean(K.square(K.maximum(1. - y_true * y_pred, 0.)), axis=-1)
La formule est :
Le résultat est [0,6666667 0,6666667]. Puisqu'il n'y a que deux valeurs de 0 et 1, y_true * y_pred équivaut à définir la prédiction correcte sur 1, et la mauvaise prédiction sur 0, puis 1. - y_true * y_pred l'inverse pour obtenir la mauvaise prédiction .
2.5, fonction charnière
Le code source est :
def hinge(y_true, y_pred):
return K.mean(K.maximum(1. - y_true * y_pred, 0.), axis=-1)
La formule est :
Le résultat est [0,6666667 0,6666667].
2.6, fonction categorical_hinge
Le code source est :
def categorical_hinge(y_true, y_pred):
pos = K.sum(y_true * y_pred, axis=-1)
neg = K.max((1. - y_true) * y_pred, axis=-1)
return K.maximum(0., neg - pos + 1.)
La formule est la même que la fonction charnière. pos indique le nombre de places où la valeur réelle est 1 est correctement prédite comme 1, et neg est le nombre de places où la valeur réelle est 0 est prédite à tort comme 1. Le résultat est [1. 1.]
2.7, fonction logcosh
Le code source est :
def logcosh(y_true, y_pred):
"""Logarithm of the hyperbolic cosine of the prediction error.
`log(cosh(x))` is approximately equal to `(x ** 2) / 2` for small `x` and
to `abs(x) - log(2)` for large `x`. This means that 'logcosh' works mostly
like the mean squared error, but will not be so strongly affected by the
occasional wildly incorrect prediction. However, it may return NaNs if the
intermediate value `cosh(y_pred - y_true)` is too large to be represented
in the chosen precision.
"""
def cosh(x):
return (K.exp(x) + K.exp(-x)) / 2
return K.mean(K.log(cosh(y_pred - y_true)), axis=-1)
Logarithme du cosinus hyperbolique de l'erreur de prévision. Le résultat est [0,2891872 0,1445936]
2.8, fonction categorical_crossentropy
Le code source est :
def categorical_crossentropy(y_true, y_pred):
return K.categorical_crossentropy(y_true, y_pred)
Pour un code source plus détaillé, voir .\Lib\site-packages\keras\backend\cntk_backend.py, comme suit :
def categorical_crossentropy(target, output, from_logits=False):
if from_logits:
result = C.cross_entropy_with_softmax(output, target)
# cntk's result shape is (batch, 1), while keras expect (batch, )
return C.reshape(result, ())
else:
# scale preds so that the class probas of each sample sum to 1
output /= C.reduce_sum(output, axis=-1)
# avoid numerical instability with epsilon clipping
output = C.clip(output, epsilon(), 1.0 - epsilon())
return -sum(target * C.log(output), axis=-1)
Lorsque vous utilisez la perte categorical_crossentropy, votre valeur cible doit être au format catégoriel (c'est-à-dire que si vous avez 10 classes, la valeur cible pour chaque échantillon doit être un vecteur à 10 dimensions avec un indice de 1, sauf pour celui représentant la catégorie, et le les autres sont tous à 0).
2.9, fonction sparse_categorical_crossentropy
Le code source est :
def sparse_categorical_crossentropy(target, output, from_logits=False):
target = C.one_hot(target, output.shape[-1])
target = C.reshape(target, output.shape)
return categorical_crossentropy(target, output, from_logits)
La signification est similaire à categorical_crossentropy.
2.10, fonction binary_crossentropy
Le code source est :
def binary_crossentropy(target, output, from_logits=False):
if from_logits:
output = C.sigmoid(output)
output = C.clip(output, epsilon(), 1.0 - epsilon())
output = -target * C.log(output) - (1.0 - target) * C.log(1.0 - output)
return output
Entropie croisée pour la classification binaire.
2.11, fonction kullback_leibler_divergence
Le code source est :
def kullback_leibler_divergence(y_true, y_pred):
y_true = K.clip(y_true, K.epsilon(), 1)
y_pred = K.clip(y_pred, K.epsilon(), 1)
return K.sum(y_true * K.log(y_true / y_pred), axis=-1)
Perte de calcul de divergence KL
2.12, fonction de poisson
Le code source est :
def poisson(y_true, y_pred):
return K.mean(y_pred - y_true * K.log(y_pred + K.epsilon()), axis=-1)
Fonction de perte de Poisson
2.13, fonction cosinus_proximité
Le code source est :
def cosine_proximity(y_true, y_pred):
y_true = K.l2_normalize(y_true, axis=-1)
y_pred = K.l2_normalize(y_pred, axis=-1)
return -K.sum(y_true * y_pred, axis=-1)
2.14, fonction cosinus_proximity
Le code source est :
def cosine_proximity(y_true, y_pred):
y_true = K.l2_normalize(y_true, axis=-1)
y_pred = K.l2_normalize(y_pred, axis=-1)
return -K.sum(y_true * y_pred, axis=-1)