def main(): mode = 'ebgan' params = { 'learning_rate': 0.005, 'z_dim': 1, 'generator': partial(linear_generator, hidden_size=10), } if mode == 'gan': params.update({ 'discriminator': partial(linear_discriminator, hidden_size=10), 'loss_builder': model.make_gan_loss }) elif mode == 'ebgan': params.update({ 'discriminator': partial(autoencoder_discriminator, hidden_size=10), 'loss_builder': partial(model.make_ebgan_loss, epsilon=0.0001) }) tf.logging._logger.setLevel(logging.INFO) data = np.random.normal(4, 0.5, 10000).astype(np.float32) data.sort() est = learn.SKCompat( learn.Estimator(model_fn=model.gan_model, model_dir='models/gan_intro/', params=params)) print_monitor = tf.train.LoggingTensorHook( ['loss_discr', 'loss_generator'], every_n_iter=100) est.fit(x=data, y=data, steps=10000, batch_size=32, monitors=[print_monitor])
def __init__(self, config): self.config = config self.model = tflearn.SKCompat( tflearn.Estimator(model_fn=self._model(), model_dir=self.config["log_dir"])) self.bias = None self.weights = None
def run_learn(pixels, label): cnn_dir = os.environ['VIRTUAL_ENV'] + "/mnist_convnet_model" mnist_dataset = mnist.load_mnist(train_dir=os.environ['VIRTUAL_ENV'] + '/MNIST-data') train_data = concat(mnist_dataset.train.images, pixels) train_labels = concat(mnist_dataset.train.labels, label) eval_data = concat(mnist_dataset.test.images, pixels) eval_labels = concat(mnist_dataset.test.labels, label) estimator = learn.Estimator(model_fn=cnn_model_fn, model_dir=cnn_dir) dataset_classifier = learn.SKCompat(estimator) tensors_to_log = {"probabilities": "softmax_tensor"} logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=500) dataset_classifier.fit(x=train_data, y=train_labels, batch_size=128, steps=5000, monitors=[logging_hook]) metrics = { "accuracy": learn.MetricSpec(metric_fn=tf.metrics.accuracy, prediction_key="classes") } eval_results = dataset_classifier.score(x=eval_data, y=eval_labels, metrics=metrics) return eval_results
def build_model(self): #建立预测模型 self.model = tflearn.SKCompat( tflearn.Estimator(model_fn=lstm_model(self.timesteps, self.rnn_layer, self.dense_layer), model_dir=self.model_dir))
def train(): train_data, train_labels, eval_data, eval_labels = load_dataset( '/Users/sunary/Downloads/train') tensors_to_log = {"probabilities": "softmax_tensor"} logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50) dogvscat_classifier = learn.SKCompat( learn.Estimator(model_fn=cnn_model_fn, model_dir='/tmp/dogvscat_convnet_model')) dogvscat_classifier.fit(x=train_data, y=train_labels, batch_size=50, steps=1000, monitors=[logging_hook]) metrics = { "accuracy": learn.MetricSpec(metric_fn=tf.metrics.accuracy, prediction_key="classes") } eval_results = dogvscat_classifier.score(x=eval_data, y=eval_labels, metrics=metrics) print(eval_results)
def train_autoencoder(imgs): autoencoder_fn = partial(linear_autoencoder_discriminator, output_dim=28, hidden_sizes=[50], encoding_dim=5) est = learn.SKCompat( model.make_autoencoder(autoencoder_fn, model_dir='models/ae_mnist', params={'learning_rate': 0.01})) save_visual = visualization.SaveVisualizationHook( 'models/ae_mnist/sample.jpg') est.fit(x=imgs, y=None, steps=3000, batch_size=32, monitors=[save_visual])
def main(): clearLogFolder() load_russian_alphabet(ALPHABET_PATH, alphabet) if USE_SUPERTYPES: splitToSupertypes(supertypes) g = Graph() g = g.Read(data_in) get_all_seqs(g) if len(all_seq) > 0: print("Parsingsequences") X, y = processSequences(all_seq, TIMESTEPS) print("Merging sequences") Xm, ym = mergeSeqs(X, y) print("Create regressor") regressor = learn.SKCompat( learn.Estimator(model_fn=lstm_model(TIMESTEPS, RNN_LAYERS, DENSE_LAYERS, optimizer="Adam"), model_dir=LOG_DIR)) # create a lstm instance and validation monitor validation_monitor = learn.monitors.ValidationMonitor( Xm['val'], ym['val'], every_n_steps=PRINT_STEPS, early_stopping_rounds=1000) print("fit regressor") regressor.fit(Xm['train'], ym['train'], monitors=[validation_monitor], batch_size=BATCH_SIZE, steps=TRAINING_STEPS) print("predicting") predicted = regressor.predict(Xm['test']) # rmse = np.sqrt(((predicted - ym['test']) ** 2).mean(axis=0)) score = mean_squared_error(predicted, ym['test']) hited = hitpoint(predicted, ym['test']) print("MSE: %f" % score) print("hitpoint:", hited)
def main(): tf.logging._logger.setLevel(logging.INFO) # Load MNIST data. mnist_data = learn.datasets.load_dataset('mnist') # Select subset of images. mnist_class = None imgs = mnist_data.train.images if mnist_class is not None: imgs = np.array([x for idx, x in enumerate(mnist_data.train.images) if mnist_data.train.labels[idx] == mnist_class]) if FLAGS.pretrain: images.train_autoencoder(imgs) # Configure. params = { 'learning_rate': 0.0005, 'z_dim': 100, 'generator': partial(images.conv_generator, output_dim=28, n_filters=64), } if FLAGS.mode == 'gan': params.update({ 'discriminator': partial(images.conv_discriminator, hidden_size=10), 'loss_builder': model.make_gan_loss }) elif FLAGS.mode == 'ebgan': pretrained = None if FLAGS.pretrain: pretrained = 'models/ae_mnist' params.update({ 'discriminator': partial(images.linear_autoencoder_discriminator, output_dim=28, hidden_sizes=[50], encoding_dim=5, pretrained=pretrained), 'loss_builder': partial(model.make_ebgan_loss, epsilon=0.05) }) est = learn.SKCompat(learn.Estimator( model_fn=model.gan_model, model_dir='models/gan_mnist/', params=params)) # Setup monitors. print_monitor = tf.train.LoggingTensorHook(['loss_discr', 'loss_generator'], every_n_iter=100) save_visual = visualization.SaveVisualizationHook('models/gan_mnist/sample.jpg') # Train for a bit. est.fit(x=imgs, y=None, steps=50000, batch_size=32, monitors=[print_monitor, save_visual])
def main(_): parser = argparse.ArgumentParser() parser.add_argument('--checkpoint_dir', type=str, default='save', help='dir to save checkpoint in') args = parser.parse_args() tf.logging.set_verbosity(tf.logging.INFO) mnist = learn.datasets.load_dataset("mnist") train_features = mnist.train.images # Returns np.array train_labels = np.asarray(mnist.train.labels, dtype=np.int32) eval_data = mnist.test.images # Returns np.array eval_labels = np.asarray(mnist.test.labels, dtype=np.int32) # Train the model runConfig = tf.contrib.learn.RunConfig(save_summary_steps=100, save_checkpoints_secs=None, save_checkpoints_steps=100, keep_checkpoint_max=5, keep_checkpoint_every_n_hours=10000) estimator = learn.Estimator(model_fn=cnn_hand_digit_classifier_model, model_dir=args.checkpoint_dir, config=runConfig) cnn_hand_digit_classifier = learn.SKCompat(estimator) tensors_to_log = {"probabilities": "softmax_tensor"} logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50) cnn_hand_digit_classifier.fit(x=train_features, y=train_labels, batch_size=500, steps=1000, monitors=[logging_hook]) metrics = { "accuracy": learn.MetricSpec(metric_fn=tf.metrics.accuracy, prediction_key="classes"), } eval_results = cnn_hand_digit_classifier.score(x=eval_data, y=eval_labels, metrics=metrics) print(eval_results)
def main(unused_argv): # Load training and eval data mnist = learn.datasets.load_dataset("mnist") print(mnist) # train_data = mnist.train.images # Returns np.array # train_labels = np.asarray(mnist.train.labels, dtype=np.int32) # eval_data = mnist.test.images # Returns np.array # eval_labels = np.asarray(mnist.test.labels, dtype=np.int32) train_labels, train_data = getImage("train-00000-of-00001") # train_data = # train_labels = # # eval_data = # eval_labels = # Create the Estimator data_classifier = learn.Estimator(model_fn=cnn_model_fn, model_dir="/tmp/convnet_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=10) # Train the model learn.SKCompat(data_classifier).fit(x=train_data, y=train_labels, batch_size=1, steps=21, monitors=[logging_hook]) # Configure the accuracy metric for evaluation metrics = { "accuracy": learn.MetricSpec(metric_fn=tf.metrics.accuracy, prediction_key="classes"), }
def main(_): tf.logging.set_verbosity(tf.logging.INFO) parser = argparse.ArgumentParser() parser.add_argument('--checkpoint_dir', type=str, default='save', help='dir to save checkpoint in') args = parser.parse_args() mnist = learn.datasets.load_dataset("mnist") eval_data = mnist.test.images # Returns np.array eval_labels = np.asarray(mnist.test.labels, dtype=np.int32) estimator = learn.Estimator( model_fn=cnn_hand_digit_classifier_model, model_dir=args.checkpoint_dir, ) cnn_hand_digit_classifier = learn.SKCompat(estimator) metrics = { "accuracy": learn.MetricSpec( metric_fn=tf.metrics.accuracy, prediction_key="classes"), } eval_results = cnn_hand_digit_classifier.score(x=eval_data, y=eval_labels, metrics=metrics) print(eval_results)
v = np.array(s.feature_lists.feature_list[column].feature[0]. float_list.value, dtype=np.float32) data = np.zeros((10, ), dtype=np.float32) data[:v.shape[0] - 1] = v[:v.shape[0] - 1] data = np.array(data).reshape([10, -1]) target = np.array(v[-1]) yield data, target if __name__ == '__main__': with tf.Session() as sess: db = "tensorflowdb" query = "select wet_bulb_temp from qclcd where wban = '14920' and time > now() - 30d group by wban" column = "column/wet_bulb_temp" regressor = tflearn.SKCompat(tflearn.Estimator(model_fn=model)) inputs = [] targets = [] for data, target in influx(db, query, column): inputs.append(data) targets.append(target) inputs = np.array(inputs) print(inputs.shape) targets = np.array(targets) print(targets.shape) regressor.fit(inputs, targets, batch_size=20, steps=20) predicted = regressor.predict(inputs) #not used in this example but used for seeing deviations rmse = np.sqrt(((predicted - targets)**2).mean(axis=0))
def _lstm_model(X, y): stacked_lstm = tf.contrib.rnn.MultiRNNCell(lstm_cells(rnn_layers), state_is_tuple=True) x_ = tf.unstack(X, axis=1, num=num_units) output, layers = tf.contrib.rnn.static_rnn(stacked_lstm, x_, dtype=dtypes.float32) output = dnn_layers(output[-1], dense_layers) prediction, loss = tflearn.models.linear_regression(output, y) train_op = tf.contrib.layers.optimize_loss( loss, tf.contrib.framework.get_global_step(), optimizer=optimizer, learning_rate=learning_rate) return prediction, loss, train_op return _lstm_model log_dir = './ops_logs/sin' time_steps = 3 rnn_layers = [{'num_units': 5}] dense_layers = None training_steps = 10000 print_steps = training_steps / 10 batch_size = 100 regressor = learn.SKCompat( learn.Estimator(model_fn=lstm_model(time_steps, rnn_layers, dense_layers), model_dir=log_dir))
y = tf.layers.dense(h, 1, tf.nn.sigmoid) loss = tf.losses.mean_squared_error(labels, y) train_op = tf.contrib.layers.optimize_loss( loss, tf.contrib.framework.get_global_step(), 0.1, "Adam") predictions = y return model_fn_lib.ModelFnOps(mode=mode, loss=loss, predictions=predictions, train_op=train_op) estimator = learn.SKCompat( learn.Estimator(model_fn=cnn_model_fn, model_dir="test")) data = np.asarray([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]], dtype=np.float32) labels = np.asarray([[[0.0]], [[1.0]], [[1.0]], [[0.0]]], dtype=np.float32) tf.logging.set_verbosity(tf.logging.INFO) estimator.fit(x=data, y=labels, steps=2000) eval_results = estimator.score(x=data, y=labels) print(eval_results) x = np.asarray([[0.0, 1.0]], dtype=np.float32) print(estimator.predict(x))
def predict(pixels): cnn_dir = os.environ['VIRTUAL_ENV'] + "/mnist_convnet_model" estimator = learn.Estimator(model_fn=cnn_model_fn, model_dir=cnn_dir) mnist_classifier = learn.SKCompat(estimator) return mnist_classifier.predict(x=pixels, batch_size=1)
list(vocab_processor.fit_transform(tmp)) global n_words #处理词汇 vocab_processor=learn.preprocessing.VocabularyProcessor(MAX_DOCUMENT_LENGTH, min_frequency=MIN_WORD_FREQUENCY) x_train=np.array(list(vocab_processor.fit_transform(train_data))) x_test=np.array(list(vocab_processor.transform(test_data))) n_words=len(vocab_processor.vocabulary_) print("Total words:%d "%n_words) cate_dic = {'technology':1, 'car':2, 'entertainment':3, 'military':4, 'sports':5} train_target=map(lambda x:cate_dic[x],train_target) test_target=map(lambda x:cate_dic[x],test_target) y_train=pandas.Series(train_target) y_test=pandas.Series(test_target) #构建模型 classifier=learn.SKCompat(learn.Estimator(model_fn=cnn_model)) classifier.fit(x_train,y_train,steps=1000) y_predicted=classifier.predict(x_test)['class'] score=metrics.accuracy_score(y_test,y_predicted) print("accuracy:{0:f}".format(score))
tf.logging.set_verbosity(tf.logging.WARN) print("Loading mnist database") # Training data (55k images) mnist = learn.datasets.load_dataset("mnist") images_training = mnist.train.images labels_training = np.asarray(mnist.train.labels, dtype=np.int32) # Test data (10k images) images_test = mnist.test.images labels_test = np.asarray(mnist.test.labels, dtype=np.int32) # You can print some of the test images using display_test_image # display_test_image(0) # Building and train our classifier feature_columns = learn.infer_real_valued_columns_from_input(images_training) tensorflow_classifier = learn.LinearClassifier(n_classes=10, feature_columns=feature_columns) classifier = learn.SKCompat(tensorflow_classifier) classifier.fit(x=images_test, y=labels_test, batch_size=100, steps=1000) # Evaluate accuracy prediction = classifier.score(images_test, labels_test) print("Accuracy: %f" % prediction['accuracy'])
from data_processing import load_csvdata import xlrd import random import math import xlrd LOG_DIR = 'C:/Users/chak282/Downloads' TIMESTEPS = 3 RNN_LAYERS = [{'num_units': 5}] DENSE_LAYERS = None TRAINING_STEPS = 10000 PRINT_STEPS = TRAINING_STEPS / 10 BATCH_SIZE = 100 regressor = learn.SKCompat( learn.Estimator(model_fn=lstm_model(TIMESTEPS, RNN_LAYERS, DENSE_LAYERS), model_dir=LOG_DIR)) workbook = xlrd.open_workbook('RNN_data.xlsx') sheet1 = workbook.sheet_by_name('RNN_data') data = np.zeros(shape=sheet1.nrows) for index1 in range(0, sheet1.nrows): data[index1] = sheet1.cell_value(index1, 1) X, y = load_csvdata(data, TIMESTEPS, seperate=False) # create a lstm instance and validation monitor validation_monitor = learn.monitors.ValidationMonitor( X['val'], y['val'], every_n_steps=PRINT_STEPS, early_stopping_rounds=1000) # print(X['train'])
Y, open( data_path + "/y_set" + str(lstm.IN_TIMESTEPS) + str(lstm.OUT_TIMESTEPS_RANGE[-1]) + ".pkl", "wb")) print("Save data successfully!") ## build the lstm model model_fn = lstm_model() config = tf.contrib.learn.RunConfig(log_step_count_steps=200, save_checkpoints_steps=VALIDATION_STEPS // 2) estimator = learn.Estimator(model_fn=model_fn, model_dir=LOG_DIR, config=config) regressor = learn.SKCompat(estimator) ## create a validation monitor validation_monitor = learn.monitors.ValidationMonitor( X['val'], Y['val'], every_n_steps=VALIDATION_STEPS) ## fit the train dataset # TRAINING_STEPS = 1 regressor.fit(X['train'], Y['train'], monitors=[validation_monitor], batch_size=BATCH_SIZE, steps=TRAINING_STEPS) #todo: test average predicted error each step #todo: add experiment, joint angles error
def main(): # Configure. vocab_size = 10 embed_dim = 10 length = 4 hidden_size = 10 params = { 'learning_rate': 0.0005, 'z_dim': 10, 'feature_processor': partial(sequence.embed_features, vocab_size=vocab_size, embed_dim=embed_dim), 'generated_postprocess': sequence.outbed_generated, 'generator': partial(sequence.sequence_generator, length=length, hidden_size=hidden_size), } if FLAGS.mode == 'gan': params.update({ 'discriminator': partial(sequence.sequence_discriminator, length=length, hidden_size=hidden_size), 'loss_builder': model.make_gan_loss }) elif FLAGS.mode == 'ebgan': params.update({ 'discriminator': partial(sequence.sequence_autoencoder_discriminator, length=length, hidden_size=hidden_size), 'loss_builder': partial(model.make_ebgan_loss, epsilon=0.05) }) tf.logging._logger.setLevel(logging.INFO) est = learn.SKCompat( learn.Estimator(model_fn=model.gan_model, model_dir='models/gan_sorting/', params=params)) # Generate data. data = np.random.randint(0, vocab_size, (1000, length)) data.sort() print([data[idx, :] for idx in range(5)]) # Setup monitors. print_monitor = tf.train.LoggingTensorHook( ['loss_discr', 'loss_generator', 'Embed_1/generated_ids'], every_n_iter=100) # Train for a bit. est.fit(x=data, y=None, steps=10000, batch_size=32, monitors=[print_monitor]) ## Evaluate. output = est.predict(x=np.zeros([1000, length], dtype=np.int32)) # Compute accuracy. actual = output.copy() actual.sort() print('\n'.join([str(output[idx, :]) for idx in range(10)])) print("Accuracy: %f" % (float(np.sum(np.all(output == actual, 1))) / len(output)))