def _decoder(self, h, reuse=False): with tf.variable_scope('decoder', reuse=reuse): hidden_layer = mlp(h, self.decoder_layer_sizes, dropout_pct=self.dropout_pct, activation_fn=self.activation_fn, training=self.is_training, reuse=reuse) mu = tf.layers.dense(hidden_layer, self.n_outputs, activation=None, name='mu', reuse=reuse) logvar = tf.layers.dense(hidden_layer, self.n_outputs, activation=None, name='logvar', reuse=reuse) self.t_pred = tf.exp(mu) self.decoder_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='decoder') return mu, logvar
def __init__(self, state_size, action_size): self.state_size = state_size self.action_size = action_size self.memory = deque(maxlen=2000) self.gamma = 0.95 # discount rate self.epsilon = 1.0 # exploration rate self.epsilon_min = 0.01 self.epsilon_decay = 0.995 self.model = mlp(state_size, action_size)
def __init__(self, state_size, action_size, invest_range=(0, 10)): self.state_size = state_size self.action_size = action_size self.memory = deque(maxlen=2000) self.gamma = 0.95 # discount rate self.epsilon = 1.0 # exploration rate self.epsilon_min = 0.01 self.epsilon_decay = 0.995 self.invest_range = invest_range self.invest_num = invest_range[1] - invest_range[0] + 1 self.model = mlp(state_size, self.invest_num * action_size[0] * action_size[1])
def _build_x(self): with tf.variable_scope('embeddings'): x_refined = mlp(self.xv, self.embedding_layer_sizes, dropout_pct=0., activation_fn=tf.nn.tanh) x_max = tf.reduce_max(x_refined, axis=1) x_mean = tf.reduce_mean(x_refined, axis=1) self.x = tf.concat([x_max, x_mean, self.xf], axis=1)
def __init__(self, actions, input_dim, model_dir): # select action function hyper-parameters self.epsilon = 0.9 # q functins hyper-parameters self.gamma = 0.01 # neural network hyper-parmetrs self.lr = 0.001 self.actions = actions output_dim = len(actions) # neural network input and output placeholder self.x = tf.placeholder(tf.float32, [None, input_dim]) self.y = tf.placeholder(tf.float32, [output_dim]) # hidden layer dimension h1_dim = 200 # model inference self.q = mlp("mlp0", self.x, input_dim, h1_dim, output_dim) # loss loss = tf.square(self.y - self.q) # train operation self.train_op = tf.train.AdamOptimizer(self.lr).minimize(loss) # session self.sess = tf.Session() # initalize init_op = tf.initialize_all_variables() self.sess.run(init_op) # saver self.saver = tf.train.Saver(tf.trainable_variables()) # laod model ckpt = tf.train.get_checkpoint_state(model_dir) if ckpt and ckpt.model_checkpoint_path: print("laod model: %s" % (ckpt.model_checkpoint_path)) self.saver.restore(self.sess, ckpt.model_checkpoint_path)
def _encoder(self, h): with tf.variable_scope('encoder'): hidden_layer = mlp(h, self.encoder_layer_sizes, dropout_pct=self.dropout_pct, training=self.is_training, activation_fn=self.activation_fn) logits = tf.layers.dense(hidden_layer, self.n_outputs, activation=None, name='logit_weights') probs = tf.nn.sigmoid(logits) self.encoder_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='encoder') return logits, probs
def run_train(ps_hosts, worker_hosts, job_name, task_index, model_f, data_path, output_path, param_path): # ====================================== # Variables ps_hosts = ps_hosts.split(",") worker_hosts = worker_hosts.split(",") param_dict = load_json(param_path) # Create a cluster from the parameter server and worker hosts. cluster = tf.train.ClusterSpec({"ps": ps_hosts, "worker": worker_hosts}) # Create and start a server for the local task. server = tf.train.Server(cluster, job_name=job_name, task_index=task_index) if job_name == "ps": server.join() elif job_name == "worker": # Load Data (X_train, Y_train, X_valid, Y_valid, _, _) = read_data(data_path, param_dict['train_ratio'], param_dict['valid_ratio']) print("=" * 30) print("X_train shape: {}".format(X_train.shape)) print("Y_train shape: {}".format(Y_train.shape)) print("X_valid shape: {}".format(X_valid.shape)) print("Y_valid shape: {}".format(Y_valid.shape)) print("=" * 30) # Inference output dimension output_dim = len(Y_train[0]) # Check is_chief is_chief = task_index == 0 # Assigns ops to the local worker by default. with tf.device( tf.train.replica_device_setter( worker_device="/job:worker/task:%d" % task_index, cluster=cluster)): # Build model... # Datasets train_X_dataset = tf.data.Dataset.from_tensor_slices(X_train) train_Y_dataset = tf.data.Dataset.from_tensor_slices(Y_train) train_dataset = tf.data.Dataset.zip( (train_X_dataset, train_Y_dataset)) train_dataset = train_dataset.shuffle( param_dict['dataset_shuffle_buffer_size']).batch( param_dict['batch_size']).repeat(param_dict['n_epoch']) if is_chief: valid_X_dataset = tf.data.Dataset.from_tensor_slices(X_valid) valid_Y_dataset = tf.data.Dataset.from_tensor_slices(Y_valid) valid_dataset = tf.data.Dataset.zip( (valid_X_dataset, valid_Y_dataset)) valid_dataset = valid_dataset.shuffle( param_dict['dataset_shuffle_buffer_size']).batch( param_dict['batch_size']) # Feedable Iterator handle = tf.placeholder(tf.string, shape=[]) iterator = tf.data.Iterator.from_string_handle( handle, train_dataset.output_types, train_dataset.output_shapes) # Iterators train_iterator = train_dataset.make_one_shot_iterator() train_handle_tensor = train_iterator.string_handle() if is_chief: valid_iterator = valid_dataset.make_initializable_iterator() valid_handle_tensor = valid_iterator.string_handle() X, Y = iterator.get_next() is_training = tf.placeholder_with_default(False, shape=None, name="is_training") global_step = tf.contrib.framework.get_or_create_global_step() logits = mlp(X=X, output_dim=output_dim, is_training=is_training, **param_dict['model_param']) Y_pred = slim.softmax(logits) loss = slim.losses.softmax_cross_entropy(logits, Y) accuracy, correct = calc_metric(Y, Y_pred) train_op = tf.train.AdamOptimizer( param_dict['learning_rate']).minimize(loss, global_step=global_step) tf.add_to_collection('X', X) tf.add_to_collection('Y_pred', Y_pred) #saved_model_tensor_dict = build_saved_model_graph(X, # Y_pred, # saved_model_path) # The StopAtStepHook handles stopping after running given steps. # hooks = [tf.train.StopAtStepHook(last_step=1000000)] # The MonitoredTrainingSession takes care of session initialization, # restoring from a checkpoint, saving to a checkpoint, and closing when done # or an error occurs. with tf.train.MonitoredTrainingSession( master=server.target, is_chief=is_chief, checkpoint_dir=output_path, # hooks=hooks, ) as mon_sess: # Get dataset handle train_handle = mon_sess.run(train_handle_tensor) valid_handle = mon_sess.run(valid_handle_tensor) # Metric window acc_window = [0.] * TRAIN_METRIC_WINDOW loss_window = [0.] * TRAIN_METRIC_WINDOW batch_i = 0 while not mon_sess.should_stop(): # Run a training step asynchronously. mon_sess.run(train_op, feed_dict={ is_training: True, handle: train_handle, }) if is_chief: train_accuracy, train_loss = mon_sess.run([accuracy, loss], feed_dict={ is_training: False, handle: train_handle, }) acc_window = acc_window[1:] + [train_accuracy] loss_window = loss_window[1:] + [train_loss] if batch_i % VERBOSE_INTERVAL == 0: recent_mean_train_accuracy = sum(acc_window) / len( acc_window) recent_mean_train_loss = sum(loss_window) / len( loss_window) valid_i = 0 valid_correct = 0 valid_loss = 0 valid_total_num = 0 mon_sess.run(valid_iterator.initializer) while True: try: (batch_Y_pred, batch_valid_correct, batch_valid_loss) = mon_sess.run( [Y_pred, correct, loss], feed_dict={ is_training: False, handle: valid_handle, }) curr_batch_num = batch_Y_pred.shape[0] valid_correct += batch_valid_correct.sum() valid_loss += batch_valid_loss * curr_batch_num valid_total_num += curr_batch_num valid_i += 1 except tf.errors.OutOfRangeError: break valid_accuracy = valid_correct / valid_total_num valid_loss = valid_loss / valid_total_num print("-" * 30) print("recent_mean_train_accuracy : {}".format( recent_mean_train_accuracy)) print("recent_mean_train_loss : {}".format( recent_mean_train_loss)) print("valid_accuracy : {}".format(valid_accuracy)) print("valid_loss : {}".format(valid_loss)) batch_i += 1
from keras.optimizers import adam from keras.utils import np_utils from model import mlp np.random.seed(1671) path = "data/GBPUSD.csv" Data = pd.read_csv(path, names=[ 'close', 'Open', 'High', 'Low', 'SMA200', 'EMA15', 'EMA12', 'EMA26', 'MACD', 'bollinger_band_upper_3sd_200', 'bollinger_band_lower_3sd_200', 'stochK', 'stockD' ]) mlp(13, 4) Num_epoch = 200 Batch_size = 128 Verbose = 1 Num_classes = 10 Optimiser = adam N_hidden = 128 Validation_split = 0.2 (X_train, Y_train), (X_test, Y_test) = mnist.load_data() Reshaped = 784 X_train = X_train.astype('float32') X_test = X_test.astype('float32') # normalise the data
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') #parameters input_dim = 22 * 4 output_dim = 12 n_run = 25 model_name = 'wc_predicter.pt' train_path = 'data/Train_data/' train_frame = 200 test_path = 'data/Test_data/' predict_path = 'data/Test_ML_MD/' predict_frame = 20 test_frame = 50 atype_dict = {'O': 0, 'H1': 1, 'H2': 2, 'WC0': 3, 'WC1': 4, 'WC2': 5, 'WC3': 6} atype_inv = {0: 'O', 1: 'H1', 2: 'H2'} #create model model = mlp(input_dim=122 * 4, output_dim=12).to(device) if run_type == 'train': train(model, atype_dict, n_run, model_name, train_path, train_frame, test_path, test_frame) else: resume(model_name, model) model.eval() make_prediction(model, predict_path, predict_frame, atype_dict, savedir='predicted_temp')
def main(unused_argv): mnist = tf.contrib.learn.datasets.load_dataset('mnist') if FLAGS.job_name is None or FLAGS.job_name == '': raise ValueError('Must specify an explicit job_name !') else: print 'job_name : %s' % FLAGS.job_name if FLAGS.task_index is None or FLAGS.task_index == '': raise ValueError('Must specify an explicit task_index!') else: print 'task_index : %d' % FLAGS.task_index ps_spec = FLAGS.ps_hosts.split(',') worker_spec = FLAGS.worker_hosts.split(',') # 创建集群 cluster = tf.train.ClusterSpec({'ps': ps_spec, 'worker': worker_spec}) config = tf.ConfigProto() config.gpu_options.allow_growth = True server = tf.train.Server(cluster, job_name=FLAGS.job_name, task_index=FLAGS.task_index, config=config) if FLAGS.job_name == 'ps': server.join() is_chief = (FLAGS.task_index == 0) with tf.device(tf.train.replica_device_setter(cluster=cluster)): global_step = tf.Variable(0, name='global_step', trainable=False) x = tf.placeholder(tf.float32, [None, FLAGS.image_pixels * FLAGS.image_pixels]) y_ = tf.placeholder(tf.int32, [None]) logits = model.mlp(x, FLAGS.image_pixels, FLAGS.hidden_units, FLAGS.num_classes) cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits( labels=y_, logits=logits) # accuracy accuracy = tf.metrics.accuracy(y_, tf.argmax(logits, axis=1)) train_op = tf.train.AdamOptimizer(FLAGS.learning_rate).minimize( cross_entropy, global_step=global_step) # 生成本地的参数初始化操作init_op init_op = tf.global_variables_initializer() #train_dir = tempfile.mkdtemp() train_dir = FLAGS.train_dir # Supervisor is deprecated, using "MonitoredTrainingSession" instead # logdir: checkpoint save dir sv = tf.train.Supervisor(is_chief=is_chief, logdir=train_dir, init_op=init_op, recovery_wait_secs=1, global_step=global_step) if is_chief: print 'Worker %d: Initailizing session...' % FLAGS.task_index else: print 'Worker %d: Waiting for session to be initaialized...' % FLAGS.task_index sess = sv.prepare_or_wait_for_session(server.target) print 'Worker %d: Session initialization complete.' % FLAGS.task_index time_begin = time.time() print 'Traing begins @ %f' % time_begin local_step = 0 while True: batch_xs, batch_ys = mnist.train.next_batch(FLAGS.batch_size) train_feed = {x: batch_xs, y_: batch_ys} _, step = sess.run([train_op, global_step], feed_dict=train_feed) local_step += 1 now = time.time() print '%f: Worker %d: traing step %d done (global step:%d)' % ( now, FLAGS.task_index, local_step, step) if step >= FLAGS.train_steps: break time_end = time.time() print 'Training ends @ %f' % time_end train_time = time_end - time_begin print 'Training elapsed time:%f s' % train_time if is_chief: val_feed = {x: mnist.validation.images, y_: mnist.validation.labels} val_xent, val_accuracy = sess.run([cross_entropy, accuracy], feed_dict=val_feed) print 'After %d training step(s)' % (FLAGS.train_steps) print('cross_entropy:') print(np.mean(val_xent)) print("accuracy:") print(val_accuracy) sess.close()
import statsmodels.api as sm import matplotlib.pyplot as plt from statsmodels.stats.proportion import proportion_confint from model import logistic, xgb, mlp warnings.filterwarnings("ignore") # load data X_train = np.load("data/train.npy") y_train = np.load("data/train_labels.npy") X_test = np.load("data/test.npy") y_test = np.load("data/test_labels.npy") # print data shape print("Training data shape: {}".format(X_train.shape)) print("Training labels shape: {}".format(y_train.shape)) print("Testing data shape: {}".format(X_test.shape)) print("Testing labels shape: {}".format(y_test.shape)) yhat, probs = mlp(X_train, y_train, X_test) # accuracy # confidence interval # classification report # confusion matrix # roc_auc # fpr, tpr
def train(speckle_path, image_path, check_point, decoder_path, save_path, code_length=128, lr=1e-3, batch_size=64, epochs=100, use_pretrain=True, model_type='autoencoder'): X_train = np.load(speckle_path[0]) Y_train = np.load(image_path[0]) X_val = np.load(speckle_path[1]) Y_val = np.load(image_path[1]) if model_type == 'autoencoder': E = encoder(code_length=code_length) if use_pretrain: D = load_model(decoder_path) else: D = decoder(code_length=code_length) model = encoder_decoder(E, D) elif model_type == 'unet': model = unet() elif model_type == 'mlp': model = mlp(input_length=1024, hidden_units=1024, hidden_layers=7, activation="relu", batchnorm=True, dropout=0.1) X_train = np.reshape(X_train, (3500, 16384)) # Y_train = np.reshape(Y_train, (3500, 1024)) X_val = np.reshape(X_val, (500, 16384)) # Y_val = np.reshape(Y_val, (500, 1024)) pca = PCA(n_components=1024) X_train = pca.fit_transform(X_train) X_val = pca.transform(X_val) flatten = False adam = Adam(lr=lr) model.compile(optimizer=adam, loss='mse') model.summary() history = model.fit(X_train, Y_train, epochs=epochs, batch_size=batch_size, validation_data=(X_val, Y_val), callbacks=[Test(X_val, Y_val, check_point, flatten)], shuffle=True) np.save(save_path + 'loss.npy', history.history['loss']) np.save(save_path + 'val_loss.npy', history.history['val_loss']) X_test = np.load(speckle_path[2]) Y_test = np.load(image_path[2]) if model_type == 'mlp': X_test = np.reshape(X_test, (1000, 16384)) # Y_test = np.reshape(Y_test, (1000, 1024)) X_test = pca.transform(X_test) model = load_model(check_point) print("final result:") a, b, c = assess(model, X_test, Y_test, flatten)
def main(): # ---------- general parameters ---------- epsilon = 0.1 # noise multiplier batch_size = 64 adversary_batches = 5 # number of adversary batches to create epochs = 5 # number of training / testing epochs # ---------- model definition ---------- # getting batches to train x_train, y_train, x_test, y_test, n_labels = load_datasets(batch_size) # setting placeholders x_ph = tf.placeholder(tf.float32, shape=[batch_size, 28, 28], name='X_input') y_ph = tf.placeholder(tf.int32, shape=[batch_size], name='Y_input') # defining model, loss, regularizer, and optimizer regularizer = tf.contrib.layers.l2_regularizer(scale=0.1) model = mlp(x_ph, n_labels, regularizer=regularizer) loss_func = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y_ph, logits=model, name='loss') reg_variables = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES) reg_term = tf.contrib.layers.apply_regularization(regularizer, reg_variables) loss = loss_func + reg_term optimizer = tf.train.AdamOptimizer().minimize(loss) # variable initializer init = tf.global_variables_initializer() # ---------- training and generating examples ---------- with tf.Session() as sess: sess.run(init) # training the network for epoch in range(epochs): for data, labels in zip(x_train, y_train): sess.run([loss, optimizer, model], feed_dict={ x_ph: data, y_ph: labels }) # ---------- generating adversarial examples ---------- # 1. choosing batches of images out of the test set inds = np.random.randint(len(x_test), size=adversary_batches) data_set = [x_test[ind] for ind in inds] label_set = [y_test[ind] for ind in inds] # 2. calculating the sign of the gradient of the loss function with respect to the images gradients = tf.gradients(loss, [x_ph]) s_gradients = tf.sign(gradients) original_accuracies = list() adversarial_accuracies = list() examples = list() for data, labels in zip(data_set, label_set): s_grads = sess.run([s_gradients], feed_dict={ x_ph: data, y_ph: labels }) s_grads = np.reshape(s_grads[0], s_grads[0].shape[1:]) # 3. creating the adversarial versions of the images in the batch adversarial_images = data + epsilon * s_grads # 4. checking accuracy on original images logits = sess.run([model], feed_dict={x_ph: data}) logits = logits[0] original_accuracies.append(calculate_accuracy(logits, labels)) # 5. checking accuracy on adversarial images logits = sess.run([model], feed_dict={x_ph: adversarial_images}) logits = logits[0] adversarial_accuracies.append(calculate_accuracy(logits, labels)) if len(examples) < 2: examples.append(data[0]) examples.append(adversarial_images[0]) # 6. comparison and showing examples print('average accuracy of original images:', np.mean(original_accuracies)) print('average accuracy of adversarial images:', np.mean(adversarial_accuracies)) plt.figure() plt.imshow(examples[0], cmap='gray') plt.figure() plt.imshow(examples[1], cmap='gray') plt.show()