[Python] J'ai expliqué en détail la théorie et la mise en œuvre de la régression logistique

introduction

Dans cet article, nous allons implémenter la régression logistique à l'aide de tensorflow et sckit-learn.

J'ai résumé la régression linéaire dans l'article précédent, veuillez donc consulter l'article suivant si vous le souhaitez.

Essayez une analyse de régression multiple en utilisant scicit-learn, tensorflow et keras en Python

Cette fois, nous utiliserons le jeu de données iris.

À propos du jeu de données iris

les données d'iris sont des données d'une variété de fleurs appelée iris.

Il existe 50 données sur chacune des trois variétés d'iris, «Setosa», «Virginica» et «Virginica», pour un total de 150 données.

Regardons réellement le contenu.

from sklearn.datasets import load_iris
import pandas as pd

iris = load_iris()
iris_df = pd.DataFrame(iris.data, columns=iris.feature_names)

print(iris_df.head())

sepal length (cm) sepal width (cm) petal length (cm) petal width (cm) 0 5.1 3.5 1.4 0.2 1 4.9 3.0 1.4 0.2 2 4.7 3.2 1.3 0.2 3 4.6 3.1 1.5 0.2 4 5.0 3.6 1.4 0.2

Puisque chaque nom de colonne est stocké dans iris.feature_names, vous pouvez sortir les données ci-dessus en les passant à l'argument de Dataframe of pandas.

«Sepal Length» stocke la longueur du pétale, «Sepal Width» stocke la largeur du pétale, «Petal length» stocke la longueur du pétale et «Petal Width» stocke les données de largeur du pétale. Je suis.

Vous pouvez afficher l'étiquette de réponse correcte comme indiqué ci-dessous.

print(iris.target)

[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]

De cette manière, les variétés d'iris «setosa», «versicolor» et «virginica» sont fixées respectivement à 0, 1 et 2.

Cette fois, nous supprimerons les données de virginica car nous effectuerons une classification binaire par régression logistique.

Ensuite, en fonction de la variable objectif, créez un modèle qui identifie s'il s'agit de "setosa" ou "versicolor".

À propos de la régression logistique

Je vais expliquer la régression logistique.

La régression logistique est appelée régression, mais ce que nous faisons est une classification binaire.

Prédire en calculant la probabilité en fonction de certaines variables explicatives. Dans cet exemple, nous identifierons s'il s'agit de "setosa" ou "versicolor" en fonction de la longueur et de la largeur des pétales.

Maintenant, sautons un peu, mais considérons un modèle d'apprentissage automatique lorsque tous les modèles sont approximés linéairement.

Maintenant, en supposant que la variable objective est «le nombre de visiteurs de la piscine» et que la variable explicative est «température», une régression linéaire est effectuée.

Dans ce cas, le nombre de visiteurs à gauche est appelé la variable de réponse et la formule à droite est appelée le prédicteur linéaire.

Mais c'est évidemment un mauvais modèle, n'est-ce pas? Car la formule de droite peut être négative en fonction de la température, mais le nombre de visiteurs ne peut pas être négatif.

Par conséquent, pour que la variable de réponse corresponde au prédicteur linéaire, changez comme suit.

En appliquant la fonction logarithmique au côté gauche de cette manière, nous avons pu faire correspondre correctement les deux côtés. La fonction logarithmique dans ce cas est appelée la fonction de lien.

Ensuite, faisons de la réussite de l'examen d'entrée la variable objective. Dans ce cas, bien sûr, ce sera 0 ou 1 car il réussit ou échoue.

Définissons la variable explicative pour étudier le temps. Les modèles suivants peuvent être envisagés.

Ce modèle n'est pas non plus un bon modèle. Le côté gauche est seulement 0 ou 1, mais évidemment le côté droit ne lui correspond pas.

Ensuite, que se passe-t-il si la variable objective est le taux de réussite comme suit?

Ce modèle n'est pas non plus un bon modèle. Le taux de réussite sur le côté gauche varie de 0 à 1, mais pas sur le côté droit.

Afin de faire correspondre cette variable de réponse au prédicteur linéaire, une fonction logit est utilisée comme fonction de lien. La fonction logit est exprimée par la formule suivante.

