tensorflow로 예측하기

Question

저는 텐서 흐름과이 모든 분야에서 초보자입니다.하지만 CS231n 클래스의 Andrej Karpathy에 대한 강의를 모두 보았으므로 코드를 이해하고 있습니다.

그래서이 코드 (안 내)입니다 : https://github.com/nfmcclure/tensorflow_cookbook/tree/master/09_Recurrent_Neural_Networks/02_Implementing_RNN_for_Spam_Prediction

# Implementing an RNN in TensorFlow 
# ---------------------------------- 
# 
# We implement an RNN in TensorFlow to predict spam/ham from texts 
# 
# https://github.com/nfmcclure/tensorflow_cookbook/blob/master/09_Recurrent_Neural_Networks/02_Implementing_RNN_for_Spam_Prediction/02_implementing_rnn.py 

import os 
import re 
import io 
import glob 
import requests 
import numpy as np 
import matplotlib.pyplot as plt 
import tensorflow as tf 
from zipfile import ZipFile 
from tensorflow.python.framework import ops 

ops.reset_default_graph() 

# Start a graph 
sess = tf.Session() 

# Set RNN parameters 
epochs = 20 
batch_size = 250 
max_sequence_length = 25 
rnn_size = 10 
embedding_size = 50 
min_word_frequency = 10 
learning_rate = 0.0005 
dropout_keep_prob = tf.placeholder(tf.float32) 

# Download or open data 
data_dir = 'temp' 
data_file = 'text_data.txt' 
if not os.path.exists(data_dir): 
    os.makedirs(data_dir) 

if not os.path.isfile(os.path.join(data_dir, data_file)): 
    zip_url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00228/smsspamcollection.zip' 
    r = requests.get(zip_url) 
    z = ZipFile(io.BytesIO(r.content)) 
    file = z.read('SMSSpamCollection') 
    # Format Data 
    text_data = file.decode() 
    text_data = text_data.encode('ascii', errors='ignore') 
    text_data = text_data.decode().split('\n') 

    # Save data to text file 
    with open(os.path.join(data_dir, data_file), 'w') as file_conn: 
     for text in text_data: 
      file_conn.write("{}\n".format(text)) 
else: 
    # Open data from text file 
    text_data = [] 
    with open(os.path.join(data_dir, data_file), 'r') as file_conn: 
     for row in file_conn: 
      text_data.append(row) 
    text_data = text_data[:-1] 

text_data = [x.split('\t') for x in text_data if len(x) >= 1] 
text_data = [x for x in text_data if len(x) > 1] 
print([list(x) for x in zip(*text_data)]) 
[text_data_target, text_data_train] = [list(x) for x in zip(*text_data)] 


# Create a text cleaning function 
def clean_text(text_string): 
    text_string = re.sub(r'([^\s\w]|_|[0-9])+', '', text_string) 
    text_string = " ".join(text_string.split()) 
    text_string = text_string.lower() 
    return (text_string) 


# Clean texts 
text_data_train = [clean_text(x) for x in text_data_train] 

# Change texts into numeric vectors 
vocab_processor = tf.contrib.learn.preprocessing.VocabularyProcessor(max_sequence_length, 
                    min_frequency=min_word_frequency) 
text_processed = np.array(list(vocab_processor.fit_transform(text_data_train))) 

# Shuffle and split data 
text_processed = np.array(text_processed) 
text_data_target = np.array([1 if x == 'ham' else 0 for x in text_data_target]) 
shuffled_ix = np.random.permutation(np.arange(len(text_data_target))) 
x_shuffled = text_processed[shuffled_ix] 
y_shuffled = text_data_target[shuffled_ix] 

# Split train/test set 
ix_cutoff = int(len(y_shuffled) * 0.80) 
x_train, x_test = x_shuffled[:ix_cutoff], x_shuffled[ix_cutoff:] 
y_train, y_test = y_shuffled[:ix_cutoff], y_shuffled[ix_cutoff:] 
vocab_size = len(vocab_processor.vocabulary_) 
print("Vocabulary Size: {:d}".format(vocab_size)) 
print("80-20 Train Test split: {:d} -- {:d}".format(len(y_train), len(y_test))) 

