Classification binaire TensorFlow : exemple de classificateur linéaire

Les deux plus courants enseignement supervisé les tâches sont la régression linéaire et le classificateur linéaire. La régression linéaire prédit une valeur tandis que le classificateur linéaire prédit une classe. Ce didacticiel se concentre sur les classificateurs linéaires.

Qu’est-ce que le classificateur linéaire ?

A Classificateur linéaire en Machine Learning est une méthode permettant de trouver la classe d'un objet en fonction de ses caractéristiques à des fins de classification statistique. Il prend une décision de classification basée sur la valeur d'une combinaison linéaire de caractéristiques d'un objet. Le classificateur linéaire est utilisé dans des problèmes pratiques tels que la classification de documents et les problèmes comportant de nombreuses variables.

Les problèmes de classification représentent environ 80 % de la tâche d’apprentissage automatique. La classification vise à prédire la probabilité de chaque classe étant donné un ensemble d'entrées. L'étiquette (c'est-à-dire la variable dépendante) est une valeur discrète, appelée classe.

1. Si l'étiquette ne comporte que deux classes, l'algorithme d'apprentissage est un classificateur binaire.
2. Le classificateur multiclasse s'attaque aux étiquettes comportant plus de deux classes.

Par exemple, un problème typique de classification binaire consiste à prédire la probabilité qu’un client effectue un deuxième achat. Prédire le type d’animal affiché sur une image est un problème de classification multiclasse puisqu’il existe plus de deux variétés d’animaux.

La partie théorique de ce tutoriel se concentre principalement sur la classe binaire. Vous en apprendrez plus sur la fonction de sortie multiclasse dans un prochain tutoriel.

Comment fonctionne le classificateur binaire ?

Vous avez appris dans le didacticiel précédent qu'une fonction est composée de deux types de variables, une variable dépendante et un ensemble de fonctionnalités (variables indépendantes). Dans la régression linéaire, une variable dépendante est un nombre réel sans étendue. L'objectif principal est de prédire sa valeur en minimisant l'erreur quadratique moyenne.

Pour TensorFlow Binary Classifier, l'étiquette peut avoir deux valeurs entières possibles. Dans la plupart des cas, il s'agit de [0,1] ou de [1,2]. Par exemple, l’objectif est de prédire si un client achètera ou non un produit. Le label est défini comme suit :

• Y = 1 (le client a acheté le produit)
• Y = 0 (le client n'achète pas le produit)

Le modèle utilise les caractéristiques X pour classer chaque client dans la classe la plus probable à laquelle il appartient, à savoir acheteur potentiel ou non.

La probabilité de succès est calculée avec régression logistique. L'algorithme calculera une probabilité basée sur la caractéristique X et prédit un succès lorsque cette probabilité est supérieure à 50 %. Plus formellement, la probabilité est calculée comme indiqué dans l'exemple de classification binaire TensorFlow ci-dessous :

où 0 est l'ensemble des poids, les caractéristiques et b le biais.

La fonction peut être décomposée en deux parties :

• Le modèle linéaire
• La fonction logistique

Modèle linéaire

Vous connaissez déjà la façon dont les poids sont calculés. Les poids sont calculés à l'aide d'un produit scalaire : Y est une fonction linéaire de toutes les caractéristiques x_i. Si le modèle ne possède pas de fonctionnalités, la prédiction est égale au biais, b.

Les poids indiquent la direction de la corrélation entre les caractéristiques x_i et l'étiquette y. Une corrélation positive augmente la probabilité d'une classe positive, tandis qu'une corrélation négative rapproche la probabilité de 0 (c'est-à-dire une classe négative).

Le modèle linéaire renvoie uniquement un nombre réel, ce qui est incompatible avec la mesure de probabilité de la plage [0,1]. La fonction logistique est nécessaire pour convertir la sortie du modèle linéaire en probabilité,

Fonction logistique

La fonction logistique, ou fonction sigmoïde, a une forme en S et la sortie de cette fonction est toujours comprise entre 0 et 1.

Il est facile de remplacer le résultat de la régression linéaire par la fonction sigmoïde. Il en résulte un nouveau nombre avec une probabilité comprise entre 0 et 1.

Le classificateur peut transformer la probabilité en classe

• Les valeurs comprises entre 0 et 0.49 deviennent la classe 0
• Les valeurs comprises entre 0.5 et 1 deviennent la classe 1

Comment mesurer les performances du classificateur linéaire ?

Précision

La performance globale d'un classificateur est mesurée avec la métrique de précision. La précision collecte toutes les valeurs correctes divisées par le nombre total d'observations. Par exemple, une valeur de précision de 80 % signifie que le modèle est correct dans 80 % des cas.

Vous pouvez noter une lacune avec cette métrique, notamment pour la classe de déséquilibre. Un ensemble de données de déséquilibre se produit lorsque le nombre d'observations par groupe n'est pas égal. Disons; vous essayez de classer un événement rare avec une fonction logistique. Imaginez que le classificateur tente d'estimer le décès d'un patient suite à une maladie. Selon les données, 5 pour cent des patients décèdent. Vous pouvez entraîner un classificateur pour prédire le nombre de décès et utiliser la métrique de précision pour évaluer les performances. Si le classificateur prédit 0 décès pour l’ensemble des données, cela sera correct dans 95 % des cas.

Matrice de confusion

Une meilleure façon d’évaluer les performances d’un classificateur consiste à examiner la matrice de confusion.

Construction matrice de confusion visualise la précision d'un classificateur en comparant les classes réelles et prédites, comme indiqué dans l'exemple de classificateur linéaire ci-dessus. La matrice de confusion binaire est composée de carrés :

• TP : Vrai positif : valeurs prédites correctement prédites comme étant réellement positives
• FP : Les valeurs prédites prédisaient à tort un résultat positif réel. c'est-à-dire que les valeurs négatives sont prédites comme positives
• FN : Faux Négatif : Valeurs positives prédites comme négatives
• TN : Vrai négatif : valeurs prédites correctement prédites comme étant réellement négatives

À partir de la matrice de confusion, il est facile de comparer la classe réelle et la classe prédite.

Précision et sensibilité

La matrice de confusion donne un bon aperçu des vrais positifs et des faux positifs. Dans certains cas, il est préférable d’avoir une métrique plus concise.

La précision

La métrique de précision montre l’exactitude de la classe positive. Il mesure la probabilité que la prédiction de la classe positive soit correcte.

Le score maximum est de 1 lorsque le classificateur classe parfaitement toutes les valeurs positives. La précision seule n’est pas très utile car elle ignore la classe négative. La métrique est généralement associée à la métrique Recall. Le rappel est également appelé sensibilité ou taux de vrais positifs.

Sensibilité

La sensibilité calcule le rapport des classes positives correctement détectées. Cette métrique indique dans quelle mesure le modèle est capable de reconnaître une classe positive.

Classificateur linéaire avec TensorFlow

Pour ce didacticiel, nous utiliserons l'ensemble de données du recensement. Le but est d'utiliser les variables de l'ensemble de données du recensement pour prédire le niveau de revenu. A noter que le revenu est une variable binaire

• avec une valeur de 1 si le revenu > 50k
• 0 si revenu < 50k.

Cette variable est votre étiquette

Cet ensemble de données comprend huit variables catégorielles :

• lieu de travail
• l'éducation
• matrimonial
• occupation
• relations
• breed
• sexe
• pays d'origine

de plus, six variables continues :

• âge
• fnlwgt
• num_education
• gain_capital
• perte_de_capital
• heures_semaine

Grâce à cet exemple de classification TensorFlow, vous comprendrez comment entraîner des classificateurs TensorFlow linéaires avec l'estimateur TensorFlow et comment améliorer la métrique de précision.

Nous procéderons de la manière suivante :

• Étape 1) Importez les données
• Étape 2) Conversion des données
• Étape 3) Former le classificateur
• Étape 4) Améliorer le modèle
• Étape 5) Hyperparamètre : Lasso et crête

Étape 1) Importez les données

Vous importez d'abord les bibliothèques utilisées lors du tutoriel.

import tensorflow as tf
import pandas as pd

Ensuite, vous importez les données de l'archive de l'UCI et définissez les noms des colonnes. Vous utiliserez COLUMNS pour nommer les colonnes dans un bloc de données pandas.

Notez que vous entraînerez le classificateur à l'aide d'une trame de données Pandas.

## Define path data
COLUMNS = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital',
           'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss',
           'hours_week', 'native_country', 'label']
PATH = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"
PATH_test = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.test"

Les données stockées en ligne sont déjà réparties entre une rame et une rame de test.

df_train = pd.read_csv(PATH, skipinitialspace=True, names = COLUMNS, index_col=False)
df_test = pd.read_csv(PATH_test,skiprows = 1, skipinitialspace=True, names = COLUMNS, index_col=False)

La rame contient 32,561 16,281 observations et la rame de test

print(df_train.shape, df_test.shape)
print(df_train.dtypes)
(32561, 15) (16281, 15)
age                int64
workclass         object
fnlwgt             int64
education         object
education_num      int64
marital           object
occupation        object
relationship      object
race              object
sex               object
capital_gain       int64
capital_loss       int64
hours_week         int64
native_country    object
label             object
dtype: object

Tensorflow nécessite une valeur booléenne pour entraîner le classificateur. Vous devez convertir les valeurs de chaîne en entier. L'étiquette est stockée en tant qu'objet, cependant, vous devez la convertir en valeur numérique. Le code ci-dessous crée un dictionnaire avec les valeurs à convertir et en boucle sur l'élément de colonne. Notez que vous effectuez cette opération deux fois, une pour le test du train, une pour l'ensemble de test

label = {'<=50K': 0,'>50K': 1}
df_train.label = [label[item] for item in df_train.label]
label_t = {'<=50K.': 0,'>50K.': 1}
df_test.label = [label_t[item] for item in df_test.label]

Dans les données ferroviaires, il y a 24,720 50 revenus inférieurs à 7841 et supérieurs. Le rapport est presque le même pour l’ensemble de test. Veuillez vous référer à ce didacticiel sur les facettes pour en savoir plus.

print(df_train["label"].value_counts())
### The model will be correct in atleast 70% of the case
print(df_test["label"].value_counts())
## Unbalanced label
print(df_train.dtypes)
0    24720
1     7841
Name: label, dtype: int64
0    12435
1     3846
Name: label, dtype: int64
age                int64
workclass         object
fnlwgt             int64
education         object
education_num      int64
marital           object
occupation        object
relationship      object
race              object
sex               object
capital_gain       int64
capital_loss       int64
hours_week         int64
native_country    object
label              int64
dtype: object

Étape 2) Conversion des données

Quelques étapes sont nécessaires avant d'entraîner un classificateur linéaire avec Tensorflow. Vous devez préparer les fonctionnalités à inclure dans le modèle. Dans la régression de référence, vous utiliserez les données d'origine sans appliquer aucune transformation.

L'estimateur doit disposer d'une liste de fonctionnalités pour entraîner le modèle. Par conséquent, les données de la colonne doivent être converties en tenseur.

Une bonne pratique consiste à définir deux listes de fonctionnalités en fonction de leur type, puis à les transmettre dans les feature_columns de l'estimateur.

Vous commencerez par convertir des fonctionnalités continues, puis définirez un compartiment avec les données catégorielles.

Les caractéristiques de l'ensemble de données ont deux formats :

• Entier
• Exlcusion

Chaque fonctionnalité est répertoriée dans les deux variables suivantes selon leurs types.

## Add features to the bucket: 
### Define continuous list
CONTI_FEATURES  = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week']
### Define the categorical list
CATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country']

Le feature_column est équipé d'un objet numeric_column pour aider à la transformation des variables continues en tenseur. Dans le code ci-dessous, vous convertissez toutes les variables de CONTI_FEATURES en un tenseur avec une valeur numérique. Ceci est obligatoire pour construire le modèle. Toutes les variables indépendantes doivent être converties dans le type de tenseur approprié.

Ci-dessous, nous écrivons un code pour vous permettre de voir ce qui se passe derrière feature_column.numeric_column. Nous imprimerons la valeur convertie pour l'âge. C'est à des fins explicatives, il n'est donc pas nécessaire de comprendre le code python. Vous pouvez vous référer à la documentation officielle pour comprendre les codes.

def print_transformation(feature = "age", continuous = True, size = 2): 
    #X = fc.numeric_column(feature)
    ## Create feature name
    feature_names = [
    feature]

    ## Create dict with the data
    d = dict(zip(feature_names, [df_train[feature]]))

    ## Convert age
    if continuous == True:
        c = tf.feature_column.numeric_column(feature)
        feature_columns = [c]
    else: 
        c = tf.feature_column.categorical_column_with_hash_bucket(feature, hash_bucket_size=size) 
        c_indicator = tf.feature_column.indicator_column(c)
        feature_columns = [c_indicator]
    
## Use input_layer to print the value
    input_layer = tf.feature_column.input_layer(
        features=d,
        feature_columns=feature_columns
        )
    ## Create lookup table
    zero = tf.constant(0, dtype=tf.float32)
    where = tf.not_equal(input_layer, zero)
    ## Return lookup tble
    indices = tf.where(where)
    values = tf.gather_nd(input_layer, indices)
    ## Initiate graph
    sess = tf.Session()
    ## Print value
    print(sess.run(input_layer))
print_transformation(feature = "age", continuous = True) 
[[39.]
 [50.]
 [38.]
 ...
 [58.]
 [22.]
 [52.]]

Les valeurs sont exactement les mêmes que dans df_train

continuous_features = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES]

Selon la documentation TensorFlow, il existe différentes manières de convertir des données catégorielles. Si la liste de vocabulaire d'une fonctionnalité est connue et ne contient pas beaucoup de valeurs, il est possible de créer la colonne catégorielle avec categorical_column_with_vocabulary_list. Il attribuera à chaque liste de vocabulaire unique un identifiant.

Par exemple, si un statut de variable a trois valeurs distinctes :

• Mari
• femme
• Single

Ensuite trois identifiants seront attribués. Par exemple, le mari aura l'ID 1, la femme l'ID 2 et ainsi de suite.

À des fins d'illustration, vous pouvez utiliser ce code pour convertir une variable d'objet en colonne catégorielle dans TensorFlow.

La caractéristique sexe ne peut avoir que deux valeurs : masculine ou féminine. Lorsque nous convertirons la fonctionnalité sexe, Tensorflow créera 2 nouvelles colonnes, une pour les hommes et une pour les femmes. Si le sexe est égal à masculin, alors la nouvelle colonne masculin sera égal à 1 et féminin à 0. Cet exemple est affiché dans le tableau ci-dessous :

lignes	sexe	après transformation	mâle	femelle
1	mâle	=>	1	0
2	mâle	=>	1	0
3	femelle	=>	0	1

En flux tensoriel :

print_transformation(feature = "sex", continuous = False, size = 2)
[[1. 0.]
 [1. 0.]
 [1. 0.]
 ...
 [0. 1.]
 [1. 0.]
 [0. 1.]]

relationship = tf.feature_column.categorical_column_with_vocabulary_list(
    'relationship', [
        'Husband', 'Not-in-family', 'Wife', 'Own-child', 'Unmarried',
        'Other-relative'])

Ci-dessous, nous avons ajouté Python code pour imprimer l’encodage. Encore une fois, vous n'avez pas besoin de comprendre le code, le but est de voir la transformation

Cependant, un moyen plus rapide de transformer les données consiste à utiliser la méthode categorical_column_with_hash_bucket. La modification des variables de chaîne dans une matrice clairsemée sera utile. Une matrice clairsemée est une matrice contenant principalement zéro. La méthode s’occupe de tout. Il vous suffit de spécifier le nombre de buckets et la colonne clé. Le nombre de compartiments correspond au nombre maximum de groupes que Tensorflow peut créer. La colonne clé est simplement le nom de la colonne à convertir.

Dans le code ci-dessous, vous créez une boucle sur toutes les fonctionnalités catégorielles.

categorical_features = [tf.feature_column.categorical_column_with_hash_bucket(k, hash_bucket_size=1000) for k in CATE_FEATURES]

Étape 3) Former le classificateur

TensorFlow fournit actuellement un estimateur pour la régression linéaire et la classification linéaire.

• Régression linéaire : LinearRegressor
• Classification linéaire : LinearClassifier

La syntaxe du classificateur linéaire est la même que dans le tutoriel sur régression linéaire sauf pour un argument, n_class. Vous devez définir la colonne de fonctionnalités, le répertoire du modèle et comparer avec le régresseur linéaire ; vous devez définir le numéro de classe. Pour une régression logit, le nombre de classes est égal à 2.

Le modèle calculera les poids des colonnes contenues danscontinu_features et categorical_features.

model = tf.estimator.LinearClassifier(
    n_classes = 2,
    model_dir="ongoing/train", 
    feature_columns=categorical_features+ continuous_features)

Sortie

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'ongoing/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': 
<tensorflow.python.training.server_lib.ClusterSpec object at 0x181f24c898>, '_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}

Maintenant que le classificateur est défini, vous pouvez créer la fonction d'entrée. La méthode est la même que dans le didacticiel du régresseur linéaire. Ici, vous utilisez une taille de lot de 128 et vous mélangez les données.

FEATURES = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country']
LABEL= 'label'
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 créez une fonction avec les arguments requis par l'estimateur linéaire, c'est-à-dire le nombre d'époques, le nombre de lots et mélangez l'ensemble de données ou la note. Puisque vous utilisez le Pandas méthode pour transmettre les données dans le modèle, vous devez définir les variables X comme une trame de données pandas. Notez que vous parcourez toutes les données stockées dans FEATURES.

Entraîneons le modèle avec l'objet model.train. Vous utilisez la fonction définie précédemment pour alimenter le modèle avec les valeurs appropriées. Notez que vous définissez la taille du lot sur 128 et le nombre d'époques sur Aucun. Le modèle sera formé sur mille étapes.

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

									 
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 ongoing/train/model.ckpt.
INFO:tensorflow:loss = 88.722855, step = 1
INFO:tensorflow:global_step/sec: 65.8282
INFO:tensorflow:loss = 52583.64, step = 101 (1.528 sec)
INFO:tensorflow:global_step/sec: 118.386
INFO:tensorflow:loss = 25203.816, step = 201 (0.837 sec)
INFO:tensorflow:global_step/sec: 110.542
INFO:tensorflow:loss = 54924.312, step = 301 (0.905 sec)
INFO:tensorflow:global_step/sec: 199.03
INFO:tensorflow:loss = 68509.31, step = 401 (0.502 sec)
INFO:tensorflow:global_step/sec: 167.488
INFO:tensorflow:loss = 9151.754, step = 501 (0.599 sec)
INFO:tensorflow:global_step/sec: 220.155
INFO:tensorflow:loss = 34576.06, step = 601 (0.453 sec)
INFO:tensorflow:global_step/sec: 199.016
INFO:tensorflow:loss = 36047.117, step = 701 (0.503 sec)
INFO:tensorflow:global_step/sec: 197.531
INFO:tensorflow:loss = 22608.148, step = 801 (0.505 sec)
INFO:tensorflow:global_step/sec: 208.479
INFO:tensorflow:loss = 22201.918, step = 901 (0.479 sec)
INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train/model.ckpt.
INFO:tensorflow:Loss for final step: 5444.363.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x181f223630>

A noter que la perte a diminué par la suite au cours des 100 dernières étapes, soit de 901 à 1000.

