Régression linéaire TensorFlow avec facette & Terme d'interaction

Dans ce didacticiel, vous apprendrez à vérifier les données et à les préparer pour créer une tâche de régression linéaire simple.

Ce tutoriel est divisé en deux parties:

• Rechercher une interaction
• Tester le modèle

Dans le didacticiel précédent, vous avez utilisé l'ensemble de données Boston pour estimer le prix médian d'une maison. L'ensemble de données de Boston a une petite taille, avec seulement 506 observations. Cet ensemble de données est considéré comme une référence pour essayer de nouveaux algorithmes de régression linéaire.

L'ensemble de données est composé de:

Variable	Description
zn	La proportion de terrains résidentiels zonés pour les lots de plus de 25 000 pieds carrés.
indus	La proportion d'acres commerciaux non commerciaux par ville.
nox	concentration d'oxydes nitriques
rm	nombre moyen de pièces par logement
âge	la 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	le ratio élèves-enseignant par ville
medv	La valeur médiane des logements occupés par leur propriétaire en milliers de dollars
crim	taux de criminalité par habitant par ville
chasser	Variable fictive de Charles River (1 si limite la rivière; 0 sinon)
B	la proportion de noirs par ville

Dans ce didacticiel, nous allons estimer le prix médian à l'aide d'un régresseur linéaire, mais l'accent est mis sur un processus particulier d'apprentissage automatique: la «préparation des données».

Un modèle généralise le modèle dans les données. Pour capturer un tel modèle, vous devez d'abord le trouver. Une bonne pratique consiste à effectuer une analyse des données avant d'exécuter un algorithme d'apprentissage automatique.

Le choix des bonnes fonctionnalités fait toute la différence dans le succès de votre modèle. Imaginez que vous essayez d'estimer le salaire d'un peuple, si vous n'incluez pas le sexe comme covariable, vous vous retrouvez avec une mauvaise estimation.

Une autre façon d'améliorer le modèle consiste à examiner la corrélation entre la variable indépendante. Revenons à l'exemple, vous pouvez considérer l'éducation comme un excellent candidat pour prédire le salaire mais aussi la profession. Il est juste de dire que la profession dépend du niveau d'éducation, à savoir que l'enseignement supérieur conduit souvent à une meilleure profession. Si nous généralisons cette idée, nous pouvons dire que la corrélation entre la variable dépendante et une variable explicative peut être amplifiée d'une autre variable explicative.

Pour saisir l'effet limité de l'éducation sur la profession, nous pouvons utiliser un terme d'interaction.

Si vous regardez l'équation des salaires, cela devient:

Si est positif, cela signifie qu'un niveau de scolarité supplémentaire entraîne une augmentation plus élevée de la valeur médiane d'une maison pour un niveau d'occupation élevé. En d'autres termes, il y a un effet d'interaction entre l'éducation et la profession.

Dans ce tutoriel, nous allons essayer de voir quelles variables peuvent être un bon candidat pour les termes d'interaction. Nous allons tester si l'ajout de ce type d'informations conduit à une meilleure prévision des prix.

Dans ce tutoriel, vous apprendrez

• Statistiques récapitulatives
• Aperçu des facettes
• Facettes Deep Dive
• Installer Facet
• Aperçu
• Graphique
• Facettes Deep Dive
• TensorFlow
• Données de préparation
• Régression de base: Benchmark
• Améliorer le modèle: terme d'interaction

Statistiques récapitulatives

Vous pouvez suivre quelques étapes avant de passer au modèle. Comme mentionné précédemment, le modèle est une généralisation des données. La meilleure pratique d'ajustement consiste à comprendre les données et à faire une prédiction. Si vous ne connaissez pas vos données, vous avez peu de chances d'améliorer votre modèle.

Dans un premier temps, chargez les données en tant que dataframe pandas et créez un ensemble d'entraînement et un ensemble de tests.

Conseils: Pour ce didacticiel, vous devez avoir matplotlit et seaborn installés en Python. Vous pouvez installer le package Python à la volée avec Jupyter. Tu ne devrais pas faire ça

!conda install -- yes matplotlib

mais

import sys!{sys.executable} -m pip install matplotlib # Already installed!{sys.executable} -m pip install seaborn

Notez que cette étape n'est pas nécessaire si vous avez installé matplotlib et seaborn.

Matplotlib est la bibliothèque pour créer un graphe en Python. Seaborn est une bibliothèque de visualisation statistique construite sur matplotlib. Il offre des parcelles attrayantes et belles.

Le code ci-dessous importe les bibliothèques nécessaires.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tffrom sklearn.datasets import load_bostonimport numpy as np

La bibliothèque sklearn comprend le jeu de données Boston. Vous pouvez appeler son API pour importer les données.

boston = load_boston()df = pd.DataFrame(boston.data) 

Le nom de la fonction est stocké dans l'objet nom_fonction dans un tableau.

boston.feature_names

Production

array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='
Vous pouvez renommer les colonnes.
df.columns = boston.feature_namesdf['PRICE'] = boston.targetdf.head(2)

Vous convertissez la variable CHAS en tant que variable de chaîne et l'étiquetez avec yes si CHAS = 1 et no si CHAS = 0
df['CHAS'] = df['CHAS'].map({1:'yes', 0:'no'})df['CHAS'].head(5)0 no1 no2 no3 no4 noName: CHAS, dtype: object
Avec les pandas, il est simple de diviser l'ensemble de données. Vous divisez aléatoirement l'ensemble de données avec un ensemble d'entraînement à 80% et un ensemble de tests à 20%. Les pandas ont une fonction de coût intégrée pour diviser un échantillon de trame de données.
Le premier paramètre frac est une valeur de 0 à 1. Vous le définissez sur 0,8 pour sélectionner au hasard 80 pour cent de la trame de données.
Random_state permet d'avoir le même dataframe retourné pour tout le monde.
### Create train/test setdf_train=df.sample(frac=0.8,random_state=200)df_test=df.drop(df_train.index)
Vous pouvez obtenir la forme des données. Ça devrait être:

Coffret: 506 * 0,8 = 405
Ensemble de test: 506 * 0,2 = 101

print(df_train.shape, df_test.shape)
Production 
(405, 14) (101, 14) 
 
df_test.head(5)
Production
 

 
 
 
 
CRIM 
 
ZN 
 
INDUS 
 
CHAS 
 
NOX 
 
RM 
 
ÂGE 
 
DIS 
 
RAD 
 
IMPÔT 
 
PTRATIO 
 
B 
 
LSTAT 
 
LE PRIX 
 

 
 
0 
 
0,00632 
 
18,0 
 
2,31 
 
non 
 
0,538 
 
6,575 
 
65,2 
 
4,0900 
 
1.0 
 
296,0 
 
15,3 
 
396,90 
 
4,98 
 
24,0 
 

 
 
1 
 
0,02731 
 
0,0 
 
7,07 
 
non 
 
0,469 
 
6,421 
 
78,9 
 
4,9671 
 
2,0 
 
242,0 
 
17,8 
 
396,90 
 
9,14 
 
21,6 
 

 
 
3 
 
0,03237 
 
0,0 
 
2,18 
 
non 
 
0,458 
 
6,998 
 
45,8 
 
6,0622 
 
3.0 
 
222,0 
 
18,7 
 
394,63 
 
2,94 
 
33,4 
 

 
 
6 
 
0,08829 
 
12,5 
 
7,87 
 
non 
 
0,524 
 
6,012 
 
66,6 
 
5,5605 
 
5,0 
 
311,0 
 
15,2 
 
395,60 
 
12,43 
 
22,9 
 

 
 
7 
 
0,14455 
 
12,5 
 
7,87 
 
non 
 
0,524 
 
6,172 
 
96,1 
 
5,9505 
 
5,0 
 
311,0 
 
15,2 
 
396,90 
 
19,15 
 
27,1 
 

 

 

Les données sont désordonnées; il est souvent mal équilibré et parsemé de valeurs aberrantes qui perturbent l'analyse et la formation à l'apprentissage automatique.
La première étape pour nettoyer l'ensemble de données est de comprendre où il doit être nettoyé. Le nettoyage d'un ensemble de données peut être difficile à faire, en particulier de toute manière généralisable
L'équipe de recherche Google a développé un outil pour ce travail appelé Facets qui aide à visualiser les données et à les découper de toutes sortes de manières. C'est un bon point de départ pour comprendre comment l'ensemble de données est présenté.
Les facettes vous permettent de trouver où les données ne ressemblent pas tout à fait à ce que vous pensez.
À l'exception de leur application Web, Google facilite l'intégration de la boîte à outils dans un bloc-notes Jupyter.
Il y a deux parties aux facettes:

