TensorFlow - Perceptron a strato singolo

Per comprendere il perceptron a strato singolo, è importante comprendere le reti neurali artificiali (ANN). Le reti neurali artificiali sono il sistema di elaborazione delle informazioni il cui meccanismo si ispira alla funzionalità dei circuiti neurali biologici. Una rete neurale artificiale possiede molte unità di elaborazione collegate tra loro. Di seguito è riportata la rappresentazione schematica della rete neurale artificiale:

Il diagramma mostra che le unità nascoste comunicano con il livello esterno. Mentre le unità di input e output comunicano solo attraverso lo strato nascosto della rete.

Il modello di connessione con i nodi, il numero totale di livelli e il livello di nodi tra input e output con il numero di neuroni per livello definiscono l'architettura di una rete neurale.

Esistono due tipi di architettura. Questi tipi si concentrano sulla funzionalità delle reti neurali artificiali come segue:

  • Perceptron a strato singolo
  • Perceptron multistrato

Perceptron a strato singolo

Il perceptron a strato singolo è il primo modello neurale proposto creato. Il contenuto della memoria locale del neurone è costituito da un vettore di pesi. Il calcolo di un perceptron a singolo strato viene eseguito sul calcolo della somma del vettore di input ciascuno con il valore moltiplicato per l'elemento corrispondente del vettore dei pesi. Il valore visualizzato nell'uscita sarà l'ingresso di una funzione di attivazione.

Concentriamoci sull'implementazione del perceptron a strato singolo per un problema di classificazione delle immagini utilizzando TensorFlow. Il miglior esempio per illustrare il perceptron a strato singolo è attraverso la rappresentazione di "Regressione logistica".

Consideriamo ora i seguenti passaggi di base della regressione logistica dell'addestramento:

  • I pesi vengono inizializzati con valori casuali all'inizio dell'addestramento.

  • Per ogni elemento del training set, l'errore viene calcolato con la differenza tra l'output desiderato e l'output effettivo. L'errore calcolato viene utilizzato per regolare i pesi.

  • Il processo viene ripetuto fino a quando l'errore commesso sull'intero training set non è inferiore alla soglia specificata, fino al raggiungimento del numero massimo di iterazioni.

Di seguito è indicato il codice completo per la valutazione della regressione logistica:

# Import MINST data 
from tensorflow.examples.tutorials.mnist import input_data 
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True) 

import tensorflow as tf 
import matplotlib.pyplot as plt 

# Parameters 
learning_rate = 0.01 
training_epochs = 25 
batch_size = 100 
display_step = 1 

# tf Graph Input 
x = tf.placeholder("float", [None, 784]) # mnist data image of shape 28*28 = 784 
y = tf.placeholder("float", [None, 10]) # 0-9 digits recognition => 10 classes 

# Create model 
# Set model weights 
W = tf.Variable(tf.zeros([784, 10])) 
b = tf.Variable(tf.zeros([10])) 

# Construct model 
activation = tf.nn.softmax(tf.matmul(x, W) + b) # Softmax 

# Minimize error using cross entropy 
cross_entropy = y*tf.log(activation) 
cost = tf.reduce_mean\ (-tf.reduce_sum\ (cross_entropy,reduction_indices = 1)) 

optimizer = tf.train.\ GradientDescentOptimizer(learning_rate).minimize(cost) 

#Plot settings 
avg_set = [] 
epoch_set = [] 

# Initializing the variables init = tf.initialize_all_variables()
# Launch the graph 
with tf.Session() as sess:
   sess.run(init)
   
   # Training cycle
   for epoch in range(training_epochs):
      avg_cost = 0.
      total_batch = int(mnist.train.num_examples/batch_size)
      
      # Loop over all batches
      for i in range(total_batch):
         batch_xs, batch_ys = \ mnist.train.next_batch(batch_size)
         # Fit training using batch data sess.run(optimizer, \ feed_dict = {
            x: batch_xs, y: batch_ys}) 
         # Compute average loss avg_cost += sess.run(cost, \ feed_dict = {
            x: batch_xs, \ y: batch_ys})/total_batch
      # Display logs per epoch step
      if epoch % display_step == 0:
         print ("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost))
            avg_set.append(avg_cost) epoch_set.append(epoch+1)
   print ("Training phase finished")
    
   plt.plot(epoch_set,avg_set, 'o', label = 'Logistic Regression Training phase') 
   plt.ylabel('cost') 
   plt.xlabel('epoch') 
   plt.legend() 
   plt.show() 
    
   # Test model 
   correct_prediction = tf.equal(tf.argmax(activation, 1), tf.argmax(y, 1)) 
   
   # Calculate accuracy 
   accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) print 
      ("Model accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels}))

Produzione

Il codice precedente genera il seguente output:

La regressione logistica è considerata un'analisi predittiva. La regressione logistica viene utilizzata per descrivere i dati e per spiegare la relazione tra una variabile binaria dipendente e una o più variabili nominali o indipendenti.