f(p) = ln(\frac{p}{1-p}) \quad (0 < p < 1))

Veuillez vous référer à l'article ici pour la fonction logit.

Pour l'événement A qui se produit avec la probabilité p, le rapport entre la probabilité que A se produise et la probabilité qu'il ne se produise pas $ \ frac {p} {1-p} $ est appelé «ods».

La fonction logit a la forme suivante.

Si vous utilisez la fonction logit comme fonction de liaison, vous pouvez créer le modèle suivant avec le taux de réussite p.

ln(\frac{p}{1-p}) = β_0 + β_1 × temps d'étude

Ce modèle est un bon modèle car le côté gauche et le côté droit correspondent.

Cependant, ce que nous voulons maintenant, c'est un modèle qui prédit le taux de réussite, résolvons donc p. Supposons que le temps d'étude soit de $ x_1 $.

\begin{align}
ln(\frac{p}{1-p}) &= β_0 + β_1 × x_1\\
ln(\frac{p}{1-p}) &= z \quad  (z = β_0 + β_1 × x_1)\\
\frac{p}{1-p}&=e^z\\
p& = e^z - e^zp\\
p &= \frac{e^z}{1+e^z}\\
p & = \frac{1}{1+e^{-z}}
\end{align}

De cette manière, la fonction sigmoïde peut être dérivée. Généraliser un peu plus z

z= β_0 + β_1 × x_1  + β_2 × x_2 ... + β_n × x_n

Disons. C'est la formule utilisée pour la régression logistique, et le but est d'optimiser β.

À propos de l'optimisation β

En considérant l'équation suivante, β peut être optimisé par la méthode des moindres carrés de la même manière que l'analyse de régression multiple.

ln(\frac{p}{1-p}) = β_0 + β_1 × x_1  + β_2 × x_2 ... + β_n × x_n

Veuillez vous référer à l'article ici pour la méthode des moindres carrés.

L'autre consiste à utiliser la méthode la plus probable.

À propos de la méthode la plus probable

La méthode la plus probable est résumée dans l'article ici d'une manière facile à comprendre, alors veuillez vous y référer.

Je vais expliquer brièvement la méthode la plus probable.

Afin de réfléchir à la méthode la plus probable, nous devons comprendre la vraisemblance et la fonction de vraisemblance.

Ce qui suit est une citation de Kotobank.

Yudo [probabilité de probabilité] Dans la fonction de densité de probabilité, la valeur observée est affectée à la variable de probabilité. En d'autres termes, il s'agit d'une valeur évaluée par la valeur observée de la densité de probabilité. De plus, lorsque celle-ci est considérée comme fonction d'une population inconnue, elle est surtout appelée fonction de vraisemblance. La logarithmique naturelle de la fonction de vraisemblance est appelée vraisemblance logarithmique. Compte tenu des valeurs observées et de leur distribution de probabilité, la valeur de la matrice qui maximise la vraisemblance ou la vraisemblance logarithmique donne une estimation naturelle de la matrice. C'est ce qu'on appelle l'estimateur le plus probable et possède diverses propriétés d'agression favorables telles qu'une correspondance étroite avec la valeur réelle de la population lorsque la taille de l'échantillon augmente et une distribution normale.

Ce qui suit est une citation de wikipedia.

Qu'est-ce que la fonction de vraisemblance En statistique, lorsqu'un résultat apparaît selon une certaine condition préalable, au contraire, on déduit du résultat de l'observation que la condition préalable était «quoi». La valeur numérique représentant la plausibilité (plausibilité) est considérée comme une fonction avec «quoi» comme variable. C'est aussi simplement appelé vraisemblance.

Je ne suis pas sûr, alors vérifions-le avec une formule.

Lorsque N données $ x_1, x_2, x_3, ..., x_n $ sont observées et que la probabilité que chaque valeur se produise est p (x), la fonction de vraisemblance est exprimée par la formule suivante.

À partir de ce moment, je comprends que la méthode la plus probable est une méthode d'estimation de la «distribution de probabilité que suivent les données d'origine» en considérant la «probabilité que les données se produisent lorsque les données sont observées». Veuillez réfléchir.

Par exemple, envisagez de lancer une pièce. Bien sûr, le recto et le verso de la pièce ont la même probabilité sauf s'il y a un calmar.

