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


Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow