Régression linéaire avec TensorFlow (exemples)

Table des matières:

Anonim

Qu'est-ce que la régression linéaire?

La régression linéaire est une approche en statistique pour modéliser les relations entre deux variables. Cette modélisation se fait entre une réponse scalaire et une ou plusieurs variables explicatives. La relation avec une variable explicative est appelée régression linéaire simple et pour plus d'une variable explicative, elle est appelée régression linéaire multiple.

TensorFlow fournit des outils pour avoir un contrôle total des calculs. Cela se fait avec l'API de bas niveau. En plus de cela, TensorFlow est équipé d'une vaste gamme d'API pour exécuter de nombreux algorithmes d'apprentissage automatique. Il s'agit de l'API de haut niveau. TensorFlow les appelle des estimateurs

  • API de bas niveau: Construisez l'architecture, optimisation du modèle à partir de zéro. C'est compliqué pour un débutant
  • API de haut niveau: définissez l'algorithme. C'est plus simple. TensorFlow fournit un estimateur d' appels de boîte à outils pour construire, former, évaluer et faire une prédiction.

Dans ce didacticiel, vous utiliserez uniquement les estimateurs . Les calculs sont plus rapides et plus faciles à mettre en œuvre. La première partie du didacticiel explique comment utiliser l'optimiseur de descente de gradient pour entraîner une régression linéaire dans TensorFlow. Dans une seconde partie, vous utiliserez l'ensemble de données Boston pour prédire le prix d'une maison à l'aide de l'estimateur TensorFlow.

Télécharger Boston DataSet

Dans ce didacticiel sur la régression TensorFlow, vous apprendrez:

  • Qu'est-ce que la régression linéaire?
  • Comment entraîner un modèle de régression linéaire
  • Comment entraîner une régression linéaire avec TensorFlow
  • Pandas
  • Solution Numpy
  • Solution Tensorflow

Comment entraîner un modèle de régression linéaire

Avant de commencer à entraîner le modèle, voyons ce qu'est une régression linéaire.

Imaginez que vous ayez deux variables, x et y et que votre tâche consiste à prédire la valeur de la connaissance de la valeur de. Si vous tracez les données, vous pouvez voir une relation positive entre votre variable indépendante, x et votre variable dépendante y.

Vous pouvez observer que si x = 1, y sera à peu près égal à 6 et si x = 2, y sera d'environ 8,5.

Ce n'est pas une méthode très précise et sujette à des erreurs, en particulier avec un ensemble de données avec des centaines de milliers de points.

Une régression linéaire est évaluée avec une équation. La variable y est expliquée par une ou plusieurs covariables. Dans votre exemple, il n'y a qu'une seule variable dépendante. Si vous devez écrire cette équation, ce sera:

Avec:

  • est le poids associé à x
  • est le résidu ou l'erreur du modèle. Il comprend ce que le modèle ne peut pas apprendre des données

Imaginez que vous adaptez le modèle et que vous trouvez la solution suivante pour:

  • = 3,8
  • = 2,78

Vous pouvez remplacer ces nombres dans l'équation et cela devient:

y = 3,8 + 2,78x

Vous disposez désormais d'un meilleur moyen de trouver les valeurs de y. Autrement dit, vous pouvez remplacer x par n'importe quelle valeur que vous souhaitez prédire y. Dans l'image ci-dessous, nous avons remplacé x dans l'équation par toutes les valeurs de l'ensemble de données et tracé le résultat.

La ligne rouge représente la valeur ajustée, c'est-à-dire les valeurs de y pour chaque valeur de x. Vous n'avez pas besoin de voir la valeur de x pour prédire y, pour chaque x il y en a qui appartient à la ligne rouge. Vous pouvez également prévoir des valeurs de x supérieures à 2!

Si vous souhaitez étendre la régression linéaire à plus de covariables, vous pouvez en ajoutant plus de variables au modèle. La différence entre l'analyse traditionnelle et la régression linéaire est que la régression linéaire examine comment y réagira pour chaque variable x prise indépendamment.

Voyons un exemple. Imaginez que vous vouliez prédire les ventes d'un glacier. L'ensemble de données contient différentes informations telles que la météo (c'est-à-dire pluvieux, ensoleillé, nuageux), les informations client (c'est-à-dire salaire, sexe, état matrimonial).

L'analyse traditionnelle tentera de prédire la vente en calculant la moyenne de chaque variable et tentera d'estimer la vente pour différents scénarios. Cela conduira à de mauvaises prévisions et limitera l'analyse au scénario choisi.

Si vous utilisez la régression linéaire, vous pouvez écrire cette équation:

L'algorithme trouvera la meilleure solution pour les poids; cela signifie qu'il essaiera de minimiser le coût (la différence entre la ligne ajustée et les points de données).