C'est le «procès de Bernouy» en statistiques.

Cependant, dans le monde réel, il est rare de manipuler des choses telles que des pièces de monnaie dont la distribution de probabilité est sensuellement connue. Donc, cette fois, nous supposerons que les chances d'obtenir le recto et le verso de la pièce ne sont pas égales.

Comment puis-je trouver la distribution de probabilité que suit cette pièce?

Il semble que vous devriez jeter beaucoup de pièces et garder un registre. Maintenant, quand j'ai jeté la pièce trois fois, elle est devenue avant, avant et arrière.

Si la probabilité d'apparition du front est $ p $, la probabilité d'apparition du verso est $ 1-p , donc la probabilité que cet événement se produise, c'est-à-dire la fonction de vraisemblance $p^2(1-p)$$

Ce sera. Maintenant, c'est arrivé. Par exemple, si la probabilité que la pièce apparaisse au recto est $ \ frac {1} {2} $ et la probabilité que la pièce apparaisse au verso est $ \ frac {1} {2} $, la probabilité que cet événement se produise est $ \ frac {1} {8}. Ce sera $. Si la probabilité que la pièce apparaisse au recto est $ \ frac {2} {3} $ et que la probabilité que la pièce apparaisse au verso est $ \ frac {1} {3} $, la probabilité que cet événement se produise est $ \ frac {4} {27} $ Ce sera.

En pensant de cette manière, lorsque l'on considère la probabilité que la pièce sortira $ p $ et la probabilité que la pièce sortira $ 1-p $ à la condition que "lancez la pièce trois fois et elle deviendra avant, avant, arrière" De plus, la méthode la plus probable est utilisée pour déterminer quel type de $ p $ est (le plus) probable.

Maintenant, le phénomène "quand j'ai lancé une pièce trois fois, c'était devant, devant, derrière" s'est produit, donc le $ p $ plausible est celui-ci "quand j'ai lancé une pièce trois fois, devant, devant, derrière" C'est $ p $ qui maximise la probabilité que l'événement "était" se produise.

En d'autres termes, pour trouver le $ p $ "probable" (méthode la plus probable), il suffit de sélectionner $ p $ qui a la plus grande fonction de vraisemblance, qui est la "probabilité de l'événement".

En d'autres termes, dans cet exemple, il suffit de trouver $ p $ qui maximise $ p ^ 2 (1-p) $, ainsi le logarithme des deux côtés peut être utilisé pour la différenciation, ou la valeur peut être différenciée telle quelle et la valeur maximale est $ p $. Cela a l'air bien si vous demandez.

De cette manière, la méthode de recherche de la distribution de probabilité que les données originales découle du résultat est appelée estimation la plus probable ou estimation bayésienne.

Cette fois, je savais depuis le début qu'elle suivrait la distribution de Bernoulli à l'avant et à l'arrière, donc je pourrais facilement trouver la fonction de vraisemblance, mais en réalité, je dois penser à partir du point de trouver la distribution de probabilité (distribution normale, etc.) que suivent les données originales. Ce sera plus difficile car ce ne sera pas le cas.

La diapositive de ici était très facile à comprendre, alors veuillez vous y référer.

À propos de l'optimisation β à nouveau

Considérons la fonction de vraisemblance pour cette régression logistique. Pour la régression logistique, étant donné la variable objective en (0, 1) et les variables explicatives $ x_1, x_2, x_3, ..., x_n $ pour certaines données, la probabilité que la variable objective pour ces données soit 1. $ p $ est

p  = \frac{1}{1+e^{-z}}　\quad (z= β_0 + β_1 × x_1  + β_2 × x_2 ... + β_n × x_n)

Ce sera. La probabilité que la variable objectif soit 1 est $ p $, et la probabilité que la variable objectif sera 0 est $ 1-p $.

Lorsqu'on sait si la variable objective est (0, 1) pour "certaines données", c'est-à-dire quelles données sont ces données (dans cet exemple d'iris, qui est "Setosa" ou "Virginica"? Pensez à quand vous savez.

En supposant que la probabilité que «certaines données» soient les données de la «variable objectif» est de $ L $, le $ p $ ci-dessus (probabilité que la variable objectif soit 1) est utilisé, et $ t_n $ est la variable objectif (0, 1). )