La perte finale après mille itérations est de 5444 1. Vous pouvez estimer votre modèle sur l'ensemble de test et voir les performances. Pour évaluer les performances de votre modèle, vous devez utiliser l'objet évaluer. Vous alimentez le modèle avec l'ensemble de test et définissez le nombre d'époques sur , c'est-à-dire que les données ne seront transmises au modèle qu'une seule fois.

model.evaluate(input_fn=get_input_fn(df_test, 
                                      num_epochs=1,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)

									  
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:22
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:23
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.7615626, accuracy_baseline = 0.76377374, auc = 0.63300294, auc_precision_recall = 0.50891197, average_loss = 47.12155, global_step = 1000, label/mean = 0.23622628, loss = 5993.6406, precision = 0.49401596, prediction/mean = 0.18454961, recall = 0.38637546

{'accuracy': 0.7615626,
 'accuracy_baseline': 0.76377374,
 'auc': 0.63300294,
 'auc_precision_recall': 0.50891197,
 'average_loss': 47.12155,
 'global_step': 1000,
 'label/mean': 0.23622628,
 'loss': 5993.6406,
 'precision': 0.49401596,
 'prediction/mean': 0.18454961,
 'recall': 0.38637546}

TensorFlow renvoie toutes les métriques que vous avez apprises dans la partie théorique. Sans surprise, la précision est grande du fait du label déséquilibré. En fait, le modèle fonctionne légèrement mieux qu’une estimation aléatoire. Imaginez que le modèle prédit tous les ménages dont le revenu est inférieur à 50 70, alors le modèle a une précision de %. En analysant de plus près, vous pouvez voir que la prédiction et le rappel sont assez faibles.

Étape 4) Améliorer le modèle

Maintenant que vous disposez d’un modèle de référence, vous pouvez essayer de l’améliorer, c’est-à-dire d’augmenter la précision. Dans le didacticiel précédent, vous avez appris comment améliorer la puissance de prédiction avec un terme d'interaction. Dans ce didacticiel, vous revisiterez cette idée en ajoutant un terme polynomial à la régression.

La régression polynomiale est déterminante en cas de non-linéarité des données. Il existe deux manières de capturer la non-linéarité des données.

• Ajouter un terme polynomial
• Bucketize la variable continue dans une variable catégorielle

Terme polynomial

Dans l’image ci-dessous, vous pouvez voir ce qu’est une régression polynomiale. C'est une équation avec X variables de puissance différente. Une régression polynomiale du deuxième degré comporte deux variables, X et X au carré. Le troisième degré a trois variables, X, X², et X³

Ci-dessous, nous avons construit un graphique avec deux variables, X et Y. Il est évident que la relation n'est pas linéaire. Si nous ajoutons une régression linéaire, nous pouvons voir que le modèle est incapable de capturer le modèle (image de gauche).

Maintenant, regardez l'image de gauche de l'image ci-dessous, nous avons ajouté cinq termes à la régression (c'est-à-dire y=x+x²+x³+x⁴+x⁵. Le modèle capture désormais bien mieux le motif. C'est le pouvoir de la régression polynomiale.

Revenons à notre exemple. L'âge n'est pas en relation linéaire avec le revenu. Un âge précoce peut donner lieu à un revenu stable proche de zéro parce que les enfants ou les jeunes ne travaillent pas. Ensuite, il augmente en âge de travailler et diminue pendant la retraite. Il s'agit généralement d'une forme en U inversé. Une façon de capturer ce modèle consiste à ajouter une puissance deux à la régression.

Voyons si cela augmente la précision.

Vous devez ajouter cette nouvelle fonctionnalité à l'ensemble de données et dans la liste des fonctionnalités continues.

Vous ajoutez la nouvelle variable dans l'ensemble de données d'entraînement et de test, il est donc plus pratique d'écrire une fonction.

def square_var(df_t, df_te, var_name = 'age'):
    df_t['new'] = df_t[var_name].pow(2) 
    df_te['new'] = df_te[var_name].pow(2) 
    return df_t, df_te

La fonction a 3 arguments :

• df_t : définir l'ensemble d'entraînement
• df_te : définir l'ensemble de test
• var_name = 'age' : Définit la variable à transformer

Vous pouvez utiliser l'objet pow(2) pour mettre au carré la variable age. Notez que la nouvelle variable est nommée 'new'

Maintenant que la fonction square_var est écrite, vous pouvez créer les nouveaux ensembles de données.

df_train_new, df_test_new = square_var(df_train, df_test, var_name = 'age')

Comme vous pouvez le constater, le nouvel ensemble de données possède une fonctionnalité supplémentaire.

print(df_train_new.shape, df_test_new.shape)			
(32561, 16) (16281, 16)

La variable carrée est appelée nouvelle dans l'ensemble de données. Vous devez l'ajouter à la liste des fonctionnalités continues.

CONTI_FEATURES_NEW  = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week', 'new']
continuous_features_new = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES_NEW]

Note que vous avez changé le répertoire du Graph. Vous ne pouvez pas entraîner différents modèles dans le même répertoire. Cela signifie que vous devez changer le chemin de l'argument model_dir. Si vous ne le faites pas, TensorFlow générera une erreur.

