tensorflow
Structure de régression linéaire simple dans TensorFlow avec Python
Recherche…
Introduction
Un modèle largement utilisé dans les statistiques traditionnelles est le modèle de régression linéaire. Dans cet article, l'objectif est de suivre la mise en œuvre progressive de ce type de modèles. Nous allons représenter une structure de régression linéaire simple.
Pour notre étude, nous analyserons l'âge des enfants sur l'axe des x et la taille des enfants sur l'axe des y . Nous allons essayer de prédire la taille des enfants, en utilisant leur âge, en appliquant une régression linéaire simple. [Dans TF trouver le meilleur W et b]
Paramètres
| Paramètre | La description |
|---|---|
| train_X | np array avec x dimension d'information |
| train_Y | np tableau avec la dimension y de l'information |
Remarques
J'ai utilisé TintorBoard sintaxis pour suivre le comportement de certaines parties du modèle, du coût, du train et des éléments d'activation.
with tf.name_scope("") as scope:
Importations utilisées:
import numpy as np
import tensorflow as tf
Type d'application et langue utilisée:
J'ai utilisé un type d'application d'implémentation de console traditionnelle, développé en Python, pour représenter l'exemple.
Version de TensorFlow utilisée:
1.0.1
Exemple académique conceptuel / référence extrait d' ici :
Structure de code de fonction de régression simple
Définition de la fonction:
def run_training(train_X, train_Y):
Variables d'entrée:
X = tf.placeholder(tf.float32, [m, n])
Y = tf.placeholder(tf.float32, [m, 1])
Représentation du poids et du biais
W = tf.Variable(tf.zeros([n, 1], dtype=np.float32), name="weight")
b = tf.Variable(tf.zeros([1], dtype=np.float32), name="bias")
Modèle linéaire:
with tf.name_scope("linear_Wx_b") as scope:
activation = tf.add(tf.matmul(X, W), b)
Coût:
with tf.name_scope("cost") as scope:
cost = tf.reduce_sum(tf.square(activation - Y)) / (2 * m)
tf.summary.scalar("cost", cost)
Entraînement:
with tf.name_scope("train") as scope:
optimizer = tf.train.GradientDescentOptimizer(0.07).minimize(cost)
Session TensorFlow:
with tf.Session() as sess:
merged = tf.summary.merge_all()
writer = tf.summary.FileWriter(log_file, sess.graph)
Note: fusionné et écrivain font partie de la stratégie de TensorBoard pour suivre le comportement du modèle.
init = tf.global_variables_initializer()
sess.run(init)
Répéter 1,5k fois la boucle d'entraînement:
for step in range(1500):
result, _ = sess.run([merged, optimizer], feed_dict={X: np.asarray(train_X), Y: np.asarray(train_Y)})
writer.add_summary(result, step)
Coût d'impression:
training_cost = sess.run(cost, feed_dict={X: np.asarray(train_X), Y: np.asarray(train_Y)})
print "Training Cost: ", training_cost, "W=", sess.run(W), "b=", sess.run(b), '\n'
Prédiction concrète basée sur le modèle formé:
print "Prediction for 3.5 years"
predict_X = np.array([3.5], dtype=np.float32).reshape([1, 1])
predict_X = (predict_X - mean) / std
predict_Y = tf.add(tf.matmul(predict_X, W), b)
print "Child height(Y) =", sess.run(predict_Y)
Routine principale
def main():
train_X, train_Y = read_data()
train_X = feature_normalize(train_X)
run_training(train_X, train_Y)
Remarque: rappelez les dépendances des fonctions de révision. read_data , feature_normalize et run_training
Routine de normalisation
def feature_normalize(train_X):
global mean, std
mean = np.mean(train_X, axis=0)
std = np.std(train_X, axis=0)
return np.nan_to_num((train_X - mean) / std)
Lire la routine de données
def read_data():
global m, n
m = 50
n = 1
train_X = np.array(
Données internes pour le tableau
).astype('float32')
train_Y = np.array(
Données internes pour le tableau
).astype('float32')
return train_X, train_Y