L = p^{t_n}(1-p)^{1-t_n}

Peut être exprimé comme. Vous pouvez voir que lorsque la variable objectif est 1, $ L $ est $ p $, et lorsque la variable objectif est 0, $ L $ est $ 1-p $.

En d'autres termes, $ L $ est la "probabilité de l'événement" lorsque la variable objectif est connue, c'est-à-dire lorsque le résultat est connu. Si vous trouvez $ p $ qui maximise $ L $, qui est la probabilité que l'événement se produise, sous la condition que l'événement se soit produit, vous pouvez penser que $ p $ est un $ p $ plausible. Je peux le faire.

Cet exemple concernait un élément de données, alors considérons maintenant toutes les données.

Comme elle est indépendante pour chaque donnée, la fonction de vraisemblance globale peut être considérée comme le produit des fonctions de vraisemblance $ n $ données comme suit.

L(β)=　\prod_{n = 1}^{N}
p_n^{t_n}(1-p_n)^{1-t_n}

Trouvez $ p $ qui maximise la fonction de vraisemblance $ L (β) $ pour ces $ n $ données, c'est-à-dire $ β $ (car $ p $ est une fonction de $ β $) Ce faisant, il semble possible d'optimiser le paramètre $ β $.

Pour faciliter le calcul de la formule ci-dessus, prenez le logarithme des deux côtés et ajoutez un signe moins pour obtenir la formule suivante.

E(β) = -logL(β) = - \sum^N_{n = 1}
\{t_nlogp_n + (1-t_n)log(1-p_n)\}

Le $ E (β) $ ainsi dérivé est appelé la fonction d'erreur d'entropie croisée.

Implémenté avec scikit-learn

Implémentons-le avec sckit-learn. Tout d'abord, préparons l'ensemble de données.

from sklearn.datasets import load_iris
import numpy as np
import pandas as pd
from pandas import Series, DataFrame
import seaborn as sns
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn import metrics
import matplotlib.pyplot as plt

iris = load_iris()
iris_data = iris.data[:100]
iris_target_data = pd.DataFrame(iris.target[:100], columns=['Species'])
iris_df = pd.DataFrame(iris_data, columns=iris.feature_names)

print(iris_df)

sepal length (cm) sepal width (cm) petal length (cm) petal width (cm) 0 5.1 3.5 1.4 0.2 1 4.9 3.0 1.4 0.2 2 4.7 3.2 1.3 0.2 3 4.6 3.1 1.5 0.2 4 5.0 3.6 1.4 0.2 .. ... ... ... ... 95 5.7 3.0 4.2 1.2 96 5.7 2.9 4.2 1.3 97 6.2 2.9 4.3 1.3 98 5.1 2.5 3.0 1.1 99 5.7 2.8 4.1 1.3

Nous classerons les deux données, «setosa» et «versicolor». Par conséquent, nous ne traitons que les 100 premières données.

Les 50 premiers sont des données sur "setoba" et les 50 derniers sont des données sur "versicolor".

Jetons un œil au contenu de iris_target_data.

print(iris_target_data)

Species 0 0 1 0 2 0 3 0 4 0 .. ... 95 1 96 1 97 1 98 1 99 1

De cette manière, c'est une trame de données qui stocke les données 0 et 1.

La raison pour laquelle le tableau numpy d'origine a été renvoyé au Dataframe est d'utiliser la méthode apply du Dataframe comme indiqué ci-dessous.

def species(num):
    if num == 0:
        return 'setosa'
    else:
        return 'versicolor'


iris_target_speacies = iris_target_data['Species'].apply(species)
print(iris_target_speacies)

0 setosa 1 setosa 2 setosa 3 setosa 4 setosa ...
95 versicolor 96 versicolor 97 versicolor 98 versicolor 99 versicolor

En utilisant la méthode Apply de Dataframe de cette manière, vous pouvez exécuter la fonction spécifiée par l'argument de la colonne spécifiée et recevoir le Dataframe avec la valeur de retour attribuée. Vous pouvez combiner horizontalement en spécifiant axis = 1.

Le code suivant combine iris_df et iris_target_speacies.

iris_all_data = pd.concat([iris_df, iris_target_speacies], axis=1)
print(iris_all_data)