model_1 = tf.estimator.LinearClassifier(
    model_dir="ongoing/train1", 
    feature_columns=categorical_features+ continuous_features_new)

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'ongoing/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': 
<tensorflow.python.training.server_lib.ClusterSpec object at 0x1820f04b70>, '_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}
FEATURES_NEW = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country', 'new']
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_NEW}),
       y = pd.Series(data_set[LABEL].values),
       batch_size=n_batch,   
       num_epochs=num_epochs,
       shuffle=shuffle)

Maintenant que le classificateur est conçu avec le nouvel ensemble de données, vous pouvez entraîner et évaluer le modèle.

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

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 ongoing/train1/model.ckpt.
INFO:tensorflow:loss = 88.722855, step = 1
INFO:tensorflow:global_step/sec: 81.487
INFO:tensorflow:loss = 70077.66, step = 101 (1.228 sec)
INFO:tensorflow:global_step/sec: 111.169
INFO:tensorflow:loss = 49522.082, step = 201 (0.899 sec)
INFO:tensorflow:global_step/sec: 128.91
INFO:tensorflow:loss = 107120.57, step = 301 (0.776 sec)
INFO:tensorflow:global_step/sec: 132.546
INFO:tensorflow:loss = 12814.152, step = 401 (0.755 sec)
INFO:tensorflow:global_step/sec: 162.194
INFO:tensorflow:loss = 19573.898, step = 501 (0.617 sec)
INFO:tensorflow:global_step/sec: 204.852
INFO:tensorflow:loss = 26381.986, step = 601 (0.488 sec)
INFO:tensorflow:global_step/sec: 188.923
INFO:tensorflow:loss = 23417.719, step = 701 (0.529 sec)
INFO:tensorflow:global_step/sec: 192.041
INFO:tensorflow:loss = 23946.049, step = 801 (0.521 sec)
INFO:tensorflow:global_step/sec: 197.025
INFO:tensorflow:loss = 3309.5786, step = 901 (0.507 sec)
INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train1/model.ckpt.
INFO:tensorflow:Loss for final step: 28861.898.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1820f04c88>

model_1.evaluate(input_fn=get_input_fn(df_test_new, 
                                      num_epochs=1,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)

INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:37
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:39
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.7944229, accuracy_baseline = 0.76377374, auc = 0.6093755, auc_precision_recall = 0.54885805, average_loss = 111.0046, global_step = 1000, label/mean = 0.23622628, loss = 14119.265, precision = 0.6682401, prediction/mean = 0.09116262, recall = 0.2576703

{'accuracy': 0.7944229,
 'accuracy_baseline': 0.76377374,
 'auc': 0.6093755,
 'auc_precision_recall': 0.54885805,
 'average_loss': 111.0046,
 'global_step': 1000,
 'label/mean': 0.23622628,
 'loss': 14119.265,
 'precision': 0.6682401,
 'prediction/mean': 0.09116262,
 'recall': 0.2576703}

La variable au carré a amélioré la précision de 0.76 à 0.79. Voyons si vous pouvez faire mieux en combinant le terme de bucketisation et d'interaction.

Bucketisation et interaction

Comme vous l’avez vu précédemment, un classificateur linéaire est incapable de capturer correctement le modèle âge-revenu. En effet, il apprend un poids unique pour chaque fonctionnalité. Pour faciliter la tâche du classificateur, vous pouvez notamment regrouper la fonctionnalité. Le bucketing transforme une caractéristique numérique en plusieurs caractéristiques spécifiques en fonction de la plage dans laquelle elle se situe, et chacune de ces nouvelles fonctionnalités indique si l'âge d'une personne se situe dans cette plage.

Grâce à ces nouvelles fonctionnalités, le modèle linéaire peut capturer la relation en apprenant différents poids pour chaque tranche.

Dans TensorFlow, cela se fait avec bucketized_column. Vous devez ajouter la plage de valeurs dans les limites.

age = tf.feature_column.numeric_column('age')
age_buckets = tf.feature_column.bucketized_column(
    age, boundaries=[18, 25, 30, 35, 40, 45, 50, 55, 60, 65])

Vous savez déjà que l’âge n’est pas linéaire avec le revenu. Une autre façon d’améliorer le modèle est l’interaction. Selon TensorFlow, il s'agit d'un croisement de fonctionnalités. Le croisement de fonctionnalités est un moyen de créer de nouvelles fonctionnalités qui sont des combinaisons de fonctionnalités existantes, ce qui peut être utile pour un classificateur linéaire qui ne peut pas modéliser les interactions entre les fonctionnalités.

Vous pouvez ventiler l’âge avec une autre fonctionnalité comme l’éducation. Autrement dit, certains groupes sont susceptibles d'avoir un revenu élevé et d'autres faibles (pensez au doctorant).

education_x_occupation = [tf.feature_column.crossed_column(
    ['education', 'occupation'], hash_bucket_size=1000)]
age_buckets_x_education_x_occupation = [tf.feature_column.crossed_column(
    [age_buckets, 'education', 'occupation'], hash_bucket_size=1000)]

Pour créer une colonne de fonctionnalités croisées, vous utilisez cross_column avec les variables à croiser entre parenthèses. Le hash_bucket_size indique les possibilités de croisement maximales. Pour créer une interaction entre les variables (au moins une variable doit être catégorique), vous pouvez utiliser tf.feature_column.crossed_column. Pour utiliser cet objet, vous devez ajouter entre crochets la variable avec laquelle interagir et un deuxième argument, la taille du bucket. La taille du bucket correspond au nombre maximum de groupes possibles dans une variable. Ici vous le fixez à 1000 car vous ne connaissez pas le nombre exact de groupes

age_buckets doit être mis au carré avant de l'ajouter aux colonnes de fonctionnalités. Vous ajoutez également les nouvelles fonctionnalités aux colonnes de fonctionnalités et préparez l'estimateur

base_columns = [
    age_buckets,
]

model_imp = tf.estimator.LinearClassifier(
    model_dir="ongoing/train3", 
    feature_columns=categorical_features+base_columns+education_x_occupation+age_buckets_x_education_x_occupation)

Sortie

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'ongoing/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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1823021be0>, '_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}

