Come testare il modello tutorial di tensorflow cifar10 cnn

Question

Sono relativamente nuovo all'apprendimento automatico e attualmente non ho quasi esperienza nello sviluppo.

Quindi la mia domanda è: dopo l'allenamento e la valutazione del set di dati cifar10 dal tensorflow tutorial Mi chiedevo come si potrebbe provare con le immagini di esempio?

Potevo addestrare e valutare Imagenet tutorial from the caffe machine-learning framework ed era relativamente facile utilizzare il modello addestrato su applicazioni personalizzate utilizzando l'API python.

Qualsiasi aiuto sarebbe molto apprezzato!

Answer 1

Questo non è al 100% la risposta alla domanda, ma è un modo simile di risolverlo, basato su un esempio di addestramento di MNIST NN suggerito nei commenti alla domanda.

Basato sul tutorial MNIST di TensorFlow begginer e grazie a this tutorial, questo è un modo di allenamento e utilizzo della rete neurale con dati personalizzati.

Si prega di notare che simile dovrebbe essere fatto per tutorial come il CIFAR10, come @ Yaroslav Bulatov menzionato nei commenti.

import input_data 
import datetime 
import numpy as np 
import tensorflow as tf 
import cv2 
from matplotlib import pyplot as plt 
import matplotlib.image as mpimg 
from random import randint 


mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) 

x = tf.placeholder("float", [None, 784]) 

W = tf.Variable(tf.zeros([784,10])) 
b = tf.Variable(tf.zeros([10])) 

y = tf.nn.softmax(tf.matmul(x,W) + b) 
y_ = tf.placeholder("float", [None,10]) 

cross_entropy = -tf.reduce_sum(y_*tf.log(y)) 

train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy) 

init = tf.initialize_all_variables() 

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

#Train our model 
iter = 1000 
for i in range(iter): 
    batch_xs, batch_ys = mnist.train.next_batch(100) 
    sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys}) 

#Evaluationg our model: 
correct_prediction=tf.equal(tf.argmax(y,1), tf.argmax(y_,1)) 

accuracy=tf.reduce_mean(tf.cast(correct_prediction,"float")) 
print "Accuracy: ", sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}) 

#1: Using our model to classify a random MNIST image from the original test set: 
num = randint(0, mnist.test.images.shape[0]) 
img = mnist.test.images[num] 

classification = sess.run(tf.argmax(y, 1), feed_dict={x: [img]}) 
''' 
#Uncomment this part if you want to plot the classified image. 
plt.imshow(img.reshape(28, 28), cmap=plt.cm.binary) 
plt.show() 
''' 
print 'Neural Network predicted', classification[0] 
print 'Real label is:', np.argmax(mnist.test.labels[num]) 


#2: Using our model to classify MNIST digit from a custom image: 

# create an an array where we can store 1 picture 
images = np.zeros((1,784)) 
# and the correct values 
correct_vals = np.zeros((1,10)) 

# read the image 
gray = cv2.imread("my_digit.png", 0) #0=cv2.CV_LOAD_IMAGE_GRAYSCALE #must be .png! 

# rescale it 
gray = cv2.resize(255-gray, (28, 28)) 

# save the processed images 
cv2.imwrite("my_grayscale_digit.png", gray) 
""" 
all images in the training set have an range from 0-1 
and not from 0-255 so we divide our flatten images 
(a one dimensional vector with our 784 pixels) 
to use the same 0-1 based range 
""" 
flatten = gray.flatten()/255.0 
""" 
we need to store the flatten image and generate 
the correct_vals array 
correct_val for a digit (9) would be 
[0,0,0,0,0,0,0,0,0,1] 
""" 
images[0] = flatten 


my_classification = sess.run(tf.argmax(y, 1), feed_dict={x: [images[0]]}) 

""" 
we want to run the prediction and the accuracy function 
using our generated arrays (images and correct_vals) 
""" 
print 'Neural Network predicted', my_classification[0], "for your digit" 

Per ulteriori immagine condizionata (cifre dovrebbero essere completamente al buio in uno sfondo bianco) e una migliore formazione NN (accuratezza> 91%) si prega di controllare il tutorial avanzato MNIST dal tensorflow o 2 ° tutorial che ho citato.

Answer 2