Comment fonctionne l'algorithme

L'algorithme choisira un nombre aléatoire pour chacun et remplacera la valeur de x pour obtenir la valeur prédite de y. Si l'ensemble de données contient 100 observations, l'algorithme calcule 100 valeurs prédites.

On peut calculer l'erreur, notée du modèle, qui est la différence entre la valeur prédite et la valeur réelle. Une erreur positive signifie que le modèle sous-estime la prédiction de y, et une erreur négative signifie que le modèle surestime la prédiction de y.

Votre objectif est de minimiser le carré de l'erreur. L'algorithme calcule la moyenne de l'erreur quadratique. Cette étape est appelée minimisation de l'erreur. Pour la régression linéaire, il y a l' erreur quadratique moyenne , également appelée MSE. Mathématiquement, c'est:

Où:

  • fait donc référence à la valeur prédite
  • y est les vraies valeurs
  • m est le nombre d'observations

Notez que est la notation mathématique de la moyenne.

Le but est de trouver le meilleur qui minimise la MSE

Si l'erreur moyenne est importante, cela signifie que le modèle fonctionne mal et que les poids ne sont pas choisis correctement. Pour corriger les poids, vous devez utiliser un optimiseur. L'optimiseur traditionnel s'appelle Gradient Descent .

La descente de gradient prend la dérivée et diminue ou augmente le poids. Si le dérivé est positif, le poids est diminué. Si le dérivé est négatif, le poids augmente. Le modèle mettra à jour les poids et recalculera l'erreur. Ce processus est répété jusqu'à ce que l'erreur ne change plus. Chaque processus est appelé une itération . De plus, les dégradés sont multipliés par un taux d'apprentissage. Il indique la vitesse de l'apprentissage.

Si le taux d'apprentissage est trop petit, il faudra beaucoup de temps pour que l'algorithme converge (c'est-à-dire qu'il nécessite de nombreuses itérations). Si le taux d'apprentissage est trop élevé, l'algorithme risque de ne jamais converger.

Vous pouvez voir sur l'image ci-dessus, le modèle répète le processus environ 20 fois avant de trouver une valeur stable pour les poids, atteignant ainsi l'erreur la plus faible.

Notez que l'erreur n'est pas égale à zéro mais se stabilise autour de 5. Cela signifie que le modèle fait une erreur typique de 5. Si vous souhaitez réduire l'erreur, vous devez ajouter plus d'informations au modèle, telles que plus de variables ou utiliser différents estimateurs.

Tu te souviens de la première équation

Les poids finaux sont de 3,8 et 2,78. La vidéo ci-dessous vous montre comment la descente de gradient optimise la fonction de perte pour trouver ces poids

Comment entraîner une régression linéaire avec TensorFlow

Maintenant que vous avez une meilleure compréhension de ce qui se passe derrière le capot, vous êtes prêt à utiliser l'API d'estimation fournie par TensorFlow pour entraîner votre première régression linéaire à l'aide de TensorFlow.

Vous utiliserez l'ensemble de données Boston, qui comprend les variables suivantes

crim taux de criminalité par habitant par ville
zn proportion de terrains résidentiels zonés pour les lots de plus de 25 000 pi.ca.
indus proportion d'acres commerciaux non commerciaux par ville.
nox concentration d'oxydes nitriques
rm nombre moyen de pièces par logement
âge proportion de logements occupés par leur propriétaire construits avant 1940
dis distances pondérées jusqu'à cinq centres d'emploi de Boston
impôt taux d'imposition foncière de la valeur totale par tranche de 10000 dollars
ptratio ratio élèves-enseignant par ville
medv Valeur médiane des logements occupés par leur propriétaire en milliers de dollars

Vous allez créer trois ensembles de données différents:

base de données objectif façonner
Formation Former le modèle et obtenir les poids 400, 10
Évaluation Évaluer les performances du modèle sur des données invisibles 100, 10
Prédire Utilisez le modèle pour prédire la valeur de la maison sur de nouvelles données 6, 10

L'objectif est d'utiliser les caractéristiques de l'ensemble de données pour prédire la valeur de la maison.

Au cours de la deuxième partie du didacticiel, vous apprendrez à utiliser TensorFlow avec trois méthodes différentes pour importer les données:

  • Avec les pandas
  • Avec Numpy
  • Seulement TF

Notez que toutes les options fournissent les mêmes résultats.

Vous apprendrez à utiliser l'API de haut niveau pour créer, former et évaluer un modèle de régression linéaire TensorFlow. Si vous utilisiez l'API de bas niveau, vous deviez définir à la main:

  • Fonction de perte
  • Optimiser: descente de gradient
  • Multiplication des matrices
  • Graphique et tenseur

C'est fastidieux et plus compliqué pour les débutants.

Pandas

