Fonctions de perte personnalisées

Machine Learning pour la finance en Python

Nathan George

Data Science Professor

désaccord de direction

MSE avec pénalité directionnelle

Si la direction de la prédiction et de la cible correspond :

$ \sum(y - \hat{y})^2$

Sinon :

$\sum (y - \hat{y})^2 * \text{penalty} $

Implémenter des fonctions de perte

import tensorflow as tf

Créer une fonction

import tensorflow as tf

# create loss function
def mean_squared_error(y_true, y_pred):

Perte MSE (erreur quadratique moyenne)

import tensorflow as tf

# create loss function
def mean_squared_error(y_true, y_pred):

    loss = tf.square(y_true - y_pred)
    return tf.reduce_mean(loss, axis=-1)

Ajouter une perte personnalisée à Keras

import tensorflow as tf

# create loss function
def mean_squared_error(y_true, y_pred):
    loss = tf.square(y_true - y_pred)
    return tf.reduce_mean(loss, axis=-1)

# enable use of loss with keras
import keras.losses
keras.losses.mean_squared_error = mean_squared_error

# fit the model with our mse loss function
model.compile(optimizer='adam', loss=mean_squared_error)
history = model.fit(scaled_train_features, train_targets, epochs=50)

Vérifier la bonne direction

tf.less(y_true * y_pred, 0)

Bonne direction :

neg * neg = pos
pos * pos = pos

Mauvaise direction :

neg * pos = neg
pos * neg = neg

Utiliser tf.where()

# create loss function
def sign_penalty(y_true, y_pred):
    penalty = 10.
    loss = tf.where(tf.less(y_true * y_pred, 0), 
                    penalty * tf.square(y_true - y_pred), 
                    tf.square(y_true - y_pred))

Assembler le tout

# create loss function
def sign_penalty(y_true, y_pred):
    penalty = 100.
    loss = tf.where(tf.less(y_true * y_pred, 0),
                    penalty * tf.square(y_true - y_pred), 
                    tf.square(y_true - y_pred))

    return tf.reduce_mean(loss, axis=-1)

# enable use of loss with keras
keras.losses.sign_penalty = sign_penalty

Utiliser la perte personnalisée

# create the model
model = Sequential()
model.add(Dense(50,
                input_dim=scaled_train_features.shape[1],
                activation='relu'))
model.add(Dense(10, activation='relu'))
model.add(Dense(1, activation='linear'))

# fit the model with our custom 'sign_penalty' loss function
model.compile(optimizer='adam', loss=sign_penalty)
history = model.fit(scaled_train_features, train_targets, epochs=50)

La forme en nœud papillon

train_preds = model.predict(scaled_train_features)
# scatter the predictions vs actual
plt.scatter(train_preds, train_targets)
plt.xlabel('predictions')
plt.ylabel('actual')
plt.show()

graphique en nœud papillon

Créez votre propre fonction de perte !

Machine Learning pour la finance en Python