Analyse de régression multiple avec Keras

J'ai essayé une simple analyse de régression multiple avec deep learning (ou Keras). L'apprentissage en profondeur a l'image de problèmes de classification et d'apprentissage par renforcement, mais cela ne signifie pas que l'analyse de régression n'est pas possible. Les réseaux de neurones sont également utilisés pour l'analyse de régression, il s'agit donc d'une tentative pour effectuer également une analyse de régression dans l'apprentissage en profondeur.

Le code que j'ai créé est ici. https://github.com/shibuiwilliam/keras_regression_sample

Que faire cette fois

L'analyse de régression multiple est effectuée à l'aide de l'API Keras Regressor de Keras. Les données sont des échantillons de données de patients diabétiques fournis par scikit-learn. Il est souvent utilisé dans l'analyse de régression, et ce sont des données petites et pratiques.

Le but de ce temps est d'écrire une procédure pour effectuer une analyse de régression en deep learning ou en réseau neuronal. Cependant, la création d'un modèle d'analyse de régression avec apprentissage en profondeur n'améliore pas la précision.

Veuillez également noter que cette fois, l'analyse de régression n'est pas une prédiction de données numériques de séries chronologiques par RNN ou LSTM.

Supplément: à propos de l'apprentissage automatique

Si vous positionnez le modèle d'apprentissage automatique et d'apprentissage en profondeur ** très approximativement **, il ressemblera à ceci.

１.png

Je ne pense pas que ce soit tout, car de nouveaux papiers et modèles sont proposés quotidiennement, mais c'est une image approximative. Cette fois, nous allons faire DNN.

Préparation préalable

Chargez les données comme préparation préliminaire.

# import libraries
import numpy as np
import pandas as pds
from keras.models import Sequential
from keras.layers import Input, Dense, Dropout, BatchNormalization
from keras.wrappers.scikit_learn import KerasRegressor
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.metrics import mean_squared_error
from sklearn.datasets import load_diabetes

# use diabetes sample data from sklearn
diabetes = load_diabetes()

# load them to X and Y
X = diabetes.data
Y = diabetes.target

Des données comme celle-ci seront chargées.

Il semble que cela ait déjà été normalisé. Il s'agit d'un petit échantillon de données avec 442 lignes et 10 variables d'entrée.

Voir ici pour plus de détails sur les données. http://web.stanford.edu/~hastie/Papers/LARS/LeastAngle_2002.pdf

KerasRegressor Keras fournit une API pour l'analyse de régression appelée Keras Regressor. https://keras.io/ja/scikit-learn-api/

Keras lui-même ne donne pas beaucoup de détails, mais le fait est qu'il semble être un wrapper pour le modèle de régression de scicit-learn. Peut-être que Keras Regressor a été créé pour être utilisé avec une API de métrique pratique pour l'analyse de régression scikit-learn (telle que cross_val_score ou mean_squared_error).

La manière d'écrire un modèle de réseau neuronal est Keras lui-même. Tout d'abord, créons un modèle simple (une couche d'entrée, une couche intermédiaire et une couche de sortie).

# create regression model
def reg_model():
    model = Sequential()
    model.add(Dense(10, input_dim=10, activation='relu'))
    model.add(Dense(16, activation='relu'))
    model.add(Dense(1))

    # compile model
    model.compile(loss='mean_squared_error', optimizer='adam')
    return model

En prenant un résumé, cela ressemble à ceci.

Jusqu'à présent, le Keras conventionnel reste le même. La différence avec le passé est de savoir comment écrire en forme lors de l'apprentissage.

Il existe à peu près deux façons d'apprendre.

Apprenez en séparant les données d'entraînement et les données de test
Apprentissage par vérification croisée

Il semble qu'une méthode générale puisse être utilisée pour l'analyse de régression.

Exemple 1 Apprentissage en séparant les données d'entraînement et les données de test

Apprenons le modèle simple ci-dessus séparément des données d'entraînement et des données de test.

# use data split and fit to run the model
x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.1, random_state=0)
estimator = KerasRegressor(build_fn=reg_model, epochs=100, batch_size=10, verbose=0)
estimator.fit(x_train, y_train)
y_pred = estimator.predict(x_test)