Aperçu des facettes


Facettes Deep Dive


Aperçu des facettes
Vue d'ensemble des facettes donne un aperçu de l'ensemble de données. Vue d'ensemble des facettes divise les colonnes des données en lignes d'informations saillantes montrant

le pourcentage d'observation manquante
valeurs min et max
des statistiques comme la moyenne, la médiane et l'écart type.
Il ajoute également une colonne indiquant le pourcentage de valeurs qui sont des zéros, ce qui est utile lorsque la plupart des valeurs sont des zéros.
Il est possible de voir ces distributions sur l'ensemble de données de test ainsi que l'ensemble d'apprentissage pour chaque entité. Cela signifie que vous pouvez vérifier que le test a une distribution similaire aux données d'entraînement.

C'est au moins le minimum à faire avant toute tâche d'apprentissage automatique. Avec cet outil, vous ne manquez pas cette étape cruciale, et il met en évidence certaines anomalies.

Facettes Deep Dive
Facets Deep Dive est un outil sympa. Cela permet d'avoir une certaine clarté sur votre ensemble de données et de zoomer complètement pour voir une donnée individuelle. Cela signifie que vous pouvez mettre en facettes les données par ligne et par colonne dans toutes les fonctionnalités de l'ensemble de données.
Nous utiliserons ces deux outils avec le jeu de données Boston.
Remarque : vous ne pouvez pas utiliser la vue d'ensemble des facettes et l'analyse approfondie des facettes en même temps. Vous devez d'abord effacer le bloc-notes pour changer d'outil.

Installer Facet
Vous pouvez utiliser l'application Web Facet pour la plupart des analyses. Dans ce didacticiel, vous verrez comment l'utiliser dans un bloc-notes Jupyter.
Tout d'abord, vous devez installer nbextensions. C'est fait avec ce code. Vous copiez et collez le code suivant dans le terminal de votre machine.
pip install jupyter_contrib_nbextensions 
Juste après cela, vous devez cloner les référentiels sur votre ordinateur. Vous avez deux choix:
Option 1) Copiez et collez ce code dans le terminal (recommandé)
Si vous n'avez pas installé Git sur votre machine, accédez à cette URL https://git-scm.com/download/win et suivez les instructions. Une fois que vous avez terminé, vous pouvez utiliser la commande git dans le terminal pour l'utilisateur Mac ou l'invite Anaconda pour l'utilisateur Windows
git clone https://github.com/PAIR-code/facets 
Option 2) Allez sur https://github.com/PAIR-code/facets et téléchargez les référentiels.

Si vous choisissez la première option, le fichier se retrouve dans votre fichier de téléchargement. Vous pouvez laisser le fichier en téléchargement ou le faire glisser vers un autre chemin.
Vous pouvez vérifier où les facettes sont stockées avec cette ligne de commande:
echo `pwd`/`ls facets` 
Maintenant que vous avez localisé Facets, vous devez l'installer dans Jupyter Notebook. Vous devez définir le répertoire de travail sur le chemin où se trouvent les facettes.
Votre répertoire de travail actuel et l'emplacement de Facets zip doivent être identiques.

Vous devez pointer le répertoire de travail vers Facet:
cd facets
Pour installer Facets dans Jupyter, vous avez deux options. Si vous avez installé Jupyter avec Conda pour tous les utilisateurs, copiez ce code:
peut utiliser jupyter nbextension install facets-dist /
jupyter nbextension install facets-dist/
Sinon, utilisez:
jupyter nbextension install facets-dist/ --user
Très bien, vous êtes prêt. Ouvrons la vue d'ensemble des facettes.

Aperçu
Overview utilise un script Python pour calculer les statistiques. Vous devez importer le script appelé generic_feature_statistics_generator vers Jupyter. Ne t'inquiète pas; le script se trouve dans les fichiers de facettes.
Vous devez localiser son chemin. C'est facile à faire. Vous ouvrez les facettes, ouvrez le fichier facets_overview puis python. Copiez le chemin

