history = model.fit(x=train_ds, epochs=num_epoch, steps_per_epoch=steps, validation_data=val_ds, validation_steps=steps, callbacks=callbacks_for_fit) self.assertIsInstance(history, keras.callbacks.History) threads = self.run_multiple_tasks_in_threads( _independent_worker_fn, cluster_spec, verification_callback=verification_callback) threads_to_join = [] for task_type, ts in threads.items(): # This test can finish once the worker threads complete, and thus # the ps threads don't need to be joined. if task_type == 'ps': continue threads_to_join.extend(ts) self.join_independent_workers(threads_to_join) verification_callback.verify(self) if __name__ == '__main__': # Enable manual variable initialization to make sure variables are initialized # by `init_restore_or_wait_for_variables`. backend.manual_variable_initialization(True) with test.mock.patch.object(sys, 'exit', os._exit): test.main()
x=train_ds, epochs=num_epoch, steps_per_epoch=steps, validation_data=val_ds, validation_steps=steps, callbacks=callbacks_for_fit) self.assertIsInstance(history, keras.callbacks.History) threads = self.run_multiple_tasks_in_threads( _independent_worker_fn, cluster_spec, verification_callback=verification_callback) threads_to_join = [] for task_type, ts in threads.items(): # This test can finish once the worker threads complete, and thus # the ps threads don't need to be joined. if task_type == 'ps': continue threads_to_join.extend(ts) self.join_independent_workers(threads_to_join) verification_callback.verify(self) if __name__ == '__main__': # Enable manual variable initialization to make sure variables are initialized # by `init_restore_or_wait_for_variables`. backend.manual_variable_initialization(True) with test.mock.patch.object(sys, 'exit', os._exit): test.main()
def main(argv=None): keras.backend.set_learning_phase(1) manual_variable_initialization(True) # Create TF session and set as Keras backend session sess = tf.Session() keras.backend.set_session(sess) # Get MNIST test data X_train, Y_train, X_test, Y_test = data_mnist() assert Y_train.shape[1] == 10. label_smooth = .1 Y_train = Y_train.clip(label_smooth / 9., 1. - label_smooth) # Define input TF placeholder x = tf.placeholder(tf.float32, shape=(None, 28, 28, 1)) y = tf.placeholder(tf.float32, shape=(None, 10)) wrm_params = { 'eps': 1.3, 'ord': 2, 'y': y, 'steps': 15, 'stop_gradient': FLAGS.stop_gradient } print('wrm params', wrm_params) if not FLAGS.skip_clean_train: print("Train on clean data") # Define TF model graph model = cnn_model(activation='elu') predictions = model(x) wrm = WassersteinRobustMethod(model, sess=sess) predictions_adv_wrm = model(wrm.generate(x, **wrm_params)) def evaluate(): # Evaluate the accuracy of the MNIST model on legitimate test examples accuracy = model_eval(sess, x, y, predictions, X_test, Y_test, args=eval_params) print('Test accuracy on legitimate test examples: %0.4f' % accuracy) # Accuracy of the model on Wasserstein adversarial examples accuracy_adv_wass = model_eval(sess, x, y, predictions_adv_wrm, X_test, \ Y_test, args=eval_params) print('Test accuracy on Wasserstein examples: %0.4f\n' % accuracy_adv_wass) # Train the model model_train(sess, x, y, predictions, X_train, Y_train, evaluate=evaluate, \ args=train_params, save=False) model.save(FLAGS.train_dir + '/' + FLAGS.filename_erm) print('') print("Repeating the process, using Wasserstein adversarial training") # Redefine TF model graph model_adv = cnn_model(activation='elu') predictions_adv = model_adv(x) wrm2 = WassersteinRobustMethod(model_adv, sess=sess) predictions_adv_adv_wrm = model_adv(wrm2.generate(x, **wrm_params)) def evaluate_adv(): # Accuracy of adversarially trained model on legitimate test inputs accuracy = model_eval(sess, x, y, predictions_adv, X_test, Y_test, args=eval_params) print('Test accuracy on legitimate test examples: %0.4f' % accuracy) # Accuracy of the adversarially trained model on Wasserstein adversarial examples accuracy_adv_wass = model_eval(sess, x, y, predictions_adv_adv_wrm, \ X_test, Y_test, args=eval_params) print('Test accuracy on Wasserstein examples: %0.4f\n' % accuracy_adv_wass) model_train(sess, x, y, predictions_adv_adv_wrm, X_train, Y_train, \ predictions_adv=predictions_adv_adv_wrm, evaluate=evaluate_adv, \ args=train_params, save=False) model_adv.save(FLAGS.train_dir + '/' + FLAGS.filename_wrm)
import tensorflow as tf import random, pygame, signal, time from ple.games.pixelcopter import Pixelcopter from ple import PLE from pygame.constants import K_w, K_s import numpy as np from collections import deque from tensorflow.python.keras import backend as K from collections import deque from tensorflow.python.keras.models import Sequential from tensorflow.python.keras.layers import Dense, Dropout from tensorflow.python.keras.optimizers import Adam from tensorflow.python.keras.backend import manual_variable_initialization manual_variable_initialization(True) class DQNAgent: def __init__(self, state_size, action_size): self.state_size = state_size self.action_size = action_size self.learning_rate = 0.0004 self.model = self._build_model() def _build_model(self): # Ensure to use same model architecture as that was trained and loaded model = Sequential() model.add(Dense(32, input_dim=self.state_size, activation='relu')) model.add(Dense(48, activation='relu')) model.add(Dense(32, activation='relu'))