Vous devez importer les bibliothèques nécessaires pour entraîner le modèle.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools

Étape 1) Importez les données avec panda.

Vous définissez les noms de colonnes et les stockez dans COLUMNS. Vous pouvez utiliser pd.read_csv () pour importer les données.

COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age","dis", "tax", "ptratio", "medv"]

training_set = pd.read_csv ("E: /boston_train.csv", skipinitialspace = True, skiprows = 1, names = COLUMNS)

test_set = pd.read_csv ("E: /boston_test.csv", skipinitialspace = True, skiprows = 1, names = COLUMNS)

prediction_set = pd.read_csv ("E: /boston_predict.csv", skipinitialspace = True, skiprows = 1, names = COLUMNS)

Vous pouvez imprimer la forme des données.

print(training_set.shape, test_set.shape, prediction_set.shape)

Production

(400, 10) (100, 10) (6, 10)

Notez que l'étiquette, c'est-à-dire votre y, est incluse dans l'ensemble de données. Vous devez donc définir deux autres listes. Un contenant uniquement les fonctionnalités et un avec le nom de l'étiquette uniquement. Ces deux listes indiqueront à votre estimateur quelles sont les caractéristiques de l'ensemble de données et quel nom de colonne est le libellé

Cela se fait avec le code ci-dessous.

FEATURES = ["crim", "zn", "indus", "nox", "rm","age", "dis", "tax", "ptratio"]LABEL = "medv"

Étape 2) Convertissez les données

Vous devez convertir les variables numériques au format approprié. Tensorflow fournit une méthode pour convertir une variable continue: tf.feature_column.numeric_column ().

À l'étape précédente, vous définissez une liste d'une fonction que vous souhaitez inclure dans le modèle. Vous pouvez maintenant utiliser cette liste pour les convertir en données numériques. Si vous souhaitez exclure des entités de votre modèle, n'hésitez pas à déposer une ou plusieurs variables dans la liste FEATURES avant de construire les feature_cols

Notez que vous utiliserez la compréhension de liste Python avec la liste FEATURES pour créer une nouvelle liste nommée feature_cols. Cela vous permet d'éviter d'écrire neuf fois tf.feature_column.numeric_column (). Une compréhension de liste est un moyen plus rapide et plus propre de créer de nouvelles listes

feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES]

Étape 3) Définissez l'estimateur

Dans cette étape, vous devez définir l'estimateur. Tensorflow fournit actuellement 6 estimateurs prédéfinis, dont 3 pour la tâche de classification et 3 pour la tâche de régression TensorFlow:

  • Régresseur
    • DNNRegressor
    • LinéaireRégresseur
    • DNNLineaCombinedRegressor
  • Classificateur
    • DNNClassifier
    • LinearClassifier
    • DNNLineaCombinedClassifier

Dans ce didacticiel, vous utiliserez le régresseur linéaire. Pour accéder à cette fonction, vous devez utiliser tf.estimator.

La fonction a besoin de deux arguments:

  • feature_columns: contient les variables à inclure dans le modèle
  • model_dir: chemin pour stocker le graphique, enregistrer les paramètres du modèle, etc.

Tensorflow créera automatiquement un fichier nommé train dans votre répertoire de travail. Vous devez utiliser ce chemin pour accéder à Tensorboard, comme illustré dans l'exemple de régression TensorFlow ci-dessous.

estimator = tf.estimator.LinearRegressor(feature_columns=feature_cols,model_dir="train")

Production

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'train', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': , '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

La partie délicate avec TensorFlow est la façon d'alimenter le modèle. Tensorflow est conçu pour fonctionner avec le calcul parallèle et un très grand ensemble de données. En raison de la limitation des ressources de la machine, il est impossible d'alimenter le modèle avec toutes les données à la fois. Pour cela, vous devez alimenter un lot de données à chaque fois. Notez que nous parlons d'un énorme ensemble de données avec des millions d'enregistrements ou plus. Si vous n'ajoutez pas de lot, vous vous retrouverez avec une erreur de mémoire.

Par exemple, si vos données contiennent 100 observations et que vous définissez une taille de lot de 10, cela signifie que le modèle verra 10 observations pour chaque itération (10 * 10).

Lorsque le modèle a vu toutes les données, il termine une époque . Une époque définit le nombre de fois où vous souhaitez que le modèle voie les données. Il est préférable de définir cette étape sur aucune et de laisser le modèle effectuer le nombre d'itérations.

Une deuxième information à ajouter est si vous souhaitez mélanger les données avant chaque itération. Pendant la formation, il est important de mélanger les données afin que le modèle n'apprenne pas le modèle spécifique de l'ensemble de données. Si le modèle apprend les détails du modèle sous-jacent des données, il aura des difficultés à généraliser la prédiction pour les données invisibles. C'est ce qu'on appelle le surajustement . Le modèle fonctionne bien sur les données d'entraînement, mais ne peut pas prédire correctement les données invisibles.