sepal length (cm) sepal width (cm) ... petal width (cm) Species 0 5.1 3.5 ... 0.2 setosa 1 4.9 3.0 ... 0.2 setosa 2 4.7 3.2 ... 0.2 setosa 3 4.6 3.1 ... 0.2 setosa 4 5.0 3.6 ... 0.2 setosa .. ... ... ... ... ... 95 5.7 3.0 ... 1.2 versicolor 96 5.7 2.9 ... 1.3 versicolor 97 6.2 2.9 ... 1.3 versicolor 98 5.1 2.5 ... 1.1 versicolor 99 5.7 2.8 ... 1.3 versicolor

Visualisons les données avec le code suivant. Le diagramme de dispersion et le rapport d'abondance pour chaque donnée sont indiqués.

sns.pairplot(iris_all_data, hue='Species')
plt.show()

Il semble que de telles données peuvent être classifiées.

Regardons la table de fréquence pour longueur sépale dans le code suivant.

sns.countplot('sepal length (cm)', data=iris_all_data, hue='Species')
plt.show()

Je pense que vous avez en quelque sorte compris les données.

Apprenez comme c'est

Créons un modèle avec le code suivant. Vous apprendrez tel quel, pas pour la formation et pour les tests.

logistic_model = LogisticRegression()
logistic_model.fit(iris_df, iris_target_data)

Ceci termine la création du modèle.

Avec le code suivant

β_1,β_2,β_3,β_4

Vous pouvez afficher la valeur de.

print(logistic_model.coef_[0])

[-0.40247392 -1.46382925 2.23785648 1.00009294]

Il est difficile de comprendre s'il est laissé tel quel, de sorte que le code suivant l'affichera d'une manière facile à comprendre.

coeff_df = DataFrame([iris_df.columns, logistic_model.coef_[0]]).T
print(coeff_df)

0 1 0 sepal length (cm) -0.402474 1 sepal width (cm) -1.46383 2 petal length (cm) 2.23786 3 petal width (cm) 1.00009

D'après ce résultat, on peut voir que si la «longueur du pétale» ou la «largeur du pétale» est grande, la probabilité d'être «versicolore» est élevée, et si la «largeur du sépale» ou «la longueur du sépale» est grande, la probabilité d'être «setosa» est élevée.

Vous pouvez voir que ce résultat est en bon accord avec le graphique.

Vérifions la précision de la prédiction avec le code suivant. Tester tel quel avec le modèle entraîné.

...py print(logistic_model.score(iris_df, iris_target_data))

>1.0

Il peut être classé avec une précision de 100%. C'est incroyable.

Vous pouvez également vérifier l'exactitude par les méthodes suivantes.

