1
Ich habe ein neuronales Netzwerk erstellt und trainiert, aber ich möchte in der Lage sein, Testpunkte einzugeben und seine Ergebnisse zu sehen (anstatt eine Eval-Funktion zu verwenden).Wie mit trainierten Tensorflow Modell
Das Modell läuft gut und die Kosten reduzieren jede Epoche, aber ich möchte nur eine Zeile am Ende hinzufügen, um einige Eingabekoordinaten zu übergeben und mir die vorhergesagten transformierten Koordinaten mitzuteilen.
import tensorflow as tf
import numpy as np
def coordinate_transform(size, angle):
input = np.random.rand(size, 2)
output = np.zeros((size, 2))
noise = 0.05*(np.add(np.random.rand(size) * 2, -1))
theta = np.add(np.add(np.arctan(input[:,1]/input[:,0]) , angle) , noise)
radii = np.sqrt(np.square(input[:,0]) + np.square(input[:,1]))
output[:,0] = np.multiply(radii, np.cos(theta))
output[:,1] = np.multiply(radii, np.sin(theta))
return input, output
#Data
input, output = coordinate_transform(2000, np.pi/2)
train_in = input[:1000]
train_out = output[:1000]
test_in = input[1000:]
test_out = output[1000:]
# Parameters
learning_rate = 0.001
training_epochs = 15
batch_size = 1
display_step = 1
# Network Parameters
n_hidden_1 = 100 # 1st layer number of features
n_input = 2 # [x,y]
n_classes = 2 # output x,y coords
# tf Graph input
x = tf.placeholder("float", [1,n_input])
y = tf.placeholder("float", [1, n_input])
# Create model
def multilayer_perceptron(x, weights, biases):
# Hidden layer with RELU activation
layer_1 = tf.add(tf.matmul(x, weights['h1']), biases['b1'])
layer_1 = tf.nn.relu(layer_1)
# Output layer with linear activation
out_layer = tf.matmul(layer_1, weights['out']) + biases['out']
return out_layer
# Store layers weight & bias
weights = {
'h1': tf.Variable(tf.random_normal([n_input, n_hidden_1])),
'out': tf.Variable(tf.random_normal([n_hidden_1, n_classes]))
}
biases = {
'b1': tf.Variable(tf.random_normal([n_hidden_1])),
'out': tf.Variable(tf.random_normal([n_classes]))
}
# Construct model
pred = multilayer_perceptron(x, weights, biases)
# Define loss and optimizer
#cost = tf.losses.mean_squared_error(0, (tf.slice(pred, 0, 1) - x)**2 + (tf.slice(pred, 1, 1) - y)**2)
cost = tf.losses.mean_squared_error(y, pred)
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
optimizer = optimizer.minimize(cost)
# Initializing the variables
#init = tf.global_variables_initializer()
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 = 1000#int(len(train_in)/batch_size)
# Loop over all batches
for i in range(total_batch):
batch_x = train_in[i].reshape((1,2))
batch_y = train_out[i].reshape((1,2))
#print(batch_x.shape)
#print(batch_y.shape)
#print(batch_y, batch_x)
# Run optimization op (backprop) and cost op (to get loss value)
_, c = sess.run([optimizer, cost], feed_dict={x: batch_x,
y: batch_y})
# Compute average loss
avg_cost += c/total_batch
# Display logs per epoch step
if epoch % display_step == 0:
print ("Epoch:", '%04d' % (epoch+1), "cost=", \
"{:.9f}".format(avg_cost))
print("Optimization Finished!")
# Test model
correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
# Calculate accuracy
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
#Make predictions
Danke! Genau das habe ich gesucht. –