TensorFlow facilite ces deux étapes. Lorsque les données sont acheminées vers le pipeline, il sait de combien d'observations il a besoin (par lots) et s'il doit mélanger les données.

Pour indiquer à Tensorflow comment alimenter le modèle, vous pouvez utiliser pandas_input_fn. Cet objet a besoin de 5 paramètres:

  • x: données d'objets
  • y: données d'étiquette
  • batch_size: lot. Par défaut 128
  • num_epoch: Nombre d'époques, par défaut 1
  • shuffle: mélanger ou non les données. Par défaut, Aucun

Vous devez alimenter le modèle plusieurs fois afin de définir une fonction pour répéter ce processus. toute cette fonction get_input_fn.

def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):return tf.estimator.inputs.pandas_input_fn(x=pd.DataFrame({k: data_set[k].values for k in FEATURES}),y = pd.Series(data_set[LABEL].values),batch_size=n_batch,num_epochs=num_epochs,shuffle=shuffle)

La méthode habituelle pour évaluer les performances d'un modèle consiste à:

  • Former le modèle
  • Évaluer le modèle dans un autre jeu de données
  • Faire des prédictions

L'estimateur Tensorflow fournit trois fonctions différentes pour effectuer ces trois étapes facilement.

Étape 4) : Former le modèle

Vous pouvez utiliser le train d'estimateurs pour évaluer le modèle. L'estimateur de train a besoin d'un input_fn et d'un certain nombre d'étapes. Vous pouvez utiliser la fonction que vous avez créée ci-dessus pour alimenter le modèle. Ensuite, vous demandez au modèle d'itérer 1000 fois. Notez que vous ne spécifiez pas le nombre d'époques, vous laissez le modèle itérer 1000 fois. Si vous définissez le nombre d'époques sur 1, le modèle effectuera des itérations 4 fois: il y a 400 enregistrements dans l'ensemble d'apprentissage et la taille du lot est de 128

  1. 128 lignes
  2. 128 lignes
  3. 128 lignes
  4. 16 rangs

Par conséquent, il est plus facile de définir le nombre d'époques sur aucune et de définir le nombre d'itérations comme indiqué dans l'exemple de classification TensorFlow ci-dessous.

estimator.train(input_fn=get_input_fn(training_set,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)

Production

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Create CheckpointSaverHook.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Saving checkpoints for 1 into train/model.ckpt.INFO:tensorflow:loss = 83729.64, step = 1INFO:tensorflow:global_step/sec: 238.616INFO:tensorflow:loss = 13909.657, step = 101 (0.420 sec)INFO:tensorflow:global_step/sec: 314.293INFO:tensorflow:loss = 12881.449, step = 201 (0.320 sec)INFO:tensorflow:global_step/sec: 303.863INFO:tensorflow:loss = 12391.541, step = 301 (0.327 sec)INFO:tensorflow:global_step/sec: 308.782INFO:tensorflow:loss = 12050.5625, step = 401 (0.326 sec)INFO:tensorflow:global_step/sec: 244.969INFO:tensorflow:loss = 11766.134, step = 501 (0.407 sec)INFO:tensorflow:global_step/sec: 155.966INFO:tensorflow:loss = 11509.922, step = 601 (0.641 sec)INFO:tensorflow:global_step/sec: 263.256INFO:tensorflow:loss = 11272.889, step = 701 (0.379 sec)INFO:tensorflow:global_step/sec: 254.112INFO:tensorflow:loss = 11051.9795, step = 801 (0.396 sec)INFO:tensorflow:global_step/sec: 292.405INFO:tensorflow:loss = 10845.855, step = 901 (0.341 sec)INFO:tensorflow:Saving checkpoints for 1000 into train/model.ckpt.INFO:tensorflow:Loss for final step: 5925.9873.

Vous pouvez vérifier le Tensorboard sera la commande suivante:

activate hello-tf# For MacOStensorboard --logdir=./train# For Windowstensorboard --logdir=train

Étape 5) Évaluez votre modèle

Vous pouvez évaluer l'ajustement de votre modèle sur l'ensemble de test avec le code ci-dessous:

ev = estimator.evaluate(input_fn=get_input_fn(test_set,num_epochs=1,n_batch = 128,shuffle=False))

Production

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-01:43:13INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-01:43:13INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896

Vous pouvez imprimer la perte avec le code ci-dessous:

loss_score = ev["loss"]print("Loss: {0:f}".format(loss_score))

Production

Loss: 3215.895996

Le modèle a une perte de 3215. Vous pouvez vérifier la statistique récapitulative pour avoir une idée de l'ampleur de l'erreur.