FEATURES_imp = ['age','workclass', 'education', 'education_num', 'marital',
                'occupation', 'relationship', 'race', 'sex', 'native_country', 'new']

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_imp}),
       y = pd.Series(data_set[LABEL].values),
       batch_size=n_batch,   
       num_epochs=num_epochs,
       shuffle=shuffle)

Vous êtes prêt à estimer le nouveau modèle et à voir s'il améliore la précision.

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

									  
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 ongoing/train3/model.ckpt.
INFO:tensorflow:loss = 88.722855, step = 1
INFO:tensorflow:global_step/sec: 94.969
INFO:tensorflow:loss = 50.334488, step = 101 (1.054 sec)
INFO:tensorflow:global_step/sec: 242.342
INFO:tensorflow:loss = 56.153225, step = 201 (0.414 sec)
INFO:tensorflow:global_step/sec: 213.686
INFO:tensorflow:loss = 45.792007, step = 301 (0.470 sec)
INFO:tensorflow:global_step/sec: 174.084
INFO:tensorflow:loss = 37.485672, step = 401 (0.572 sec)
INFO:tensorflow:global_step/sec: 191.78
INFO:tensorflow:loss = 56.48449, step = 501 (0.524 sec)
INFO:tensorflow:global_step/sec: 163.436
INFO:tensorflow:loss = 32.528934, step = 601 (0.612 sec)
INFO:tensorflow:global_step/sec: 164.347
INFO:tensorflow:loss = 37.438057, step = 701 (0.607 sec)
INFO:tensorflow:global_step/sec: 154.274
INFO:tensorflow:loss = 61.1075, step = 801 (0.647 sec)
INFO:tensorflow:global_step/sec: 189.14
INFO:tensorflow:loss = 44.69645, step = 901 (0.531 sec)
INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train3/model.ckpt.
INFO:tensorflow:Loss for final step: 44.18133.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1823021cf8>

model_imp.evaluate(input_fn=get_input_fn(df_test_new, 
                                      num_epochs=1,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)

									  
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:52
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train3/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:54
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.8358209, accuracy_baseline = 0.76377374, auc = 0.88401634, auc_precision_recall = 0.69599575, average_loss = 0.35122654, global_step = 1000, label/mean = 0.23622628, loss = 44.67437, precision = 0.68986726, prediction/mean = 0.23320661, recall = 0.55408216


{'accuracy': 0.8358209,
 'accuracy_baseline': 0.76377374,
 'auc': 0.88401634,
 'auc_precision_recall': 0.69599575,
 'average_loss': 0.35122654,
 'global_step': 1000,
 'label/mean': 0.23622628,
 'loss': 44.67437,
 'precision': 0.68986726,
 'prediction/mean': 0.23320661,
 'recall': 0.55408216}

Le nouveau niveau de précision est de 83.58 pour cent. C'est quatre pour cent de plus que le modèle précédent.

Enfin, vous pouvez ajouter un terme de régularisation pour éviter le surajustement.

Étape 5) Hyperparamètre : Lasso et crête

Votre modèle peut souffrir de surajustement or sous-ajustement.

• Surajustement : le modèle est incapable de généraliser la prédiction à de nouvelles données
• Sous-ajustement : le modèle est incapable de capturer le modèle des données. c'est-à-dire une régression linéaire lorsque les données sont non linéaires