Après cela, revenez à Jupyter et écrivez le code suivant. Remplacez le chemin «/ Users / Thomas / facets / facets_overview / python» par votre chemin.
# Add the facets overview python code to the python path# Add timport syssys.path.append('/Users/Thomas/facets/facets_overview/python')
Vous pouvez importer le script avec le code ci-dessous.
from generic_feature_statistics_generator importGenericFeatureStatisticsGenerator
Sous Windows, le même code devient
import syssys.path.append(r"C:\Users\Admin\Anaconda3\facets-master\facets_overview\python")from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator
Pour calculer les statistiques d'objet, vous devez utiliser la fonction GenericFeatureStatisticsGenerator () et vous utilisez l'objet ProtoFromDataFrames. Vous pouvez transmettre le bloc de données dans un dictionnaire. Par exemple, si nous voulons créer une statistique récapitulative pour le train, nous pouvons stocker les informations dans un dictionnaire et les utiliser dans l'objet `` ProtoFromDataFrames ''


'name': 'train', 'table': df_train 

Nom est le nom de la table affichée et vous utilisez le nom de la table dont vous souhaitez calculer le résumé. Dans votre exemple, la table contenant les données est df_train
# Calculate the feature statistics proto from the datasets and stringify it for use in facets overviewimport base64gfsg = GenericFeatureStatisticsGenerator()proto = gfsg.ProtoFromDataFrames([{'name': 'train', 'table': df_train},{'name': 'test', 'table': df_test}])#proto = gfsg.ProtoFromDataFrames([{'name': 'train', 'table': df_train}])protostr = base64.b64encode(proto.SerializeToString()).decode("utf-8")
Enfin, copiez et collez simplement le code ci-dessous. Le code provient directement de GitHub. Vous devriez pouvoir voir ceci:

