Ricerca…


introduzione

Un modello ampiamente utilizzato nelle statistiche tradizionali è il modello di regressione lineare. In questo articolo, l'obiettivo è seguire l'implementazione passo-passo di questo tipo di modelli. Rappresenteremo una semplice struttura di regressione lineare.

Per il nostro studio, analizzeremo l'età dei bambini sull'asse x e l'altezza dei bambini sull'asse y . Cercheremo di prevedere l'altezza dei bambini, usando la loro età, applicando una semplice regressione lineare. [In TF trovare i migliori W eb]

Parametri

Parametro Descrizione
train_X array np con dimensione x di informazioni
train_Y array np con dimensione y di informazione

Osservazioni

Ho usato la sintassi TensorBoard per tracciare il comportamento di alcune parti del modello, dei costi, del treno e degli elementi di attivazione.

with tf.name_scope("") as scope:

Le importazioni utilizzate:

import numpy as np
import tensorflow as tf

Tipo di applicazione e lingua utilizzata:

Ho utilizzato un tipo di app di implementazione console tradizionale, sviluppato in Python, per rappresentare l'esempio.


Versione di TensorFlow utilizzata:

1.0.1


Esempio / riferimento accademico concettuale estratto da qui :

Semplice struttura del codice della funzione di regressione

Definizione della funzione:

def run_training(train_X, train_Y):

Inputs variables:

X = tf.placeholder(tf.float32, [m, n])
Y = tf.placeholder(tf.float32, [m, 1])

Rappresentazione del peso e della distorsione

W = tf.Variable(tf.zeros([n, 1], dtype=np.float32), name="weight")
b = tf.Variable(tf.zeros([1], dtype=np.float32), name="bias")

Modello lineare:

with tf.name_scope("linear_Wx_b") as scope:
    activation = tf.add(tf.matmul(X, W), b)

Costo:

with tf.name_scope("cost") as scope:
    cost = tf.reduce_sum(tf.square(activation - Y)) / (2 * m)
    tf.summary.scalar("cost", cost)

Formazione:

with tf.name_scope("train") as scope:
    optimizer = tf.train.GradientDescentOptimizer(0.07).minimize(cost)

Sessione TensorFlow:

with tf.Session() as sess:
    merged = tf.summary.merge_all()
    writer = tf.summary.FileWriter(log_file, sess.graph)

Nota: uniti e scrittore fanno parte della strategia di TensorBoard per tracciare il comportamento del modello.


    init = tf.global_variables_initializer()
    sess.run(init)

Ripetere 1.5k volte il ciclo di allenamento:

    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)

Stampa costo di formazione:

    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'

Predizione concreta basata sul modello addestrato:

    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)

Nota: ricordare le dipendenze delle funzioni di revisione. read_data , feature_normalize e run_training

Routine di normalizzazione

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)

Leggi la routine dei dati

def read_data():
    global m, n

    m = 50
    n = 1

    train_X = np.array(

Dati interni per l'array

    ).astype('float32')

    train_Y = np.array(

Dati interni per l'array

    ).astype('float32')

    return train_X, train_Y


Modified text is an extract of the original Stack Overflow Documentation
Autorizzato sotto CC BY-SA 3.0
Non affiliato con Stack Overflow