training_set['medv'].describe()

Production

count 400.000000mean 22.625500std 9.572593min 5.00000025% 16.60000050% 21.40000075% 25.025000max 50.000000Name: medv, dtype: float64

D'après la statistique récapitulative ci-dessus, vous savez que le prix moyen d'une maison est de 22 mille, avec un prix minimum de 9 mille et un maximum de 50 mille. Le modèle fait une erreur typique de 3k dollars.

Étape 6) Faites la prédiction

Enfin, vous pouvez utiliser l'estimateur TensorFlow prédire pour estimer la valeur de 6 maisons à Boston.

y = estimator.predict(input_fn=get_input_fn(prediction_set,num_epochs=1,n_batch = 128,shuffle=False))

Pour imprimer les valeurs estimées de, vous pouvez utiliser ce code:

predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions)))

Production

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.Predictions: [array([32.297546], dtype=float32), array([18.96125], dtype=float32), array([27.270979], dtype=float32), array([29.299236], dtype=float32), array([16.436684], dtype=float32), array([21.460876], dtype=float32)]

Le modèle prévoit les valeurs suivantes:

loger

Prédiction

1

32,29

2

18,96

3

27,27

4

29,29

5

16,43

7

21,46

Notez que nous ne connaissons pas la vraie valeur de. Dans le tutoriel d'apprentissage en profondeur, vous allez essayer de battre le modèle linéaire

Solution Numpy

Cette section explique comment entraîner le modèle à l'aide d'un estimateur numpy pour alimenter les données. La méthode est la même que celle que vous utiliserez l'estimateur numpy_input_fn.

training_set_n = pd.read_csv ("E: /boston_train.csv"). valeurs

test_set_n = pd.read_csv ("E: /boston_test.csv"). valeurs

prediction_set_n = pd.read_csv ("E: /boston_predict.csv"). valeurs

Étape 1) Importez les données

Tout d'abord, vous devez différencier les variables de fonctionnalité de l'étiquette. Vous devez le faire pour les données d'entraînement et l'évaluation. Il est plus rapide de définir une fonction pour fractionner les données.

def prepare_data(df):X_train = df[:, :-3]y_train = df[:,-3]return X_train, y_train

Vous pouvez utiliser la fonction pour séparer l'étiquette des caractéristiques du jeu de données train / évaluer

X_train, y_train = prepare_data(training_set_n)X_test, y_test = prepare_data(test_set_n)

Vous devez exclure la dernière colonne de l'ensemble de données de prédiction car elle ne contient que NaN

x_predict = prediction_set_n[:, :-2]

Confirmez la forme du tableau. Notez que l'étiquette ne doit pas avoir de dimension, cela signifie (400,).

print(X_train.shape, y_train.shape, x_predict.shape)

Production

(400, 9) (400,) (6, 9)

Vous pouvez construire les colonnes de caractéristiques comme suit:

feature_columns = [ tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]

L'estimateur est défini comme précédemment, vous indiquez les colonnes de caractéristiques et où enregistrer le graphique.

estimator = tf.estimator.LinearRegressor(feature_columns=feature_columns,model_dir="train1")

Production

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'train1', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': , '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

Vous pouvez utiliser l'estimapor numpy pour fournir les données au modèle, puis entraîner le modèle. Notez que nous définissons la fonction input_fn avant pour faciliter la lisibilité.

# Train the estimatortrain_input = tf.estimator.inputs.numpy_input_fn(x={"x": X_train},y=y_train,batch_size=128,shuffle=False,num_epochs=None)estimator.train(input_fn = train_input,steps=5000)

Production

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Create CheckpointSaverHook.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Saving checkpoints for 1 into train1/model.ckpt.INFO:tensorflow:loss = 83729.64, step = 1INFO:tensorflow:global_step/sec: 490.057INFO:tensorflow:loss = 13909.656, step = 101 (0.206 sec)INFO:tensorflow:global_step/sec: 788.986INFO:tensorflow:loss = 12881.45, step = 201 (0.126 sec)INFO:tensorflow:global_step/sec: 736.339INFO:tensorflow:loss = 12391.541, step = 301 (0.136 sec)INFO:tensorflow:global_step/sec: 383.305INFO:tensorflow:loss = 12050.561, step = 401 (0.260 sec)INFO:tensorflow:global_step/sec: 859.832INFO:tensorflow:loss = 11766.133, step = 501 (0.117 sec)INFO:tensorflow:global_step/sec: 804.394INFO:tensorflow:loss = 11509.918, step = 601 (0.125 sec)INFO:tensorflow:global_step/sec: 753.059INFO:tensorflow:loss = 11272.891, step = 701 (0.134 sec)INFO:tensorflow:global_step/sec: 402.165INFO:tensorflow:loss = 11051.979, step = 801 (0.248 sec)INFO:tensorflow:global_step/sec: 344.022INFO:tensorflow:loss = 10845.854, step = 901 (0.288 sec)INFO:tensorflow:Saving checkpoints for 1000 into train1/model.ckpt.INFO:tensorflow:Loss for final step: 5925.985.Out[23]:

Vous répliquez la même étape avec un estimateur différent pour évaluer votre modèle

eval_input = tf.estimator.inputs.numpy_input_fn(x={"x": X_test},y=y_test,shuffle=False,batch_size=128,num_epochs=1)estimator.evaluate(eval_input,steps=None)

Production

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-01:44:00INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-01:44:00INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.158947, global_step = 1000, loss = 3215.8945Out[24]:{'average_loss': 32.158947, 'global_step': 1000, 'loss': 3215.8945}

Enfin, vous pouvez calculer la prédiction. Cela devrait être la même chose que les pandas.

test_input = tf.estimator.inputs.numpy_input_fn(x={"x": x_predict},batch_size=128,num_epochs=1,shuffle=False)y = estimator.predict(test_input)predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions)))

Production

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.Predictions: [array([32.297546], dtype=float32), array([18.961248], dtype=float32), array([27.270979], dtype=float32), array([29.299242], dtype=float32), array([16.43668], dtype=float32), array([21.460878], dtype=float32)]

Solution Tensorflow

La dernière section est dédiée à une solution TensorFlow. Cette méthode est légèrement plus compliquée que l'autre.

Notez que si vous utilisez le notebook Jupyter, vous devez redémarrer et nettoyer le noyau pour exécuter cette session.

TensorFlow a construit un excellent outil pour transmettre les données dans le pipeline. Dans cette section, vous construirez vous-même la fonction input_fn.

Étape 1) Définissez le chemin et le format des données

Tout d'abord, vous déclarez deux variables avec le chemin du fichier csv. Notez que vous disposez de deux fichiers, un pour l'ensemble d'apprentissage et un pour l'ensemble de test.

import tensorflow as tf
df_train = "E:/boston_train.csv"
df_eval = "E:/boston_test.csv"

Ensuite, vous devez définir les colonnes que vous souhaitez utiliser à partir du fichier csv. Nous utiliserons tout. Après cela, vous devez déclarer le type de variable dont il s'agit.

Les variables flottantes sont définies par [0.]

COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age","dis", "tax", "ptratio", "medv"]RECORDS_ALL = [[0.0], [0.0], [0.0], [0.0],[0.0],[0.0],[0.0],[0.0],[0.0],[0.0]]

Étape 2) Définissez la fonction input_fn

La fonction peut être divisée en trois parties:

  1. Importez les données
  2. Créer l'itérateur
  3. Consommez les données

Vous trouverez ci-dessous le code général pour définir la fonction. Le code sera expliqué après

def input_fn(data_file, batch_size, num_epoch = None):# Step 1def parse_csv(value):columns = tf.decode_csv(value, record_defaults= RECORDS_ALL)features = dict(zip(COLUMNS, columns))#labels = features.pop('median_house_value')labels = features.pop('medv')return features, labels# Extract lines from input files using theDataset API. dataset = (tf.data.TextLineDataset(data_file) # Read text file.skip(1) # Skip header row.map(parse_csv))dataset = dataset.repeat(num_epoch)dataset = dataset.batch(batch_size)# Step 3iterator = dataset.make_one_shot_iterator()features, labels = iterator.get_next()return features, labels

** Importez les données **

Pour un fichier csv, la méthode de l'ensemble de données lit une ligne à la fois. Pour créer l'ensemble de données, vous devez utiliser l'objet TextLineDataset. Votre ensemble de données a un en-tête, vous devez donc utiliser skip (1) pour ignorer la première ligne. À ce stade, vous ne lisez que les données et excluez l'en-tête du pipeline. Pour alimenter le modèle, vous devez séparer les fonctions de l'étiquette. La méthode utilisée pour appliquer toute transformation aux données est la carte.

Cette méthode appelle une fonction que vous allez créer pour indiquer comment transformer les données.En bref, vous devez passer les données dans l'objet TextLineDataset, exclure l'en-tête et appliquer une transformation qui est commandée par une fonction.

  • tf.data.TextLineDataset (data_file): Cette ligne lit le fichier csv
  • .skip (1): sauter l'en-tête
  • .map (parse_csv)): analyse les enregistrements dans les tenseurs Vous devez définir une fonction pour instruire l'objet de la carte. Vous pouvez appeler cette fonction parse_csv.