```python
class_predict = logistic_model.predict(iris_df)
print(class_predict)

[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]

En utilisant la méthode prédire, vous pouvez obtenir la valeur prédite pour les données données de cette manière sous la forme d'un tableau de numpy.

ceclass_predictEt l'étiquette de réponse correctemetrics.accuracy_scoreLa précision de la prédiction peut être calculée en comparant avec.

print(metrics.accuracy_score(iris_target_data, class_predict))

1.0

Bien sûr, cette méthode est également à 100%.

####Apprenez séparément pour les tests et la formation Ensuite, étudions les données séparément pour les tests et la formation.

Le code ressemble à ceci:

X_train, X_test, Y_train, Y_test = train_test_split(iris_df, iris_target_data)
logistic_model2 = LogisticRegression()
logistic_model2.fit(X_train, Y_train)
coeff_df2 = DataFrame([iris_df.columns, logistic_model2.coef_[0]]).T
print(coeff_df2)
print(logistic_model2.score(X_test, Y_test))

0 1 0 sepal length (cm) -0.381626 1 sepal width (cm) -1.33919 2 petal length (cm) 2.12026 3 petal width (cm) 0.954906 1.0

Même si les données étaient séparées pour les tests et la formation, la précision des prédictions était de 100%. C'est incroyable.

#Implémenté avec tensorflow Si vous l'implémentez avec tensorflow, vous devez comprendre la formule d'origine. Allons vérifier.

p  = \frac{1}{1+e^{-z}}　\quad (z= β_0 + β_1 × x_1  + β_2 × x_2 ... + β_n × x_n)

L'erreur d'entropie croisée est utilisée pour la fonction de perte. C'est la valeur logarithmique de la fonction de vraisemblance multipliée par moins.

E(β) = -logL(β) = - \sum^N_{n = 1}
\{t_nlogp_n + (1-t_n)log(1-p_n)\}

Mettons-le en œuvre. Préparons les données avec le code suivant.

from sklearn.datasets import load_iris
import numpy as np
import pandas as pd
from pandas import Series, DataFrame
import seaborn as sns
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn import metrics
import matplotlib.pyplot as plt
import tensorflow as tf

iris = load_iris()
iris_data = iris.data[:100]
iris_target_data = pd.DataFrame(iris.target[:100], columns=['Species'])
iris_df = pd.DataFrame(iris_data, columns=iris.feature_names)
X_train, X_test, Y_train, Y_test = train_test_split(iris_df, iris_target_data)

print(X_train.shape)
print(X_test.shape)
print(Y_train.shape)
print(Y_test.shape)

(75, 4) (25, 4) (75, 1) (25, 1)

Créons un modèle avec le code suivant.

X = tf.placeholder(dtype=tf.float32, shape=[None, 4])
W = tf.Variable(tf.zeros([4, 1]))
b = tf.Variable(tf.zeros([1, 1]))
y = tf.nn.sigmoid(tf.matmul(X, W) + b)
y = tf.clip_by_value(y, 1e-10, 1.0 - 1e-10)
t = tf.placeholder(dtype=tf.float32, shape=[None, 1])

La variable explicative est stockée dans X et la variable objectif est stockée dans t. Y est la formule ci-dessuspCela correspond à.

Parce que y est logarithmique lorsqu'il est affecté à la fonction d'erreur d'entropie croiséey = 0Provoquera une erreur, donc y = tf.clip_by_value(y, 1e-10, 1.0 - 1e-10)Par la valeur minimale de y1e-10À la valeur maximale de y 1.0 - 1e-10Je le fais.

Optimisons la fonction d'erreur d'entropie croisée avec Adam avec la formule suivante.

cross_entropy = tf.reduce_sum(t * tf.log(y) + (1 - t) * tf.log(1 - y))
train_step = tf.train.AdamOptimizer(0.001).minimize(cross_entropy)

Maintenant que le modèle est complet, exécutons-le avec le code ci-dessous.

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for step in range(10000):
        if step % 10 == 0:
            loss_val = sess.run(cross_entropy, feed_dict={X: X_train, t: Y_train})
            W_val = sess.run(W)
            b_val = sess.run(b)
            print('Step: {},   Loss: {} W_val: {} b_val: {}'.format(step, loss_val, W_val, b_val))

        sess.run(train_step, feed_dict={X: X_train, t: Y_train})

    correct_prediction = sess.run(tf.cast(tf.greater(y, 0.5), tf.int32), feed_dict={X: X_train, t: Y_train})
 print ('Évaluation des données d'entraînement:', metrics.accuracy_score (Y_train, correct_prediction))

    test_data = tf.placeholder(dtype=tf.float32, shape=[None, 4])
    test_prediction = tf.nn.sigmoid(tf.matmul(test_data, W_val) + b_val)
    test_correct_prediction = sess.run(tf.cast(tf.greater(test_prediction, 0.5), tf.int32), feed_dict={test_data: X_test})

 print ('Évaluation des données de test:', metrics.accuracy_score (Y_test, test_correct_prediction))

Step: 9990, Loss: 0.10178631544113159 W_val: [[ 0.25520977] [-3.2158086 ] [ 3.3751483 ] [ 3.4625392 ]] b_val: [[-3.2248065]] Évaluation des données d'entraînement: 1.0 Évaluation des données de test: 1.0

tf.greater(y, 0.5)Par 0.Vrai pour y supérieur à 5 et 0.Pour y inférieur à 5, une valeur booléenne avec False attribué est renvoyée.

Iltf.castConvertit True en 1 et False en 0 en attribuant à.

C'est la fin de l'implémentation par tensorflow.

#À la fin Merci d'être resté avec nous jusqu'à présent.

Je vous remercie pour votre travail acharné.