# Create placeholders 
x_data = tf.placeholder(tf.int32, [None, max_sequence_length]) 
y_output = tf.placeholder(tf.int32, [None]) 

# Create embedding 
embedding_mat = tf.Variable(tf.random_uniform([vocab_size, embedding_size], -1.0, 1.0)) 
embedding_output = tf.nn.embedding_lookup(embedding_mat, x_data) 
# embedding_output_expanded = tf.expand_dims(embedding_output, -1) 

# Define the RNN cell 
# tensorflow change >= 1.0, rnn is put into tensorflow.contrib directory. Prior version not test. 
if tf.__version__[0] >= '1': 
    cell = tf.contrib.rnn.BasicRNNCell(num_units=rnn_size) 
else: 
    cell = tf.nn.rnn_cell.BasicRNNCell(num_units=rnn_size) 

output, state = tf.nn.dynamic_rnn(cell, embedding_output, dtype=tf.float32) 
output = tf.nn.dropout(output, dropout_keep_prob) 

# Get output of RNN sequence 
output = tf.transpose(output, [1, 0, 2]) 
last = tf.gather(output, int(output.get_shape()[0]) - 1) 

weight = tf.Variable(tf.truncated_normal([rnn_size, 2], stddev=0.1)) 
bias = tf.Variable(tf.constant(0.1, shape=[2])) 
logits_out = tf.matmul(last, weight) + bias 

# Loss function 
losses = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits_out, 
                 labels=y_output) # logits=float32, labels=int32 
loss = tf.reduce_mean(losses) 

accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.argmax(logits_out, 1), tf.cast(y_output, tf.int64)), tf.float32)) 

optimizer = tf.train.RMSPropOptimizer(learning_rate) 
train_step = optimizer.minimize(loss) 

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

train_loss = [] 
test_loss = [] 
train_accuracy = [] 
test_accuracy = [] 
# Start training 
for epoch in range(epochs): 

    # Shuffle training data 
    shuffled_ix = np.random.permutation(np.arange(len(x_train))) 
    x_train = x_train[shuffled_ix] 
    y_train = y_train[shuffled_ix] 
    num_batches = int(len(x_train)/batch_size) + 1 
    # TO DO CALCULATE GENERATIONS ExACTLY 
    for i in range(num_batches): 
     # Select train data 
     min_ix = i * batch_size 
     max_ix = np.min([len(x_train), ((i + 1) * batch_size)]) 
     x_train_batch = x_train[min_ix:max_ix] 
     y_train_batch = y_train[min_ix:max_ix] 

     # Run train step 
     train_dict = {x_data: x_train_batch, y_output: y_train_batch, dropout_keep_prob: 0.5} 
     sess.run(train_step, feed_dict=train_dict) 

    # Run loss and accuracy for training 
    temp_train_loss, temp_train_acc = sess.run([loss, accuracy], feed_dict=train_dict) 
    train_loss.append(temp_train_loss) 
    train_accuracy.append(temp_train_acc) 

    # Run Eval Step 
    test_dict = {x_data: x_test, y_output: y_test, dropout_keep_prob: 1.0} 
    temp_test_loss, temp_test_acc = sess.run([loss, accuracy], feed_dict=test_dict) 
    test_loss.append(temp_test_loss) 
    test_accuracy.append(temp_test_acc) 
    print('Epoch: {}, Test Loss: {:.2}, Test Acc: {:.2}'.format(epoch + 1, temp_test_loss, temp_test_acc)) 


# Plot loss over time 
epoch_seq = np.arange(1, epochs + 1) 
plt.plot(epoch_seq, train_loss, 'k--', label='Train Set') 
plt.plot(epoch_seq, test_loss, 'r-', label='Test Set') 
plt.title('Softmax Loss') 
plt.xlabel('Epochs') 
plt.ylabel('Softmax Loss') 
plt.legend(loc='upper left') 
plt.show() 

