def main(): tf.set_random_seed(10) with tf.Session() as sess: rnn_cell = tf.nn.rnn_cell.LSTMCell(10) # defining initial state initial_state = rnn_cell.zero_state(4, dtype=tf.float32) inputs = tf.Variable(tf.random_uniform(shape = (4, 30, 100)), name='input') inputs = tf.identity(inputs, "input_node") # 'state' is a tensor of shape [batch_size, cell_state_size] outputs, state = tf.nn.dynamic_rnn(rnn_cell, inputs, initial_state=initial_state, dtype=tf.float32) y1 = tf.identity(outputs, 'outputs') y2 = tf.identity(state, 'state') t1 = tf.ones([4, 30, 10]) t2 = tf.ones([4, 10]) loss = tf.reduce_sum((y1 - t1) * (y1 - t1)) + tf.reduce_sum((y2 - t2) * (y2 - t2)) tf.identity(loss, name = "lstm_loss") # tf.summary.FileWriter('/tmp/log', tf.get_default_graph()) net_outputs = map(lambda x: tf.get_default_graph().get_tensor_by_name(x), argv[2].split(',')) run_model(net_outputs, argv[1], None, argv[3] == 'True')
def main(): """ You can also run these commands manually to generate the pb file 1. git clone https://github.com/tensorflow/models.git 2. export PYTHONPATH=Path_to_your_model_folder 3. python temporal_convolution.py """ tf.set_random_seed(1024) input_width = 32 input_channel = 3 inputs = tf.Variable(tf.random_uniform((1, input_width, input_channel)), name='input') inputs = tf.identity(inputs, "input_node") filter_width = 4 output_channels = 6 filters = tf.Variable( tf.random_uniform((filter_width, input_channel, output_channels))) conv_out = tf.nn.conv1d(inputs, filters, stride=1, padding="VALID") bias = tf.Variable(tf.zeros([output_channels])) output = tf.nn.tanh(tf.nn.bias_add(conv_out, bias), name="output") net_outputs = map(lambda x: tf.get_default_graph().get_tensor_by_name(x), argv[2].split(',')) run_model(net_outputs, argv[1], backward=(argv[3] == 'True'))
def main(): tf.set_random_seed(1) n_steps = 2 n_input = 10 n_hidden = 10 xs = tf.Variable(tf.random_uniform([4, n_steps, n_input]) + 10, name='input', dtype=tf.float32) xs = tf.identity(xs, name="input_node") x = tf.unstack(xs, n_steps, 1) cell = tf.contrib.rnn.BasicLSTMCell(n_hidden) init_state = cell.zero_state(4, tf.float32) outputs = [] for i in range(n_steps): if i == 0: output, state = cell(x[-1], init_state) else: output, state = cell(output, state) outputs.append(output) final = tf.identity(outputs, name="output") net_outputs = map(lambda x: tf.get_default_graph().get_tensor_by_name(x), argv[2].split(',')) run_model(net_outputs, argv[1], 'rnn', argv[3] == 'True')
def main(): tf.set_random_seed(10) with tf.Session() as sess: inputs = tf.Variable(tf.random_uniform((20, 30, 32)), name='input') inputs = tf.identity(inputs, "input_node") input1, input2, input3, input4 = tf.split(inputs, 4, 0) # scatter and gather tensor_array = tf.TensorArray(tf.float32, 128) tensor_array = tensor_array.scatter([1, 2, 5, 4, 3], input1) tensor_array.gather([1, 2, 5, 4, 3], name='scatter_and_gather') # split and concat tensor_array = tf.TensorArray(tf.float32, 2) tensor_array = tensor_array.split(input2, [2, 3]) tf.identity(tensor_array.concat(), name='split_and_concat') # write and read tensor_array = tf.TensorArray(tf.float32, 5) tensor_array = tensor_array.identity() tensor_array = tensor_array.write(1, input3) tf.cast(tensor_array.size(), tf.float32, name='size1') tensor_array.read(1, name='write_and_read') tf.cast(tensor_array.size(), tf.float32, name='size2') # unstack and stack tensor_array = tf.TensorArray(tf.float32, 5) tensor_array = tensor_array.unstack(input4) tf.identity(tensor_array.stack(), name='unstack_and_stack') net_outputs = map( lambda x: tf.get_default_graph().get_tensor_by_name(x), argv[2].split(',')) run_model(net_outputs, argv[1], None, argv[3] == 'True')
def main(): """ Run this command to generate the pb file 1. mkdir model 2. python rnn_lstm.py """ tf.set_random_seed(1) n_steps = 2 n_input = 10 n_hidden = 20 n_output = 5 # xs = tf.placeholder(tf.float32, [None, n_steps, n_input]) xs = tf.Variable(tf.random_uniform([4, n_steps, n_input]) + 10, name='input', dtype=tf.float32) xs = tf.identity(xs, "input_node") weight = tf.Variable(tf.random_uniform([n_hidden, n_output]) + 10, name="weight", dtype=tf.float32) bias = tf.Variable(tf.random_uniform([n_output]) + 10, name="bias", dtype=tf.float32) x = tf.unstack(xs, n_steps, 1) cell = rnn.BasicLSTMCell(n_hidden) output, states = rnn.static_rnn(cell, x, dtype=tf.float32) final = tf.nn.bias_add(tf.matmul(output[-1], weight), bias, name='output') net_outputs = map(lambda x: tf.get_default_graph().get_tensor_by_name(x), argv[2].split(',')) run_model(net_outputs, argv[1], 'rnn', argv[3] == 'True')
def main(): tf.set_random_seed(10) with tf.Session() as sess: rnn_cell = tf.nn.rnn_cell.LSTMCell(10) # defining initial state initial_state = rnn_cell.zero_state(4, dtype=tf.float32) inputs = tf.Variable(tf.random_uniform(shape=(4, 30, 100)), name='input') inputs = tf.identity(inputs, "input_node") # 'state' is a tensor of shape [batch_size, cell_state_size] outputs, state = tf.nn.dynamic_rnn(rnn_cell, inputs, initial_state=initial_state, dtype=tf.float32) y1 = tf.identity(outputs, 'outputs') y2 = tf.identity(state, 'state') t1 = tf.ones([4, 30, 10]) t2 = tf.ones([4, 10]) loss = tf.reduce_sum((y1 - t1) * (y1 - t1)) + tf.reduce_sum( (y2 - t2) * (y2 - t2)) tf.identity(loss, name="lstm_loss") # tf.summary.FileWriter('/tmp/log', tf.get_default_graph()) net_outputs = map( lambda x: tf.get_default_graph().get_tensor_by_name(x), argv[2].split(',')) run_model(net_outputs, argv[1], None, argv[3] == 'True')
def main(): inputs = tf.Variable(tf.reshape(tf.range(0.0, 16), [1, 1, 4, 4]), name = 'input') inputs = tf.identity(inputs, "input_node") output = tf.layers.batch_normalization(inputs, axis=1, training=True) named_output = tf.nn.relu(output, name="output") net_outputs = map(lambda x: tf.get_default_graph().get_tensor_by_name(x), argv[2].split(',')) run_model(net_outputs, argv[1], 'batchNorm', argv[3] == 'True')
def main(): inputs = tf.Variable(tf.reshape(tf.range(0.0, 4.0), [4, 1]), name = 'input') inputs = tf.identity(inputs, "input_node") output = tf.concat([inputs, inputs], axis=0) named_output = tf.nn.relu(output, name="output") net_outputs = map(lambda x: tf.get_default_graph().get_tensor_by_name(x), argv[2].split(',')) run_model(net_outputs, argv[1], 'two_edge', argv[3] == 'True')
def main(): """ You can also run these commands manually to generate the pb file 1. git clone https://github.com/tensorflow/models.git 2. export PYTHONPATH=Path_to_your_model_folder 3. python alexnet.py """ height, width = 224, 224 inputs = tf.Variable(tf.random_uniform((1, height, width, 3)), name='input') net, end_points = vgg.vgg_19(inputs, is_training = False) print("nodes in the graph") for n in end_points: print(n + " => " + str(end_points[n])) net_outputs = map(lambda x: tf.get_default_graph().get_tensor_by_name(x), argv[2].split()) run_model(net_outputs, argv[1])
def main(): """ You can also run these commands manually to generate the pb file 1. git clone https://github.com/tensorflow/models.git 2. export PYTHONPATH=Path_to_your_model_folder 3. python alexnet.py """ height, width = 224, 224 inputs = tf.Variable(tf.random_uniform((1, height, width, 3)), name='input') inputs = tf.identity(inputs, "input_node") net, end_points = vgg.vgg_a(inputs, is_training = False) print("nodes in the graph") for n in end_points: print(n + " => " + str(end_points[n])) net_outputs = map(lambda x: tf.get_default_graph().get_tensor_by_name(x), argv[2].split(',')) run_model(net_outputs, argv[1], 'vgg_a', argv[3] == 'True')
def main(): """ You can also run these commands manually to generate the pb file 1. git clone https://github.com/tensorflow/models.git 2. export PYTHONPATH=Path_to_your_model_folder 3. python alexnet.py """ height, width = 32, 32 inputs = tf.Variable(tf.random_uniform((1, height, width, 3)), name='input') inputs = tf.identity(inputs, "input_node") net, end_points = lenet.lenet(inputs) print("nodes in the graph") for n in end_points: print(n + " => " + str(end_points[n])) net_outputs = map(lambda x: tf.get_default_graph().get_tensor_by_name(x), argv[2].split(',')) run_model(net_outputs, argv[1], 'LeNet', argv[3] == 'True')
def main(): inputs = tf.Variable(tf.reshape(tf.range(0.0, 4.0), [4, 1]), name = 'input') inputs = tf.identity(inputs, "input_node") W1 = tf.Variable(tf.zeros([1,10])+0.2) b1 = tf.Variable(tf.zeros([10])+0.1) out1 = tf.nn.bias_add(tf.matmul(inputs, W1), b1) W2 = tf.Variable(tf.zeros([1,10])+0.2) b2 = tf.Variable(tf.zeros([10])+0.1) out2 = tf.nn.bias_add(tf.matmul(inputs, W2), b2) with tf.control_dependencies([inputs]): output = tf.add_n([out1, out2]) named_output = tf.nn.relu(output, name="output") net_outputs = map(lambda x: tf.get_default_graph().get_tensor_by_name(x), argv[2].split(',')) run_model(net_outputs, argv[1], 'control_dep', argv[3] == 'True')
def main(): """ You can also run these commands manually to generate the pb file 1. git clone https://github.com/tensorflow/models.git 2. export PYTHONPATH=Path_to_your_model_folder 3. python alexnet.py """ tf.set_random_seed(1) height, width = 299, 299 inputs = tf.Variable(tf.random_uniform((2, height, width, 3)), name='input') inputs = tf.identity(inputs, "input_node") net, end_points = inception_resnet_v2.inception_resnet_v2( inputs, is_training=False) print("nodes in the graph") for n in end_points: print(n + " => " + str(end_points[n])) net_outputs = map(lambda x: tf.get_default_graph().get_tensor_by_name(x), argv[2].split(',')) run_model(net_outputs, argv[1], 'InceptionResnetV2', argv[3] == 'True')
def main(): inputs = tf.Variable(tf.reshape(tf.range(0.0, 4.0), [4, 1]), name='input') inputs = tf.identity(inputs, "input_node") W1 = tf.Variable(tf.zeros([1, 10]) + 0.2) b1 = tf.Variable(tf.zeros([10]) + 0.1) out1 = tf.nn.bias_add(tf.matmul(inputs, W1), b1) W2 = tf.Variable(tf.zeros([1, 10]) + 0.2) b2 = tf.Variable(tf.zeros([10]) + 0.1) out2 = tf.nn.bias_add(tf.matmul(inputs, W2), b2) with tf.control_dependencies([inputs]): output = tf.add_n([out1, out2]) named_output = tf.nn.relu(output, name="output") net_outputs = map(lambda x: tf.get_default_graph().get_tensor_by_name(x), argv[2].split(',')) run_model(net_outputs, argv[1], 'control_dep', argv[3] == 'True')
def main(): """ You can also run these commands manually to generate the pb file 1. git clone https://github.com/tensorflow/models.git 2. export PYTHONPATH=Path_to_your_model_folder 3. python temporal_convolution.py """ tf.set_random_seed(1024) input_width = 32 input_channel = 3 inputs = tf.Variable(tf.random_uniform((1, input_width, input_channel)), name='input') inputs = tf.identity(inputs, "input_node") filter_width = 4 output_channels = 6 filters = tf.Variable(tf.random_uniform((filter_width, input_channel, output_channels))) conv_out = tf.nn.conv1d(inputs, filters, stride=1, padding="VALID") bias = tf.Variable(tf.zeros([output_channels])) output = tf.nn.tanh(tf.nn.bias_add(conv_out, bias), name="output") net_outputs = map(lambda x: tf.get_default_graph().get_tensor_by_name(x), argv[2].split(',')) run_model(net_outputs, argv[1], backward=(argv[3] == 'True'))
def main(): """ You can also run these commands manually to generate the pb file 1. git clone https://github.com/tensorflow/models.git 2. export PYTHONPATH=Path_to_your_model_folder 3. python alexnet.py """ height, width = 224, 224 batchSize = 1 if len(argv) == 5: batchSize = int(argv[4]) inputs = tf.Variable(tf.random_uniform((batchSize, 3, height, width)), name='input') net, end_points = alexnet_v1(inputs, is_training=False, spatial_squeeze=False) print("nodes in the graph") for n in end_points: print(n + " => " + str(end_points[n])) net_outputs = map(lambda x: tf.get_default_graph().get_tensor_by_name(x), argv[2].split(',')) run_model(net_outputs, argv[1], 'alexnet', argv[3] == 'True')
def eval_model(self, Manager, text_file, dirname, train_load, val_load, test_load, train_data, val_data, test_data, training): options = Manager.options train_args = Manager.train_args """Preparing for training""" best_val_loss = np.inf best_val_auc = 0 if training == 'testing': train_args['NumEpochs'] = 1 else: text_file = open(text_file, "w") for t in range(Manager.train_args['NumEpochs']): tini = time.time() train_acc, train_loss, train_auc, _, train_out, train_collect = run_model( t, Manager=Manager, data_load=train_load, train_data=train_data, phase=training, use_gpu=train_args['use_gpu']) if options['use_val']: val_acc, val_loss, val_auc, _, val_out, val_collect = run_model( t, Manager=Manager, data_load=val_load, train_data=val_data, phase='val', use_gpu=train_args['use_gpu']) else: val_acc = 0 val_auc = 0 val_loss = 0 test_acc, test_loss, test_auc, _, test_out, test_collect = run_model( t, Manager=Manager, data_load=test_load, train_data=test_data, phase='test', use_gpu=train_args['use_gpu']) if t % 10 == 0: print_cams(test_collect, t, 2) Manager.scheduler.step() """Save Model""" if (val_loss <= best_val_loss) and training == 'training': best_val_loss = val_loss if Manager.train_args['RunPar']: torch.save(Manager.net.module.state_dict(), os.path.join(dirname, 'PRE0')) else: torch.save(Manager.net.state_dict(), os.path.join(dirname, 'PRE0')) np.save(os.path.join(dirname, 'train_features'), train_collect['features']) np.save(os.path.join(dirname, 'val_features'), val_collect['features']) np.save(os.path.join(dirname, 'test_features'), test_collect['features']) np.save(os.path.join(dirname, 'train_out'), train_collect['out']) np.save(os.path.join(dirname, 'val_out'), val_collect['out']) np.save(os.path.join(dirname, 'test_out'), test_collect['out']) np.save(os.path.join(dirname, 'train_labels'), train_collect['labels']) np.save(os.path.join(dirname, 'val_labels'), val_collect['labels']) np.save(os.path.join(dirname, 'test_labels'), test_collect['labels']) if (val_auc >= best_val_auc) and training == 'training': best_val_auc = val_auc if Manager.train_args['RunPar']: torch.save(Manager.net.module.state_dict(), os.path.join(dirname, 'PRE1')) else: torch.save(Manager.net.state_dict(), os.path.join(dirname, 'PRE1')) """Print Stats""" print( '{} {:.4f} {:.4f} {:.4f} {:.4f} {:.4f} {:.4f} {:.4f} {:.4f} {:.1f}' .format(t, train_acc, val_acc, test_acc, train_loss, val_loss, test_loss, val_auc, test_auc, time.time() - tini)) if training == 'training': text_file.write( '{} {:.4f} {:.4f} {:.4f} {:.4f} {:.4f} {:.4f} {:.4f} {:.4f} {:.1f} \n' .format(t, train_acc, val_acc, test_acc, train_loss, val_loss, test_loss, val_auc, test_auc, time.time() - tini)) text_file.flush() return train_out, val_out, test_out
import random from fastFM.als import FMRegression from joblib import Parallel, delayed from sklearn.pipeline import make_union from util import create_basic_feature_extractor, create_BoW_feature_extractor, run_model def fm_predict(X_train, y_train, X_test): fm = FMRegression(init_stdev=0.0001, rank=128, l2_reg_w=20, l2_reg_V=400, n_iter=7, random_state=random.randint(0, 1000)) fm.fit(X_train, y_train) return fm.predict(X_test) def run_fm(train, test, y_train, num_models): feature_extractor = make_union(create_basic_feature_extractor(), create_BoW_feature_extractor()) X_train = feature_extractor.fit_transform(train) X_test = feature_extractor.transform(test) return Parallel(n_jobs=-1, max_nbytes=None)( delayed(fm_predict)(X_train, y_train, X_test) for _ in range(num_models) ) if __name__ == '__main__': run_model(model_runner=run_fm, model_name='FM')
def rnn_predict(keras_input_train, y_train, keras_input_test): model = build_rnn_model( basic_input_dim=keras_input_train['basic'].shape[1], vocabulary_size_name=keras_input_train['name'].max() + 1, vocabulary_size_desc=keras_input_train['item_description'].max() + 1) model.fit(keras_input_train, y_train, batch_size=1024, epochs=3, verbose=True) pred = model.predict(keras_input_test, batch_size=1024).ravel() del model gc.collect() K.clear_session() return pred def run_rnn(train, test, y_train, num_models): keras_input_train, keras_input_test = create_keras_input(train, test) return [ rnn_predict(keras_input_train, y_train, keras_input_test) for _ in range(num_models) ] if __name__ == '__main__': run_model(model_runner=run_rnn, model_name='RNN')
from sklearn.linear_model import Ridge from sklearn.pipeline import make_union from util import create_basic_feature_extractor, create_BoW_feature_extractor, run_model def lr_predict(X_train, y_train, X_test): ridge = Ridge(alpha=15.0, solver='sag', max_iter=100) ridge.fit(X_train, y_train) return ridge.predict(X_test) def run_lr(train, test, y_train, num_models): feature_extractor = make_union(create_basic_feature_extractor(), create_BoW_feature_extractor()) X_train = feature_extractor.fit_transform(train) X_test = feature_extractor.transform(test) return [lr_predict(X_train, y_train, X_test) for _ in range(num_models)] if __name__ == '__main__': run_model(model_runner=run_lr, model_name='LR')
x = Dense(64, activation='relu')(x) output = Dense(1)(x) model = keras.Model(model_input, output) model.compile(loss='mean_squared_error', optimizer=keras.optimizers.Adam(lr=3e-3)) return model def mlp_predict(X_train, y_train, X_test): model = build_mlp_model(input_dim=X_train.shape[1]) model.fit(X_train, y_train, batch_size=2048, epochs=3, verbose=True) pred = model.predict(X_test, batch_size=2048).ravel() del model gc.collect() K.clear_session() return pred def run_mlp(train, test, y_train, num_models): feature_extractor = make_union(create_basic_feature_extractor(), create_BoW_feature_extractor()) X_train = feature_extractor.fit_transform(train) X_test = feature_extractor.transform(test) return [mlp_predict(X_train, y_train, X_test) for _ in range(num_models)] if __name__ == '__main__': run_model(model_runner=run_mlp, model_name='MLP')
def cnn_predict(keras_input_train, y_train, keras_input_test): model = build_cnn_model( basic_input_dim=keras_input_train['basic'].shape[1], vocabulary_size_name=keras_input_train['name'].max() + 1, vocabulary_size_desc=keras_input_train['item_description'].max() + 1, ) model.fit(keras_input_train, y_train, batch_size=2048, epochs=3, verbose=True) pred = model.predict(keras_input_test, batch_size=2048).ravel() del model gc.collect() K.clear_session() return pred def run_cnn(train, test, y_train, num_models): keras_input_train, keras_input_test = create_keras_input(train, test) return [ cnn_predict(keras_input_train, y_train, keras_input_test) for _ in range(num_models) ] if __name__ == '__main__': run_model(model_runner=run_cnn, model_name='CNN')
print('\nThis is the mdoel training part') while True: print( 'Please input the NUMBER of these model options, if you want to finish running model, input #\n' ) print('1. SVM') print('2. Decision Tree') print('3. Logistic Regression') print('4. Xgboost') print('5. Random Forest') print('6. CNN') model_number = input() if model_number != '#': if model_number == '1': run_model('SVM', review, X, y) elif model_number == '2': run_model('DT', review, X, y) elif model_number == '3': run_model('LR', review, X, y) elif model_number == '4': print('this takes several hours') run_model('Xgboost', review, X, y) elif model_number == '5': run_model('RandomForest', review, X, y) elif model_number == '6':