def save_session(self): time_at_start_save = time.time() sys.stdout.write( '{}: [Step {}k -- Took {:3.2f} s] '.format( datetime.now(), self.step // 1000, time_at_start_save - self.last_time)) self.last_time = time_at_start_save Parameters.add_attr("CURRENT_STEP", self.step) a = time.time() Parameters.update() b = time.time() sys.stdout.write('[{:3.2f}s for json] '.format(b - a)) save_file = path.join( Parameters.SESSION_SAVE_DIRECTORY, Parameters.SESSION_SAVE_FILENAME) if not path.exists(Parameters.SESSION_SAVE_DIRECTORY): makedirs(Parameters.SESSION_SAVE_DIRECTORY) a = time.time() self.tf_saver.save(self.tf_session, save_file) b = time.time() sys.stdout.write('[{:3.2f}s for tf] '.format(b - a)) a = time.time() Plotter.save("out") b = time.time() sys.stdout.write('[{:3.2f}s for Plotter] '.format(b - a)) a = time.time() self.memory.save_memory() b = time.time() sys.stdout.write('[{:3.2f}s for memory] '.format(b - a)) post_save_time = time.time() sys.stdout.write( '[Required {:3.2f}s to save all] '.format( post_save_time - time_at_start_save)) self.last_time = post_save_time elapsed_time = time.time() - self.initial_time remaining_seconds = elapsed_time * \ (Parameters.MAX_STEPS - self.step) / (self.step - self.initial_step) print("eta: {}s".format((timedelta(seconds=remaining_seconds))))
def main(): print("Loading wordvecs...") if utils.exists("glove", "glove.840B.300d.txt", "gutenberg"): words, wordvecs = utils.load_glove("glove", "glove.840B.300d.txt", "gutenberg") else: words, wordvecs = utils.load_glove("glove", "glove.840B.300d.txt", "gutenberg", set(map(clean_word, gutenberg.words()))) wordvecs_norm = wordvecs / np.linalg.norm(wordvecs, axis=1).reshape(-1, 1) print("Loading corpus...") # Convert corpus into normed wordvecs, replacing any words not in vocab with zero vector sentences = [[wordvecs_norm[words[clean_word(word)]] if clean_word(word) in words.keys() else np.zeros(WORD_DIM) for word in sentence] for sentence in gutenberg.sents()] print("Processing corpus...") # Pad sentences shorter than SEQUENCE_LENGTH with zero vectors and truncate sentences longer than SEQUENCE_LENGTH s_train = list(map(pad_or_truncate, sentences)) np.random.shuffle(s_train) # Truncate to multiple of BATCH_SIZE s_train = s_train[:int(len(s_train) / BATCH_SIZE) * BATCH_SIZE] s_train_idxs = np.arange(len(s_train)) print("Generating graph...") network = NlpGan(learning_rate=LEARNING_RATE, d_dim_state=D_DIM_STATE, g_dim_state=G_DIM_STATE, dim_in=WORD_DIM, sequence_length=SEQUENCE_LENGTH) plotter = Plotter([2, 1], "Loss", "Accuracy") plotter.plot(0, 0, 0, 0) plotter.plot(0, 0, 0, 1) plotter.plot(0, 0, 1, 0) plotter.plot(0, 1, 1, 0) #d_vars = [var for var in tf.trainable_variables() if 'discriminator' in var.name] saver = tf.train.Saver() with tf.Session() as sess: #eval(sess, network, words, wordvecs_norm, saver) sess.run(tf.global_variables_initializer()) #resume(sess, saver, plotter, "GAN_9_SEQUENCELENGTH_10", 59) d_loss, g_loss = 0.0, 0.0 for epoch in range(0, 10000000): print("Epoch %d" % epoch) np.random.shuffle(s_train_idxs) for batch in range(int(len(s_train_idxs) / BATCH_SIZE)): # select next random batch of sentences s_batch_real = [s_train[x] for x in s_train_idxs[batch:batch + BATCH_SIZE]] # shape (BATCH_SIZE, SEQUENCE_LENGTH, WORD_DIM) # reshape to (SEQUENCE_LENGTH, BATCH_SIZE, WORD_DIM) while preserving sentence order s_batch_real = np.array(s_batch_real).swapaxes(0, 1) if d_loss - g_loss > MAX_LOSS_DIFF and False: output_dict = sess.run( network.get_fetch_dict('d_loss', 'd_train', 'g_loss'), network.get_feed_dict(inputs=s_batch_real, input_dropout=D_KEEP_PROB) ) elif g_loss - d_loss > MAX_LOSS_DIFF and False: output_dict = sess.run( network.get_fetch_dict('d_loss', 'g_loss', 'g_train'), network.get_feed_dict(inputs=s_batch_real, input_dropout=D_KEEP_PROB) ) else: output_dict = sess.run( network.get_fetch_dict('d_loss', 'd_train', 'g_loss', 'g_train'), network.get_feed_dict(inputs=s_batch_real, input_dropout=D_KEEP_PROB, instance_variance=INSTANCE_VARIANCE) ) d_loss, g_loss = output_dict['d_loss'], output_dict['g_loss'] if batch % 10 == 0: print("Finished training batch %d / %d" % (batch, int(len(s_train) / BATCH_SIZE))) print("Discriminator Loss: %f" % output_dict['d_loss']) print("Generator Loss: %f" % output_dict['g_loss']) plotter.plot(epoch + (batch / int(len(s_train) / BATCH_SIZE)), d_loss, 0, 0) plotter.plot(epoch + (batch / int(len(s_train) / BATCH_SIZE)), g_loss, 0, 1) if batch % 100 == 0: eval = sess.run( network.get_fetch_dict('g_outputs', 'd_accuracy'), network.get_feed_dict(inputs=s_batch_real, input_dropout=1.0, instance_variance=INSTANCE_VARIANCE) ) # reshape g_outputs to (BATCH_SIZE, SEQUENCE_LENGTH, WORD_DIM) while preserving sentence order generated = eval['g_outputs'].swapaxes(0, 1) for sentence in generated[:3]: for wordvec in sentence: norm = np.linalg.norm(wordvec) word, similarity = nearest_neighbor(words, wordvecs_norm, wordvec / norm) print("{}({:4.2f})".format(word, similarity)) print('\n---------') print("Total Accuracy: %f" % eval['d_accuracy']) plotter.plot(epoch + (batch / int(len(s_train) / BATCH_SIZE)), eval['d_accuracy'], 1, 0) saver.save(sess, './checkpoints/{}.ckpt'.format(SAVE_NAME), global_step=epoch) plotter.save(SAVE_NAME)
beg_yr = int(sys.argv[2]) end_yr = int(sys.argv[3]) nc_var = sys.argv[4] obs_pattern = sys.argv[5] obs_nc_var = sys.argv[6] for yr in xrange(beg_yr, end_yr): pattern = os.path.join(nc_dir, '*' + str(yr) + '*.nc') # for r = RegCMReader(pattern) value = r.get_value(nc_var).mean() time_limits = value.get_limits('time') crd_limits = value.get_latlonlimits() obs_r = CRUReader(obs_pattern) obs_value = obs_r.get_value(obs_nc_var, imposed_limits={ 'time': time_limits }, latlon_limits=crd_limits).mean() if obs_nc_var == "TMP": obs_value.to_K() value.regrid(obs_value.latlon) diff = obs_value - value plt = Plotter(diff) plt.plot(levels=(-5, 5)) plt.show() plt.save('image', format='png') plt.close()
Example: ./app.py 'data/Africa_SRF.1970*.nc' t2m 'obs/CRUTMP.CDF' TMP """ if __name__ == "__main__": if len(sys.argv) != 5: print usage sys.exit(1) pattern = sys.argv[1] nc_var = sys.argv[2] obs_pattern = sys.argv[3] obs_nc_var = sys.argv[4] r = RegCMReader(pattern) value = r.get_value(nc_var).mean() time_limits = value.get_limits('time') crd_limits = value.get_latlonlimits() obs_r = CRUReader(obs_pattern) obs_value = obs_r.get_value(obs_nc_var, imposed_limits={'time': time_limits}, latlon_limits=crd_limits).mean() if obs_nc_var == "TMP": obs_value.to_K() value.regrid(obs_value.latlon) diff = obs_value - value plt = Plotter(diff) plt.plot(levels = (-5, 5)) plt.show() plt.save('image', format='png') plt.close()