# show its root mean square error
mse = mean_squared_error(y_test, y_pred)
print("KERAS REG RMSE : %.2f" % (mse ** 0.5))

Enfin, la sortie standard donne la racine quadratique moyenne. Le style d'écriture est de type scikit-learn (mais Keras est de type scikit-learn en premier lieu).

Exemple 2 Apprentissage par vérification croisée

Continuons à apprendre avec la vérification croisée.

# use Kfold and cross validation to run the model
seed = 7
np.random.seed(seed)
estimator = KerasRegressor(build_fn=reg_model, epochs=100, batch_size=10, verbose=0)
kfold = KFold(n_splits=10, random_state=seed)

# show its root mean square error
results = cross_val_score(estimator, X, Y, scoring='neg_mean_squared_error', cv=kfold)
mse = -results.mean()
print("KERAS REG RMSE : %.2f" % (mse ** 0.5))

Ici aussi, la racine carrée de l'erreur quadratique moyenne est calculée à la fin. Organisons chaque résultat.

Eh bien, cela ne fait pas beaucoup de différence.

Essayons d'approfondir la couche réseau

Jusqu'à présent, j'ai effectué une analyse de régression multiple avec un simple réseau de neurones. Essayons maintenant d'approfondir la couche réseau.

# create deep learning like regression model
def deep_reg_model():
    model = Sequential()
    model.add(Dense(10, input_dim=10, activation='relu'))
    model.add(BatchNormalization())
    model.add(Dropout(0.2))
    model.add(Dense(256, activation='relu'))
    model.add(BatchNormalization())
    model.add(Dropout(0.2))
    model.add(Dense(128, activation='relu'))
    model.add(BatchNormalization())
    model.add(Dropout(0.2))
    model.add(Dense(64, activation='relu'))
    model.add(BatchNormalization())
    model.add(Dropout(0.2))
    model.add(Dense(1))

    # compile model
    model.compile(loss='mean_squared_error', optimizer='adam')
    return model

Comme c'est un gros problème, j'ai ajouté la normalisation par lots et l'abandon.

Apprenons.

# use data split and fit to run the model
x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.1, random_state=0)
estimator = KerasRegressor(build_fn=deep_reg_model, epochs=100, batch_size=10, verbose=0)
estimator.fit(x_train, y_train)
y_pred = estimator.predict(x_test)

# show its root mean square error
mse = mean_squared_error(y_test, y_pred)
print("KERAS REG RMSE : %.2f" % (mse ** 0.5))


# use Kfold and cross validation to run the model
seed = 7
np.random.seed(seed)
estimator = KerasRegressor(build_fn=deep_reg_model, epochs=100, batch_size=10, verbose=0)
kfold = KFold(n_splits=10, random_state=seed)

# show its root mean square error
results = cross_val_score(estimator, X, Y, scoring='neg_mean_squared_error', cv=kfold)
mse = -results.mean()
print("KERAS REG RMSE : %.2f" % (mse ** 0.5))

Ce n'est pas très différent d'un simple réseau. Compte tenu du temps de calcul, il ne sert à rien de l'approfondir.

finalement

J'ai essayé l'analyse de régression multiple avec Keras Regressor. Il y a peut-être beaucoup de gens qui ont essayé la même chose, mais la raison pour laquelle il n'y a pas beaucoup d'exemples de google est probablement parce que la précision ne s'est pas améliorée de manière spectaculaire (Nageyari). Eh bien, si vous essayez avec des données plus volumineuses et plus complexes, vous pourrez peut-être dire quelque chose de différent, donc si vous trouvez des données qui semblent bonnes, essayez à nouveau.

référence

https://keras.io/ja/scikit-learn-api/ http://machinelearningmastery.com/regression-tutorial-keras-deep-learning-library-python/ http://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_diabetes.html http://qiita.com/TomokIshii/items/f355d8e87d23ee8e0c7a http://s0sem0y.hatenablog.com/entry/2016/05/22/215529

[PYTHON] Analyse de régression multiple avec Keras