def main(): model = create_model() print 'Loading data' x_test, y_test = get_test_data() x_train, y_train = get_train_data() x_validation, y_validation = get_validation_data() print 'Starting training' try: model.fit(x_train, y_train, validation_data=(x_validation, y_validation), batch_size=32, epochs=30, verbose=1) except KeyboardInterrupt: print 'Training Interrupted' print 'Evaluating' loss_and_accuracy = model.evaluate(x_test, y_test, batch_size=32) print "Loss: ", loss_and_accuracy[0] print "Accuracy: ", loss_and_accuracy[1] print 'Saving model' save_model(model, "../models/", loss_and_accuracy[1])
def main(_): # Create the model x = tf.placeholder(tf.float32, [None, IMG_SIZE]) W = tf.Variable(tf.zeros([IMG_SIZE, 10])) b = tf.Variable(tf.zeros([10])) h = tf.matmul(x, W) + b y = tf.placeholder(tf.float32, [None, 10]) cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=h)) train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy) sess = tf.InteractiveSession() tf.global_variables_initializer().run() # Train for _ in range(1000): batch_xs, batch_ys = data.get_train_data() rtn = sess.run(train_step, feed_dict={x: batch_xs, y: batch_ys}) # Test trained model correct_prediction = tf.equal(tf.argmax(h, 1), tf.argmax(y, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) test_xs, test_ys = data.get_test_data() print("Accuracy: ", sess.run(accuracy, feed_dict={x: test_xs, y: test_ys})) img = data.get_img(FLAGS.ask) print("The image is: ", sess.run(tf.argmax(h, 1), feed_dict={x: [img]}))
def train(): # Load training and eval data data_train_data, data_train_labels = data.get_train_data(onehot=False) train_data = np.asarray(data_train_data, dtype=np.float32) train_labels = np.asarray(data_train_labels, dtype=np.int32) data_eval_data, data_eval_labels = data.get_test_data(onehot=False) eval_data = np.asarray(data_eval_data, dtype=np.float32) eval_labels = np.asarray(data_eval_labels, dtype=np.int32) # Create the Estimator mnist_classifier = tf.estimator.Estimator(model_fn=cnn_model_fn, model_dir=FLAGS.model) # Set up logging for predictions # Log the values in the "Softmax" tensor with label "probabilities" tensors_to_log = {"probabilities": "softmax_tensor"} logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50) #debug_hook = tf_debug.LocalCLIDebugHook() # Train the model train_input_fn = tf.estimator.inputs.numpy_input_fn(x={"x": train_data}, y=train_labels, batch_size=10, num_epochs=None, shuffle=True) mnist_classifier.train(input_fn=train_input_fn, steps=FLAGS.step, hooks=[logging_hook]) # Evaluate the model and print results eval_input_fn = tf.estimator.inputs.numpy_input_fn(x={"x": eval_data}, y=eval_labels, num_epochs=1, shuffle=False) eval_results = mnist_classifier.evaluate(input_fn=eval_input_fn) print(eval_results)
test_loss = 0 with torch.no_grad(): for data, (index, target_rating) in enumerate(data_loader): output = model(data) test_loss += pow(target_rating - output[index], 2) test_loss /= len(data_loader.dataset) test_loss = math.sqrt(test_loss) print('\nTest set: Average loss: {:.4f}'.format(test_loss)) # ----------------------------------------------------------------------------- # TRAINING LOOP # ----------------------------------------------------------------------------- #model = 0 for epoch in range(1000): train_epoch(epoch + 1, model, dl.get_train_data(), optimizer, autorec_loss) # validate_epoch(model, data_loader) ''' with torch.no_grad(): for batch_idx, (target, input) in enumerate(dl.get_train_data()): #output = model(target) #print(target[0][input[0].item()-1]) print(target) print(model(target)) '''
import data_loader import options import os from tensorboardX import SummaryWriter if __name__ == '__main__': writer = SummaryWriter() opt = options.Option() net = model.Net() #net.load_state_dict(torch.load('./network_model/model.para')) net.to(torch.device(opt.device_name)) sample_data, sample_label = data_loader.get_train_data(0, 5) functions.cal_k_nearnest(sample_data) out = net(sample_data) with open('Output.off', 'w') as f: f.write('OFF\n') f.write(str(opt.pointnum) + ' 0 0\n') for i in range(opt.pointnum): f.write( str(out[0][i][0].item()) + ' ' + str(out[0][i][1].item()) + ' ' + str(out[0][i][2].item()) + '\n') with open('STD.off', 'w') as f: f.write('OFF\n') f.write(str(opt.pointnum) + ' 0 0\n') for i in range(opt.pointnum):
net.to(torch.device(opt.device_name)) optimizer = optim.Adam(net.parameters(), opt.learning_rate, betas=(0.9, 0.99)) print(net) iter = 0 for epoch in range(opt.total_epoch): print('Epoch:{}'.format(epoch)) Epoch_loss = 0 data_loader.shuffle_TrainingSet() for now in range(0, data_loader.get_TrainingSize(), opt.batch_size): sample_data, sample_label = data_loader.get_train_data( now, opt.batch_size) functions.cal_k_nearnest(sample_data) optimizer.zero_grad() out = net(sample_data) loss = net.lossfunc(out, sample_data) loss.backward() optimizer.step() Epoch_loss = Epoch_loss + loss.item() writer.add_scalar('Train/Loss', loss.item(), iter) iter = iter + 1 print('{}/{}:loss: {}'.format(now, data_loader.get_TrainingSize(), loss.item())) Epoch_loss = Epoch_loss / (data_loader.get_TrainingSize() /