# Plot accuracy over time 
plt.plot(epoch_seq, train_accuracy, 'k--', label='Train Set') 
plt.plot(epoch_seq, test_accuracy, 'r-', label='Test Set') 
plt.title('Test Accuracy') 
plt.xlabel('Epochs') 
plt.ylabel('Accuracy') 
plt.legend(loc='upper left') 
plt.show() 

def findFiles(path): return glob.glob(path) 

pred_array = "words" 

pred_num = np.array(list(vocab_processor.fit_transform(pred_array))) 
print(pred_num) 

pred_output = tf.placeholder(tf.float32,[1,len(pred_array),max_sequence_length]) 

feed_dict = {pred_output: [pred_num]} 
classification = sess.run(losses, feed_dict) 
print(classification) 

그것은 RNN 스팸 분류, 그리고 그것은 (큰 일 나는를 만들려고 해요 내가 마지막에 쓴 부분에 대해 동의 것 예측). 난 그냥이에 대한 예측 함수를 작성하는 방법을 이해하려는거야

, 그처럼 보이는 뭔가 :

def predict(text): # text is a string (my mail) 
    # Doing prediction stuff 
    return (top result) # ham or spam 

마지막 몇 줄 내 마지막 시도는 나에게 다음과 같은 오류를주고있다 : tensorflow.python.framework.errors_impl.InvalidArgumentError: You must feed a value for placeholder tensor 'Placeholder' with dtype float [[Node: Placeholder = Placeholder[dtype=DT_FLOAT, shape=<unknown>, _device="/job:localhost/replica:0/task:0/cpu:0"]()]]

또한 나는 Making predictions with a TensorFlow model를 사용하여 뭔가를 시도하고 난 그냥 초보자 폭발물 해요 때문에 나는 또한 https://www.tensorflow.org/serving/serving_basic 내가 실패 해봤 모든 것을 ...

읽기 anations는 환영하지만, 코드 작성법을 알 수 없으므로 코드 응답도 올릴 수 있습니다.

(파이썬 3.6 btw)

고마워요! 그들의 train_dict 및 test_dict, 당신은 그들이 그래프에서 placeholder로 정의 텐서의 각 값을 공급 것을 볼 수 설정 방법을 구체적

Answer 1

원래 코드는 교육 및 테스트 단계를 수행하는 방법에 대해 살펴 경우. 기본적으로 자리 표시자는 네트워크에 요청하는 계산에 사용하려면 일부 값을 제공해야합니다. 네트워크에서 예측을 찾고 있기 때문에 예상 출력을 제공 할 필요는 없지만 입력 데이터에 x_data과 dropout_keep_prob의 값을 입력해야합니다. 예상치는 dropout_keep_prob=1.0이어야합니다.

예측도 필요하며 네트워크가 손실되지는 않습니다. 손실은 기본적으로 네트워크 출력이 예상 한 것과 얼마나 떨어져 있는지를 측정하지만, 새로운 데이터를 예측하기 위해 네트워크가 말하고있는 것을보고 싶습니다. 직접 logits_out op를 사용하여이 작업을 수행 할 수 있습니다. 또는 사용자의 로그인을 클래스에 대한 확률 분포로 변환하는 op를 추가 할 수 있습니다. 어느 쪽이든 분포를 보면 네트워크가 데이터를 각 범주에 속한다고 생각할 가능성이 있는지 또는이 벡터의 최대 값을 사용하여 네트워크의 가장 좋은 추측을 산출 할 수 있는지 알 수 있습니다.

prediction = tf.nn.softmax(logits_out) 
feed_dict = {x_data: your_input_data, dropout_keep_prob: 1.0} 
pred = sess.run(prediction, feed_dict) 
best_guess = np.argmax(pred) # highest-rated class