Lorsqu’un modèle comporte de nombreux paramètres et une quantité de données relativement faible, il conduit à de mauvaises prédictions. Imaginez, un groupe n'a que trois observations ; le modèle calculera un poids pour ce groupe. Le poids est utilisé pour faire une prédiction ; si les observations de l'ensemble de test pour ce groupe particulier sont entièrement différentes de l'ensemble d'apprentissage, alors le modèle fera une prédiction erronée. Lors de l'évaluation avec l'ensemble d'entraînement, la précision est bonne, mais pas bonne avec l'ensemble de test car les poids calculés ne sont pas les vrais pour généraliser le modèle. Dans ce cas, il ne fait pas de prédiction raisonnable sur des données invisibles.

Pour éviter le surajustement, la régularisation vous donne la possibilité de contrôler une telle complexité et de la rendre plus généralisable. Il existe deux techniques de régularisation :

• L1 : Lasso
• L2 : Crête

Dans TensorFlow, vous pouvez ajouter ces deux hyperparamètres dans l'optimiseur. Par exemple, plus l’hyperparamètre L2 est élevé, plus le poids tend à être très faible et proche de zéro. La droite ajustée sera très plate, tandis qu'un L2 proche de zéro implique que les poids sont proches de la régression linéaire régulière.

Vous pouvez essayer par vous-même les différentes valeurs des hyperparamètres et voir si vous pouvez augmenter le niveau de précision.

Note que si vous modifiez l'hyperparamètre, vous devez supprimer le dossier en cours/train4 sinon le modèle démarrera avec le modèle précédemment entraîné.

Voyons quelle est la précision avec le battage médiatique

model_regu = tf.estimator.LinearClassifier(
    model_dir="ongoing/train4", feature_columns=categorical_features+base_columns+education_x_occupation+age_buckets_x_education_x_occupation,
    optimizer=tf.train.FtrlOptimizer(
        learning_rate=0.1,
        l1_regularization_strength=0.9,
        l2_regularization_strength=5))

SORTIE

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train4', '_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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1820d9c128>, '_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}

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

SORTIE

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 ongoing/train4/model.ckpt.
INFO:tensorflow:loss = 88.722855, step = 1
INFO:tensorflow:global_step/sec: 77.4165
INFO:tensorflow:loss = 50.38778, step = 101 (1.294 sec)
INFO:tensorflow:global_step/sec: 187.889
INFO:tensorflow:loss = 55.38014, step = 201 (0.535 sec)
INFO:tensorflow:global_step/sec: 201.895
INFO:tensorflow:loss = 46.806694, step = 301 (0.491 sec)
INFO:tensorflow:global_step/sec: 217.992
INFO:tensorflow:loss = 38.68271, step = 401 (0.460 sec)
INFO:tensorflow:global_step/sec: 193.676
INFO:tensorflow:loss = 56.99398, step = 501 (0.516 sec)
INFO:tensorflow:global_step/sec: 202.195
INFO:tensorflow:loss = 33.263622, step = 601 (0.497 sec)
INFO:tensorflow:global_step/sec: 216.756
INFO:tensorflow:loss = 37.7902, step = 701 (0.459 sec)
INFO:tensorflow:global_step/sec: 240.215
INFO:tensorflow:loss = 61.732605, step = 801 (0.416 sec)
INFO:tensorflow:global_step/sec: 220.336
INFO:tensorflow:loss = 46.938225, step = 901 (0.456 sec)
INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train4/model.ckpt.
INFO:tensorflow:Loss for final step: 43.4942.


<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x181ff39e48>

model_regu.evaluate(input_fn=get_input_fn(df_test_new, 
                                      num_epochs=1,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)

Sortie

INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:29:07
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train4/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:29:09
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.83833915, accuracy_baseline = 0.76377374, auc = 0.8869794, auc_precision_recall = 0.7014905, average_loss = 0.34691378, global_step = 1000, label/mean = 0.23622628, loss = 44.12581, precision = 0.69720596, prediction/mean = 0.23662092, recall = 0.5579823





{'accuracy': 0.83833915,
 'accuracy_baseline': 0.76377374,
 'auc': 0.8869794,
 'auc_precision_recall': 0.7014905,
 'average_loss': 0.34691378,
 'global_step': 1000,
 'label/mean': 0.23622628,
 'loss': 44.12581,
 'precision': 0.69720596,
 'prediction/mean': 0.23662092,
 'recall': 0.5579823}

Avec cet hyperparamètre, vous augmentez légèrement les mesures de précision. Dans le prochain didacticiel, vous apprendrez comment améliorer un classificateur linéaire à l'aide d'une méthode noyau.

Synthèse

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

• Définir les fonctionnalités : Variables indépendantes : X
• Définir le label : Variable dépendante : y
• Construire un ensemble de train/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
  • Nombre de classe

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

1. Colonnes de fonctionnalités. Si continu : tf.feature_column.numeric_column(). Vous pouvez remplir une liste avec la compréhension de la liste Python
2. L'estimateur : tf.estimator.LinearClassifier(feature_columns, model_dir, n_classes = 2)
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 une prédiction avec train(), évalue() et prédire().

Pour améliorer les performances du modèle, vous pouvez :

• Utiliser la régression polynomiale
• Terme d'interaction : tf.feature_column.crossed_column
• Ajouter un paramètre de régularisation