Cette fonction analyse le fichier csv avec la méthode tf.decode_csv et déclare les fonctionnalités et l'étiquette. Les fonctionnalités peuvent être déclarées sous forme de dictionnaire ou de tuple. Vous utilisez la méthode du dictionnaire car elle est plus pratique.

  • tf.decode_csv (valeur, record_defaults = RECORDS_ALL): la méthode decode_csv utilise la sortie du TextLineDataset pour lire le fichier csv. record_defaults indique à TensorFlow le type de colonnes.
  • dict (zip (_CSV_COLUMNS, colonnes)): Remplit le dictionnaire avec toutes les colonnes extraites lors de ce traitement de données
  • features.pop ('median_house_value'): exclut la variable cible de la variable de fonction et créer une variable d'étiquette

L'ensemble de données a besoin d'éléments supplémentaires pour alimenter de manière itérative les tenseurs. En effet, vous devez ajouter la méthode repeat pour permettre à l'ensemble de données de continuer indéfiniment à alimenter le modèle. Si vous n'ajoutez pas la méthode, le modèle n'itérera qu'une seule fois, puis lèvera une erreur car plus aucune donnée n'est introduite dans le pipeline.

Après cela, vous pouvez contrôler la taille du lot avec la méthode par lots. Cela signifie que vous indiquez à l'ensemble de données le nombre de données que vous souhaitez transmettre dans le pipeline pour chaque itération. Si vous définissez une grande taille de lot, le modèle sera lent.

Étape 3) Créez l'itérateur

Vous êtes maintenant prêt pour la deuxième étape: créez un itérateur pour renvoyer les éléments de l'ensemble de données.

La manière la plus simple de créer un opérateur est d'utiliser la méthode make_one_shot_iterator.

Après cela, vous pouvez créer les fonctionnalités et les étiquettes à partir de l'itérateur.

Étape 4) Consommez les données

Vous pouvez vérifier ce qui se passe avec la fonction input_fn. Vous devez appeler la fonction dans une session pour consommer les données. Vous essayez avec une taille de lot égale à 1.

Notez que, il imprime les fonctionnalités dans un dictionnaire et l'étiquette sous forme de tableau.

Il affichera la première ligne du fichier csv. Vous pouvez essayer d'exécuter ce code plusieurs fois avec une taille de lot différente.

next_batch = input_fn(df_train, batch_size = 1, num_epoch = None)with tf.Session() as sess:first_batch = sess.run(next_batch)print(first_batch)

Production

({'crim': array([2.3004], dtype=float32), 'zn': array([0.], dtype=float32), 'indus': array([19.58], dtype=float32), 'nox': array([0.605], dtype=float32), 'rm': array([6.319], dtype=float32), 'age': array([96.1], dtype=float32), 'dis': array([2.1], dtype=float32), 'tax': array([403.], dtype=float32), 'ptratio': array([14.7], dtype=float32)}, array([23.8], dtype=float32))

Étape 4) Définissez la colonne de caractéristiques

Vous devez définir les colonnes numériques comme suit:

X1= tf.feature_column.numeric_column('crim')X2= tf.feature_column.numeric_column('zn')X3= tf.feature_column.numeric_column('indus')X4= tf.feature_column.numeric_column('nox')X5= tf.feature_column.numeric_column('rm')X6= tf.feature_column.numeric_column('age')X7= tf.feature_column.numeric_column('dis')X8= tf.feature_column.numeric_column('tax')X9= tf.feature_column.numeric_column('ptratio')

Notez que vous devez combiner toutes les variables dans un bucket

base_columns = [X1, X2, X3,X4, X5, X6,X7, X8, X9]

Étape 5) Construisez le modèle

Vous pouvez entraîner le modèle avec l'estimateur LinearRegressor.

model = tf.estimator.LinearRegressor(feature_columns=base_columns, model_dir='train3')

Production

INFO:tensorflow:Using default config. INFO:tensorflow:Using config: {'_model_dir': 'train3', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': , '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

Vous devez utiliser une fonction lambda pour permettre d'écrire l'argument dans la fonction inpu_fn. Si vous n'utilisez pas de fonction lambda, vous ne pouvez pas entraîner le modèle.

# Train the estimatormodel.train(steps =1000,input_fn= lambda : input_fn(df_train,batch_size=128, num_epoch = None))

Production

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Create CheckpointSaverHook.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Saving checkpoints for 1 into train3/model.ckpt.INFO:tensorflow:loss = 83729.64, step = 1INFO:tensorflow:global_step/sec: 72.5646INFO:tensorflow:loss = 13909.657, step = 101 (1.380 sec)INFO:tensorflow:global_step/sec: 101.355INFO:tensorflow:loss = 12881.449, step = 201 (0.986 sec)INFO:tensorflow:global_step/sec: 109.293INFO:tensorflow:loss = 12391.541, step = 301 (0.915 sec)INFO:tensorflow:global_step/sec: 102.235INFO:tensorflow:loss = 12050.5625, step = 401 (0.978 sec)INFO:tensorflow:global_step/sec: 104.656INFO:tensorflow:loss = 11766.134, step = 501 (0.956 sec)INFO:tensorflow:global_step/sec: 106.697INFO:tensorflow:loss = 11509.922, step = 601 (0.938 sec)INFO:tensorflow:global_step/sec: 118.454INFO:tensorflow:loss = 11272.889, step = 701 (0.844 sec)INFO:tensorflow:global_step/sec: 114.947INFO:tensorflow:loss = 11051.9795, step = 801 (0.870 sec)INFO:tensorflow:global_step/sec: 111.484INFO:tensorflow:loss = 10845.855, step = 901 (0.897 sec)INFO:tensorflow:Saving checkpoints for 1000 into train3/model.ckpt.INFO:tensorflow:Loss for final step: 5925.9873.Out[8]:

Vous pouvez évaluer l'ajustement de votre modèle sur l'ensemble de test avec le code ci-dessous:

results = model.evaluate(steps =None,input_fn=lambda: input_fn(df_eval, batch_size =128, num_epoch = 1))for key in results:print(" {}, was: {}".format(key, results[key]))

Production

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-02:06:02INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-02:06:02INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896average_loss, was: 32.158958435058594loss, was: 3215.89599609375global_step, was: 1000

La dernière étape consiste à prédire la valeur de en fonction de la valeur de, les matrices des caractéristiques. Vous pouvez rédiger un dictionnaire avec les valeurs que vous souhaitez prédire. Votre modèle a 9 fonctionnalités, vous devez donc fournir une valeur pour chacune. Le modèle fournira une prédiction pour chacun d'eux.

Dans le code ci-dessous, vous avez écrit les valeurs de chaque fonctionnalité contenue dans le fichier csv df_predict.

Vous devez écrire une nouvelle fonction input_fn car il n'y a pas d'étiquette dans l'ensemble de données. Vous pouvez utiliser l'API from_tensor de l'ensemble de données.

prediction_input = {'crim': [0.03359,5.09017,0.12650,0.05515,8.15174,0.24522],'zn': [75.0,0.0,25.0,33.0,0.0,0.0],'indus': [2.95,18.10,5.13,2.18,18.10,9.90],'nox': [0.428,0.713,0.453,0.472,0.700,0.544],'rm': [7.024,6.297,6.762,7.236,5.390,5.782],'age': [15.8,91.8,43.4,41.1,98.9,71.7],'dis': [5.4011,2.3682,7.9809,4.0220,1.7281,4.0317],'tax': [252,666,284,222,666,304],'ptratio': [18.3,20.2,19.7,18.4,20.2,18.4]}def test_input_fn():dataset = tf.data.Dataset.from_tensors(prediction_input)return dataset# Predict all our prediction_inputpred_results = model.predict(input_fn=test_input_fn)

Enfin, vous imprimez les prédictions.

for pred in enumerate(pred_results):print(pred)

Production

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.(0, {'predictions': array([32.297546], dtype=float32)})(1, {'predictions': array([18.96125], dtype=float32)})(2, {'predictions': array([27.270979], dtype=float32)})(3, {'predictions': array([29.299236], dtype=float32)})(4, {'predictions': array([16.436684], dtype=float32)})(5, {'predictions': array([21.460876], dtype=float32)})INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train3/model.ckpt-5000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. (0, {'predictions': array([35.60663], dtype=float32)}) (1, {'predictions': array([22.298521], dtype=float32)}) (2, {'predictions': array([25.74533], dtype=float32)}) (3, {'predictions': array([35.126694], dtype=float32)}) (4, {'predictions': array([17.94416], dtype=float32)}) (5, {'predictions': array([22.606628], dtype=float32)})

Résumé

Pour entraîner un modèle, vous devez:

  • Définissez les fonctionnalités: Variables indépendantes: X
  • Définissez le libellé: Variable dépendante: y
  • Construire un train / ensemble de test
  • Définir le poids initial
  • Définir la fonction de perte: MSE
  • Optimiser le modèle: descente de gradient
  • Définir:
    • Taux d'apprentissage
    • Nombre d'époque
    • Taille du lot

Dans ce didacticiel, vous avez appris à utiliser l'API de haut niveau pour un estimateur TensorFlow de régression linéaire. Vous devez définir:

  1. Colonnes de fonctionnalités. Si continue: tf.feature_column.numeric_column (). Vous pouvez remplir une liste avec la compréhension de liste python
  2. L'estimateur: tf.estimator.LinearRegressor (feature_columns, model_dir)
  3. Une fonction pour importer les données, la taille du lot et l'époque: input_fn ()

Après cela, vous êtes prêt à vous entraîner, à évaluer et à faire des prédictions avec train (), evaluer () et prédire ()