Si consiglia di dare un'occhiata allo basic MNIST tutorial sul sito Web TensorFlow. Sembra che tu abbia definito alcune funzioni che generano il tipo di output desiderato, quindi esegui la sessione, passandole questa funzione di valutazione (correct_prediction di seguito) e un dizionario contenente gli argomenti necessari (x e y_ di seguito).

Se avete definito e addestrato alcuni di rete che richiede un input x, genera una risposta y, sulla base di input, e sai che il tuo risposte attese per il test impostato y_, si può essere in grado di stampare ogni risposta alla vostra test set con qualcosa di simile:

correct_prediction = tf.equal(y, y_) % Check whether your prediction is correct 
print(sess.run(correct_prediction, feed_dict={x: test_images, y_: test_labels})) 

Questa è solo una modifica di ciò che viene fatto nel tutorial, in cui invece di cercare di stampare ogni risposta, determinano la percentuale di risposte corrette. Si noti inoltre che il tutorial utilizza vettori one-hot per la previsione e il valore effettivo y_, quindi per restituire il numero associato, devono trovare quale indice di questi vettori è uguale a uno con tf.argmax(y, 1).

Modifica

In generale, se si definisce qualcosa nel grafico, è possibile uscita in un secondo momento, quando si esegue il grafico. Diciamo che definire qualcosa che determina il risultato della funzione SoftMax sulle logit uscita come:

graph = tf.Graph() 
with graph.as_default(): 
    ... 
    prediction = tf.nn.softmax(logits) 
    ... 

allora si può uscita questo in fase di esecuzione con:

with tf.Session(graph=graph) as sess: 
    ... 
    feed_dict = { ... } # define your feed dictionary 
    pred = sess.run([prediction], feed_dict=feed_dict) 
    # do stuff with your prediction vector 

Answer 3

L'esempio seguente non è per il tutorial mnist, ma un semplice esempio XOR. Nota i metodi train() e test(). Tutto ciò che dichiariamo & a livello globale sono i pesi, i bias e le sessioni. Nel metodo di prova ridefiniamo la forma dell'input e riutilizziamo gli stessi pesi (e sessione) di & che abbiamo perfezionato in allenamento.

import tensorflow as tf 

#parameters for the net 
w1 = tf.Variable(tf.random_uniform(shape=[2,2], minval=-1, maxval=1, name='weights1')) 
w2 = tf.Variable(tf.random_uniform(shape=[2,1], minval=-1, maxval=1, name='weights2')) 

#biases 
b1 = tf.Variable(tf.zeros([2]), name='bias1') 
b2 = tf.Variable(tf.zeros([1]), name='bias2') 

#tensorflow session 
sess = tf.Session() 


def train(): 

    #placeholders for the traning inputs (4 inputs with 2 features each) and outputs (4 outputs which have a value of 0 or 1) 
    x = tf.placeholder(tf.float32, [4, 2], name='x-inputs') 
    y = tf.placeholder(tf.float32, [4, 1], name='y-inputs') 

    #set up the model calculations 
    temp = tf.sigmoid(tf.matmul(x, w1) + b1) 
    output = tf.sigmoid(tf.matmul(temp, w2) + b2) 

    #cost function is avg error over training samples 
    cost = tf.reduce_mean(((y * tf.log(output)) + ((1 - y) * tf.log(1.0 - output))) * -1) 

    #training step is gradient descent 
    train_step = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(cost) 

    #declare training data 
    training_x = [[0,1], [0,0], [1,0], [1,1]] 
    training_y = [[1], [0], [1], [0]] 

    #init session 
    init = tf.initialize_all_variables() 
    sess.run(init) 

    #training 
    for i in range(100000): 
     sess.run(train_step, feed_dict={x:training_x, y:training_y}) 

     if i % 1000 == 0: 
      print (i, sess.run(cost, feed_dict={x:training_x, y:training_y})) 

    print '\ntraining done\n' 


def test(inputs): 
    #redefine the shape of the input to a single unit with 2 features 
    xtest = tf.placeholder(tf.float32, [1, 2], name='x-inputs') 

    #redefine the model in terms of that new input shape 
    temp = tf.sigmoid(tf.matmul(xtest, w1) + b1) 
    output = tf.sigmoid(tf.matmul(temp, w2) + b2) 

    print (inputs, sess.run(output, feed_dict={xtest:[inputs]})[0, 0] >= 0.5) 


train() 

test([0,1]) 
test([0,0]) 
test([1,1]) 
test([1,0])