# Display the facets overview visualization for this data# Displfrom IPython.core.display import display, HTMLHTML_TEMPLATE = """
"""html = HTML_TEMPLATE.format(protostr=protostr)display(HTML(html))
 
Graphique
Après avoir vérifié les données et leur distribution, vous pouvez tracer une matrice de corrélation. La matrice de corrélation calcule le coefficient de Pearson. Ce coefficient est lié entre -1 et 1, une valeur positive indique une corrélation positive et une valeur négative une corrélation négative.
Vous êtes intéressé de voir quelles variables peuvent être un bon candidat pour les termes d'interaction.
## Choose important feature and further check with Dive%matplotlib inlineimport matplotlib.pyplot as pltimport seaborn as snssns.set(style="ticks")# Compute the correlation matrixcorr = df.corr('pearson')# Generate a mask for the upper trianglemask = np.zeros_like(corr, dtype=np.bool)mask[np.triu_indices_from(mask)] = True# Set up the matplotlib figuref, ax = plt.subplots(figsize=(11, 9))# Generate a custom diverging colormapcmap = sns.diverging_palette(220, 10, as_cmap=True)# Draw the heatmap with the mask and correct aspect ratiosns.heatmap(corr, mask=mask, cmap=cmap, vmax=.3, center=0,annot=True,square=True, linewidths=.5, cbar_kws={"shrink": .5})
Production 

png

À partir de la matrice, vous pouvez voir:

LSTAT
RM

Sont fortement corrélés avec PRIX. Une autre caractéristique intéressante est la forte corrélation positive entre NOX et INDUS, ce qui signifie que ces deux variables évoluent dans la même direction. En outre, il existe également une corrélation avec le PRIX. Le DIS est également fortement corrélé avec l'IND et le NOX.
Vous avez un premier indice selon lequel IND et NOX peuvent être de bons candidats pour le terme d'interception et DIS pourrait également être intéressant de se concentrer.
Vous pouvez aller un peu plus loin en traçant une grille de paires. Il illustrera plus en détail la carte de corrélation que vous avez tracée auparavant.
La grille de paires nous sommes composées comme suit:

Partie supérieure: Nuage de points avec ligne ajustée
Diagonale: tracé de densité du noyau
Partie inférieure: diagramme de densité de noyau multivarié

Vous choisissez le focus sur quatre variables indépendantes. Le choix correspond aux variables à forte corrélation avec PRICE

INDUS
NOX
RM
LSTAT

de plus, le PRIX.
Notez que l'erreur standard est ajoutée par défaut au nuage de points.
attributes = ["PRICE", "INDUS", "NOX", "RM", "LSTAT"]g = sns.PairGrid(df[attributes])g = g.map_upper(sns.regplot, color="g")g = g.map_lower(sns.kdeplot,cmap="Reds", shade=True, shade_lowest=False)g = g.map_diag(sns.kdeplot)
Production 

Commençons par la partie supérieure:

Le prix est négativement corrélé avec INDUS, NOX et LSTAT; corrélé positivement avec RM.
Il y a une légère non-linéarité avec LSTAT et PRICE
Il y a comme une ligne droite lorsque le prix est égal à 50. D'après la description de l'ensemble de données, PRICE a été tronqué à la valeur de 50

Diagonale

NOX semble avoir deux groupes, l'un autour de 0,5 et l'autre autour de 0,85.

Pour en savoir plus, vous pouvez regarder la partie inférieure. La densité de noyau multivariée est intéressante en ce sens qu'elle colore là où se trouvent la plupart des points. La différence avec le nuage de points dessine une densité de probabilité, même s'il n'y a pas de point dans le jeu de données pour une coordonnée donnée. Lorsque la couleur est plus forte, cela indique une forte concentration de point autour de cette zone.
Si vous vérifiez la densité multivariée pour INDUS et NOX, vous pouvez voir la corrélation positive et les deux clusters. Lorsque la part de l'industrie est supérieure à 18, la concentration d'oxydes nitriques est supérieure à 0,6.
Vous pouvez penser à ajouter une interaction entre INDUS et NOX dans la relation linéaire.
Enfin, vous pouvez utiliser le deuxième outil créé par Google, Facets Deep Dive. L'interface est divisée en quatre sections principales. La zone centrale au centre est un affichage zoomable des données. En haut du panneau, il y a le menu déroulant dans lequel vous pouvez modifier la disposition des données pour contrôler les facettes, le positionnement et la couleur. Sur la droite, il y a une vue détaillée d'une ligne spécifique de données. Cela signifie que vous pouvez cliquer sur n'importe quel point de données dans la visualisation centrale pour voir les détails de ce point de données particulier.
Lors de l'étape de visualisation des données, vous êtes intéressé par la recherche de la corrélation par paire entre la variable indépendante sur le prix de la maison. Cependant, il implique au moins trois variables et les tracés 3D sont compliqués à utiliser.
Une façon de résoudre ce problème consiste à créer une variable catégorielle. Autrement dit, nous pouvons créer un tracé 2D d'une couleur du point. Vous pouvez diviser la variable PRIX en quatre catégories, chaque catégorie étant un quartile (c'est-à-dire 0,25, 0,5, 0,75). Vous appelez cette nouvelle variable Q_PRICE.
## Check non linearity with important featuresdf['Q_PRICE'] = pd.qcut(df['PRICE'], 4, labels=["Lowest", "Low", "Upper", "upper_plus"])## Show non linearity between RM and LSTATax = sns.lmplot(x="DIS", y="INDUS", hue="Q_PRICE", data=df, fit_reg = False,palette="Set3")


Facettes Deep Dive
Pour ouvrir Deep Dive, vous devez transformer les données au format json. Pandas comme objet pour cela. Vous pouvez utiliser to_json après l'ensemble de données Pandas.
La première ligne de code gère la taille de l'ensemble de données.
df['Q_PRICE'] = pd.qcut(df['PRICE'], 4, labels=["Lowest", "Low", "Upper", "upper_plus"])sprite_size = 32 if len(df.index)>50000 else 64jsonstr = df.to_json(orient='records')
Le code ci-dessous provient de Google GitHub. Après avoir exécuté le code, vous devriez pouvoir voir ceci:

# Display thde Dive visualization for this datafrom IPython.core.display import display, HTML# Create Facets templateHTML_TEMPLATE = """
"""# Load the json dataset and the sprite_size into the templatehtml = HTML_TEMPLATE.format(jsonstr=jsonstr, sprite_size=sprite_size)# Display the templatedisplay(HTML(html))
Vous êtes intéressé de voir s'il existe un lien entre le taux de l'industrie, la concentration d'oxydes, la distance du centre de l'emploi et le prix de la maison.
Pour cela, vous devez d'abord diviser les données par gamme d'industries et par couleur avec le quartile de prix:

Sélectionnez la facette X et choisissez INDUS.
Sélectionnez Affichage et choisissez DIS. Il colorera les points avec le quartile du prix de l'immobilier

ici, des couleurs plus foncées signifient que la distance par rapport au premier centre d'emploi est loin.
Jusqu'à présent, cela montre à nouveau ce que vous savez, un taux d'industrie plus bas, un prix plus élevé. Vous pouvez maintenant regarder la répartition par INDUX, par NOX.

Sélectionnez la facette Y et choisissez NOX.

Maintenant, vous pouvez voir que la maison, loin du premier centre pour l'emploi, a la plus faible part de l'industrie et donc la plus faible concentration d'oxyde. Si vous choisissez d'afficher le type avec Q_PRICE et de zoomer dans le coin inférieur gauche, vous pouvez voir de quel type de prix il s'agit.
Vous avez un autre indice que l'interaction entre IND, NOX et DIS peut être de bons candidats pour améliorer le modèle.

TensorFlow
Dans cette section, vous allez estimer le classificateur linéaire avec l'API des estimateurs TensorFlow. Vous procéderez comme suit:

Préparez les données
Estimer un modèle de référence: aucune interaction
Estimer un modèle avec interaction

N'oubliez pas que l'objectif de l'apprentissage automatique est de minimiser l'erreur. Dans ce cas, le modèle avec l'erreur quadratique moyenne la plus faible l'emportera. L'estimateur TensorFlow calcule automatiquement cette métrique.
Données de préparation
Dans la plupart des cas, vous devez transformer vos données. C'est pourquoi la vue d'ensemble des facettes est fascinante. D'après la statistique récapitulative, vous avez vu qu'il y a des valeurs aberrantes. Ces valeurs affectent les estimations car elles ne ressemblent pas à la population que vous analysez. Les valeurs aberrantes ont généralement biaisé les résultats. Par exemple, une valeur aberrante positive a tendance à surestimer le coefficient.
Une bonne solution pour résoudre ce problème est de standardiser la variable. La normalisation signifie un écart type de un et une moyenne de zéro. Le processus de normalisation comporte deux étapes. Tout d'abord, il soustrait la valeur moyenne de la variable. Deuxièmement, il divise par la variance de sorte que la distribution a une variance unitaire
La bibliothèque sklearn est utile pour standardiser les variables. Vous pouvez utiliser le prétraitement du module avec l'échelle d'objet à cet effet.
Vous pouvez utiliser la fonction ci-dessous pour mettre à l'échelle un ensemble de données. Notez que vous ne mettez pas à l'échelle la colonne d'étiquette et les variables catégorielles.
from sklearn import preprocessingdef standardize_data(df):X_scaled = preprocessing.scale(df[['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT']])X_scaled_df = pd.DataFrame(X_scaled, columns = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'])df_scale = pd.concat([X_scaled_df,df['CHAS'],df['PRICE']],axis=1, join='inner')return df_scale
Vous pouvez utiliser la fonction pour construire l'ensemble train / test mis à l'échelle.
df_train_scale = standardize_data(df_train)df_test_scale = standardize_data(df_test) 
Régression de base: Benchmark
Tout d'abord, vous entraînez et testez un modèle sans interaction. Le but est de voir la métrique de performance du modèle.
La façon d'entraîner le modèle est exactement comme le didacticiel sur l'API de haut niveau . Vous utiliserez l'estimateur TensorFlow LinearRegressor.
Pour rappel, vous devez choisir:

les fonctionnalités à mettre dans le modèle
transformer les fonctionnalités
construire le régresseur linéaire
construire la fonction input_fn
former le modèle
tester le modèle

Vous utilisez toutes les variables de l'ensemble de données pour entraîner le modèle. Au total, il existe des variables continues à onze niveaux et une variable catégorielle
## Add features to the bucket:### Define continuous listCONTI_FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT']CATE_FEATURES = ['CHAS']
Vous convertissez les entités en une colonne numérique ou une colonne catégorielle
continuous_features = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES]#categorical_features = tf.feature_column.categorical_column_with_hash_bucket(CATE_FEATURES, hash_bucket_size=1000)categorical_features = [tf.feature_column.categorical_column_with_vocabulary_list('CHAS', ['yes','no'])]
Vous créez le modèle avec le linearRegressor. Vous stockez le modèle dans le dossier train_Boston
model = tf.estimator.LinearRegressor(model_dir="train_Boston",feature_columns=categorical_features + continuous_features)
Production 
INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'train_Boston', '_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}
Chaque colonne du train ou des données de test est convertie en un Tensor avec la fonction get_input_fn
FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT', 'CHAS']LABEL= 'PRICE'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)
Vous estimez le modèle sur les données du train.
model.train(input_fn=get_input_fn(df_train_scale,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_Boston/model.ckpt.INFO:tensorflow:loss = 56417.703, step = 1INFO:tensorflow:global_step/sec: 144.457INFO:tensorflow:loss = 76982.734, step = 101 (0.697 sec)INFO:tensorflow:global_step/sec: 258.392INFO:tensorflow:loss = 21246.334, step = 201 (0.383 sec)INFO:tensorflow:global_step/sec: 227.998INFO:tensorflow:loss = 30534.78, step = 301 (0.439 sec)INFO:tensorflow:global_step/sec: 210.739INFO:tensorflow:loss = 36794.5, step = 401 (0.477 sec)INFO:tensorflow:global_step/sec: 234.237INFO:tensorflow:loss = 8562.981, step = 501 (0.425 sec)INFO:tensorflow:global_step/sec: 238.1INFO:tensorflow:loss = 34465.08, step = 601 (0.420 sec)INFO:tensorflow:global_step/sec: 237.934INFO:tensorflow:loss = 12241.709, step = 701 (0.420 sec)INFO:tensorflow:global_step/sec: 220.687INFO:tensorflow:loss = 11019.228, step = 801 (0.453 sec)INFO:tensorflow:global_step/sec: 232.702INFO:tensorflow:loss = 24049.678, step = 901 (0.432 sec)INFO:tensorflow:Saving checkpoints for 1000 into train_Boston/model.ckpt.INFO:tensorflow:Loss for final step: 23228.568.
Enfin, vous estimez les performances du modèle sur l'ensemble de test
model.evaluate(input_fn=get_input_fn(df_test_scale,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)
Production 
INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-29-02:40:43INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train_Boston/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-29-02:40:43INFO:tensorflow:Saving dict for global step 1000: average_loss = 86.89361, global_step = 1000, loss = 1650.9785{'average_loss': 86.89361, 'global_step': 1000, 'loss': 1650.9785}
La perte du modèle est de 1650. C'est la métrique à battre dans la section suivante

Améliorer le modèle: terme d'interaction
Au cours de la première partie du didacticiel, vous avez vu une relation intéressante entre les variables. Les différentes techniques de visualisation ont révélé que INDUS et NOS sont liés entre eux et se transforment pour amplifier l'effet sur le prix. Non seulement l'interaction entre INDUS et NOS affecte le prix, mais cet effet est également plus fort lorsqu'il interagit avec DIS.
Il est temps de généraliser cette idée et de voir si vous pouvez améliorer le modèle de modèle prévu.
Vous devez ajouter deux nouvelles colonnes à chaque ensemble de données: train + test. Pour cela, vous créez une fonction pour calculer le terme d'interaction et une autre pour calculer le terme d'interaction triple. Chaque fonction produit une seule colonne. Une fois les nouvelles variables créées, vous pouvez les concaténer à l'ensemble de données d'entraînement et à l'ensemble de données de test.
Tout d'abord, vous devez créer une nouvelle variable pour l'interaction entre INDUS et NOX.
La fonction ci-dessous renvoie deux dataframes, train et test, avec l'interaction entre var_1 et var_2, dans votre cas INDUS et NOX.
def interaction_term(var_1, var_2, name):t_train = df_train_scale[var_1]*df_train_scale[var_2]train = t_train.rename(name)t_test = df_test_scale[var_1]*df_test_scale[var_2]test = t_test.rename(name)return train, test
Vous stockez les deux nouvelles colonnes
interation_ind_ns_train, interation_ind_ns_test= interaction_term('INDUS', 'NOX', 'INDUS_NOS')interation_ind_ns_train.shape(325,)
Deuxièmement, vous créez une deuxième fonction pour calculer le terme d'interaction triple.
def triple_interaction_term(var_1, var_2,var_3, name):t_train = df_train_scale[var_1]*df_train_scale[var_2]*df_train_scale[var_3]train = t_train.rename(name)t_test = df_test_scale[var_1]*df_test_scale[var_2]*df_test_scale[var_3]test = t_test.rename(name)return train, testinteration_ind_ns_dis_train, interation_ind_ns_dis_test= triple_interaction_term('INDUS', 'NOX', 'DIS','INDUS_NOS_DIS')
Maintenant que vous disposez de toutes les colonnes nécessaires, vous pouvez les ajouter pour entraîner et tester l'ensemble de données. Vous nommez ces deux nouveaux dataframe:

df_train_new
df_test_new

df_train_new = pd.concat([df_train_scale,interation_ind_ns_train,interation_ind_ns_dis_train],axis=1, join='inner')df_test_new = pd.concat([df_test_scale,interation_ind_ns_test,interation_ind_ns_dis_test],axis=1, join='inner')df_train_new.head(5)
Production 

C'est ça; vous pouvez estimer le nouveau modèle avec les termes d'interaction et voir comment est la mesure de performance.
CONTI_FEATURES_NEW = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT','INDUS_NOS', 'INDUS_NOS_DIS']### Define categorical listcontinuous_features_new = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES_NEW]model = tf.estimator.LinearRegressor(model_dir="train_Boston_1",feature_columns= categorical_features + continuous_features_new)
Production 
INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'train_Boston_1', '_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}
CODE
FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT','INDUS_NOS', 'INDUS_NOS_DIS','CHAS']LABEL= 'PRICE'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)
 
model.train(input_fn=get_input_fn(df_train_new,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_Boston_1/model.ckpt.INFO:tensorflow:loss = 56417.703, step = 1INFO:tensorflow:global_step/sec: 124.844INFO:tensorflow:loss = 65522.3, step = 101 (0.803 sec)INFO:tensorflow:global_step/sec: 182.704INFO:tensorflow:loss = 15384.148, step = 201 (0.549 sec)INFO:tensorflow:global_step/sec: 208.189INFO:tensorflow:loss = 22020.305, step = 301 (0.482 sec)INFO:tensorflow:global_step/sec: 213.855INFO:tensorflow:loss = 28208.812, step = 401 (0.468 sec)INFO:tensorflow:global_step/sec: 209.758INFO:tensorflow:loss = 7606.877, step = 501 (0.473 sec)INFO:tensorflow:global_step/sec: 196.618INFO:tensorflow:loss = 26679.76, step = 601 (0.514 sec)INFO:tensorflow:global_step/sec: 196.472INFO:tensorflow:loss = 11377.163, step = 701 (0.504 sec)INFO:tensorflow:global_step/sec: 172.82INFO:tensorflow:loss = 8592.07, step = 801 (0.578 sec)INFO:tensorflow:global_step/sec: 168.916INFO:tensorflow:loss = 19878.56, step = 901 (0.592 sec)INFO:tensorflow:Saving checkpoints for 1000 into train_Boston_1/model.ckpt.INFO:tensorflow:Loss for final step: 19598.387.
 
model.evaluate(input_fn=get_input_fn(df_test_new,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)
Production 
INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-29-02:41:14INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train_Boston_1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-29-02:41:14INFO:tensorflow:Saving dict for global step 1000: average_loss = 79.78876, global_step = 1000, loss = 1515.9863{'average_loss': 79.78876, 'global_step': 1000, 'loss': 1515.9863}
La nouvelle perte est 1515. En ajoutant simplement deux nouvelles variables, vous avez pu réduire la perte. Cela signifie que vous pouvez faire une meilleure prédiction qu'avec le modèle de référence.