def main(args):
trainloader, testloader, num_classes = load_data(batch_size=args.batch_size)
net = ResNet18()
results = run_root(
net, args.batch_size, trainloader, testloader, n_epoch=args.n_epoch,
lr=args.learning_rate, weight_decay=0, checkpoint=125, noisy_train_stat=True)
save_results(*results, method='root_sgd')
def train(args):
config = Config(args)
train, test, word_to_id, id_to_word, embeddings = utils.load_from_file_basic(
)
config.word_to_id = word_to_id
config.id_to_word = id_to_word
utils.save(config.output_path, word_to_id, id_to_word)
handler = logging.FileHandler(config.log_output)
handler.setLevel(logging.DEBUG)
handler.setFormatter(
logging.Formatter('%(asctime)s:%(levelname)s: %(message)s'))
logging.getLogger().addHandler(handler)
with tf.Graph().as_default():
logger.info('Building model...', )
start = time.time()
model = RNNModel(config, embeddings)
logger.info('took %.2f seconds', time.time() - start)
init = tf.global_variables_initializer()
saver = tf.train.Saver()
with tf.Session() as session:
session.run(init)
model.fit(session, saver, train, test)
sentences, masks, predictions = model.output(session, train)
originals, predictions = lookup_words(predictions, sentences,
id_to_word)
output = zip(originals, masks, predictions)
with open('results.txt', 'w') as f:
utils.save_results(f, output)
def test(config):
load_dir = f'{config["save_dir"]}/weights/'
model_list = sorted(
list(map(lambda m: int(m.split('.')[0]), os.listdir(load_dir))))
if hr_test is None:
with open(f'{config["save_dir"]}/results.json') as f:
results = json.load(f)
start_from_epoch = list(
results["test_acc"]
)[-1] if results["test_acc"]['1'] is not None else 0
model_list = model_list[int(start_from_epoch):]
for epoch in model_list:
# print(epoch)
acc = 0
model = f'{load_dir}{epoch}.pth'
state_dict = torch.load(model)
config['network'].load_state_dict(state_dict)
config['network'].eval()
Y_batch, Predicted = [], []
with torch.no_grad():
for idx, (X_batch, y_batch) in enumerate(config['data_test']):
X_batch = X_batch.to(config['device']).view(
X_batch.shape[0], -1)
y_batch = y_batch.to(config['device'])
y_pred, _, _, _ = config['network'](X_batch)
predicted = torch.argmax(y_pred.data, 1)
acc += (predicted == y_batch).sum().item()
Y_batch += y_batch
Predicted += predicted
test_acc = 100 * acc / config['len_test']
# test_acc_per_epoch[str(epoch)] = test_acc
utils.save_results(config, None, test_acc, str(epoch), hr_test=hr_test)
print(f'epoch: {epoch} - test accuracy: {round(test_acc, 3):.3f}')
def run(result_csv_path):
train_x, train_y = load_data(train_csv_path, True)
test_x = load_data(test_csv_path, False)
print('load data successfully ......')
rf = RandomForestRegressor(
n_estimators=2000, #[1500,2000]
min_samples_split=2,
max_depth=15, # [10,15]
n_jobs=-1)
rf.fit(train_x, train_y)
###### save model ##################
joblib.dump(rf, 'weights/' + Model_Name + '.m')
y_pred = rf.predict(test_x)
####### save_results ###########################
save_results(result_csv_path, y_pred)
###### generate report #######################
feature_importances = rf.feature_importances_
dic_feature_importances = dict(zip(fields, feature_importances))
dic = sorted(dic_feature_importances.iteritems(),
key=lambda d: d[1],
reverse=True)
print('feature_importances:')
for i in range(len(dic)):
print(dic[i][0] + ":\t" + str(dic[i][1]))
def train(self, sess, epochs, train_dataset, validation_dataset, output_dir):
merged_summaries = tf.summary.merge_all()
train_writer = tf.summary.FileWriter(output_dir + '/train', sess.graph)
#train_writer = tf.train.SummaryWriter(output_dir + '/train', sess.graph)
train_metric = self.evaluate(sess, train_dataset)
validation_metric = self.evaluate(sess, validation_dataset)
train_results_file_path = os.path.join(output_dir, "train_result.csv")
plt.subplot(2, 1, 1)
plt.title('Training data set')
plt.axis([0, epochs, 0, train_metric[0]])
plt.subplot(2, 1, 2)
plt.title('Vaidation data set')
plt.axis([0, epochs, 0, validation_metric[0]])
plt.ion()
logger.info('Start Training')
steps_in_epoch = train_dataset.num_examples // self.batch_size
# self.get_g_structure(sess,train_dataset)
for epoch in xrange(0, epochs):
for i in xrange(0, steps_in_epoch):
feed_dict = self.fill_feed_dict(train_dataset, self.batch_size)
_= sess.run([self.train_op], feed_dict=feed_dict)
summ = sess.run(merged_summaries)
train_writer.add_summary(summ, epoch)
train_dataset.reset_epoch(permute=True)
sess.run([self.global_step_update_op])
if epoch % 10 == 0:
train_metric = self.evaluate(sess, train_dataset)
validation_metric = self.evaluate(sess, validation_dataset)
plt.subplot(2, 1, 1)
plt.scatter(epoch, train_metric[0], color='red', marker=".")
plt.scatter(epoch, train_metric[1], color='blue', marker=".")
plt.subplot(2, 1, 2)
plt.scatter(epoch, validation_metric[0], color='red', marker=".")
plt.scatter(epoch, validation_metric[1], color='blue', marker=".")
learning_rate = self.get_learning_rate(sess)
plt.pause(0.05)
logger.info(
"Epoch: {:}, Learning rate {:.8f} Train RMSE: {:.4f}, Train AAE: {:.4f} Validation RMSE {:.4f}, Validation AAE {:.4f}".
format(epoch, learning_rate[0], train_metric[0],
train_metric[1], validation_metric[0],
validation_metric[1],
precision=8))
save_results(train_results_file_path, train_dataset.labels, self.predict(sess, train_dataset))
logger.info('Training Finished')
def main(data_path="data/split/", feature_path="data/features/", out_path="data/pca/"):
X_train, X_test, y_train, y_test = read_data(data_path)
params = read_params("params.yaml", "pca")
pca = PCA(**params).fit(X_train)
train_feature = pd.DataFrame(pca.transform(X_train))
test_feature = pd.DataFrame(pca.transform(X_test))
train_feature["class"] = y_train
test_feature["class"] = y_test
if not os.path.isdir(feature_path):
os.mkdir(feature_path)
train_feature.to_csv(f"{feature_path}train.csv", index=False)
test_feature.to_csv(f"{feature_path}test.csv", index=False)
save_results(out_path, pca, None)
print(f"Finished Feature Engineering:\nStats:")
print(f"\tExplained Variance: {pca.explained_variance_}")
print(f"\tExplained Variance Ratio: {pca.explained_variance_ratio_}")
log_experiment(
out_path,
metrics=dict(
explained_variance_=pca.explained_variance_,
explained_variance_ratio_=pca.explained_variance_ratio_,
),
)
def main(_):
# for rm in [0.5, 0.6, 0.7, 0.8]:
# for ds_ind in range(5):
# config.data_rm = rm
# config.ds_ind = ds_ind
# Directory generating.. for saving
prepare_dirs(config)
prepare_config_date(config, config.ds_ind)
# Random seed settings
rng = np.random.RandomState(config.random_seed)
tf.set_random_seed(config.random_seed)
# Model training
trainer = Trainer(config, rng)
save_config(config.model_dir, config)
config.load_path = config.model_dir
if config.is_train:
trainer.train(save=True)
result_dict = trainer.test()
else:
if not config.load_path:
raise Exception("[!] You should specify `load_path` to "
"load a pretrained model")
result_dict = trainer.test()
save_results(config.result_dir, result_dict)
accept_rate = evaluate_result(result_dict, method='KS-test', alpha=0.1)
kl_div = evaluate_result(result_dict, method='KL')
wasser_dis = evaluate_result(result_dict, method='wasser')
sig_test = evaluate_result(result_dict, method='sig_test')
print("The accept rate of KS test is ", accept_rate)
print("The final KL div is ", kl_div)
print("The wasser distance is ", wasser_dis)
print("The AR of Sign Test is ", sig_test)
def run_dropout_experiment(model_dict, train_dict, out_dir):
np.random.seed(12345)
results = defaultdict(list)
model_dict['dropout'] = True
kernel_size = model_dict['kernel_size']
padding = model_dict['padding']
label = f'kernel={kernel_size}x{kernel_size}, pad={padding}'
model = ConvNet(**model_dict)
train_dict['callbacks'][1] = ModelDump(
output_dir=os.path.join(out_dir, label))
train_dict['callbacks'][2] = SaveBestModel(
output_dir=os.path.join(out_dir, label))
trainer = Trainer(model, **train_dict)
start_time = time()
trainer.train_loop()
time_period = (time() - start_time) / 60
log_data = trainer.logger.logging_data
results['model_dict'].append(model_dict)
results['train_dict'].append(train_dict)
results['time'].append(time_period)
results['label'].append(label)
results['log_data'].append(log_data)
calc_test_accuracy(model, test_data, train_dict)
save_results(out_dir, results_dict=results)
return results
def run_mlp_conv_compare_experiment(model_dict_conv, model_dict_mlp,
train_dict, out_dir, test_data):
np.random.seed(12345)
results = defaultdict(list)
for model, model_dict in [(MlpNet(**model_dict_mlp), model_dict_mlp),
(ConvNet(**model_dict_conv), model_dict_conv)]:
label = f'model={model.name}'
print(f'{label}')
train_dict['callbacks'][1] = ModelDump(
output_dir=os.path.join(out_dir, label))
train_dict['callbacks'][2] = SaveBestModel(
output_dir=os.path.join(out_dir, label))
trainer = Trainer(model, **train_dict)
start_time = time()
trainer.train_loop()
time_period = (time() - start_time) / 60
log_data = trainer.logger.logging_data
results['model_dict'].append(model_dict)
results['train_dict'].append(train_dict)
results['time'].append(time_period)
results['label'].append(label)
results['log_data'].append(log_data)
calc_test_accuracy(model, test_data, train_dict)
save_results(out_dir, results_dict=results)
return results
def run_experiment():
environment = 'CartPole-v0'
seed = 1
episodes = 500
returns = []
agent = UpsideDownAgent(environment)
for e in range(episodes):
for i in range(100):
agent.train_behaviour_function()
for i in range(15):
tmp_r = []
exploratory_commands = agent.sample_exploratory_commands(
) # Line 5 Algorithm 1
desired_return = exploratory_commands[0]
desired_horizon = exploratory_commands[1]
r = agent.generate_episode(environment, e, desired_return,
desired_horizon, False)
tmp_r.append(r)
print(np.mean(tmp_r))
returns.append(np.mean(tmp_r))
exploratory_commands = agent.sample_exploratory_commands()
agent.generate_episode(environment, 1, 200, 200, True)
utils.save_results(environment, 'upside_down_agent', seed, returns)
utils.save_trained_model(environment, seed, agent.behaviour_function)
def run_experiment(experiment_generator, out_dir, test_data):
np.random.seed(12345)
results = defaultdict(list)
for i, (model_dict, train_dict, exp_name,
value) in enumerate(experiment_generator()):
label = f'{exp_name}={value}'
print(f'{i}. {label}')
train_dict['callbacks'][1] = ModelDump(
output_dir=os.path.join(out_dir, label))
train_dict['callbacks'][2] = SaveBestModel(
output_dir=os.path.join(out_dir, label))
model = ConvNet(**model_dict)
trainer = Trainer(model, **train_dict)
start_time = time()
trainer.train_loop()
time_period = (time() - start_time) / 60
log_data = trainer.logger.logging_data
results['model_dict'].append(model_dict)
results['train_dict'].append(train_dict)
results['time'].append(time_period)
results['label'].append(label)
results['log_data'].append(log_data)
calc_test_accuracy(model, test_data, train_dict)
save_results(out_dir, results_dict=results)
return results
def main():
# loads a lot of default parser values from the 'parser' file
parser = get_parser()
# get args from parser as an object
args = parser.parse_args()
args.device = 'cuda' if args.cuda else 'cpu'
# initialize seeds
utils.init_seed(args.seed)
# print('loader stuff', args)
loader = Loader.IncrementalLoader(args, seed=args.seed)
# print('loader stuff after after', args)
n_inputs, n_outputs, n_tasks = loader.get_dataset_info()
# setup logging
# logging is from 'misc_utils.py' from 'utils' folder
timestamp = utils.get_date_time() # this line is redundant bcz log_dir already takes care of it
args.log_dir, args.tf_dir = utils.log_dir(args, timestamp) # stores args into "training_parameters.json"
# create the model neural net
model = Model.Net(n_inputs, n_outputs, n_tasks, args, innerlr=args.opt_lr, outerlr=args.alpha_init)
# make model cuda-ized if possible
model.net.to(args.device)
# for all the CL baselines
result_val_t, result_val_a, result_test_t, result_test_a, spent_time = life_experience(model, loader, args)
# save results in files or print on terminal
save_results(args, result_val_t, result_val_a, result_test_t, result_test_a, model, spent_time)
def main():
args = parser.parse_args()
model_path = args.model
dataset_size = args.size
batch_size = args.batch_size
backend_name = args.backend
print_freq = args.print_freq
# Load ONNX model
onnx_protobuf = onnx.load(model_path)
# Change batch size defined in model to value passed by user as argument
onnx_protobuf.graph.input[0].type.tensor_type.shape.dim[0].dim_value = batch_size
ng_model = import_onnx_model(onnx_protobuf)
model_batch, model_channels, model_height, model_width = ng_model.get_parameters()[0].shape
# Generate synthetic dataset filled with random values
dataset = generate_data(count=dataset_size,
batch_size=model_batch,
image_channels=model_channels,
image_height=model_height,
image_width=model_width)
dataset = [(img, 0) for img in dataset]
perf_metrics = evaluate(backend_name, ng_model, dataset, batch_size, print_freq)
save_results('results/', args.output_file, {key: val.data for key, val in perf_metrics.items()})
def evaluate(args):
config = Config(args)
train, test, word_to_id, id_to_word, embeddings = utils.load_from_file_basic(
)
config.word_to_id = word_to_id
config.id_to_word = id_to_word
with tf.Graph().as_default():
logger.info('Building model...', )
start = time.time()
model = RNNModel(config, embeddings)
logger.info('took %.2f seconds', time.time() - start)
init = tf.global_variables_initializer()
saver = tf.train.Saver()
with tf.Session() as session:
session.run(init)
saver.restore(session, model.config.model_path)
sentences, masks, predictions = model.output(session, train)
originals, predictions = lookup_words(predictions, sentences,
id_to_word)
output = zip(originals, masks, predictions)
with open('eval_results.txt', 'w') as f:
utils.save_results(f, output)
def run_agent_es(n_agents=50, n_generations=100, save=True):
"""
implmentation of the evolutionary strategy (ES) algorithm
:param n_agents: number of agent per generation
:param n_generations: number of generations
:param save: save weights and scores at the end of training
:return:
"""
n_weights = len(Agent().model.get_weights())
agents_weights = np.empty((n_generations, n_agents, n_weights),
dtype=np.ndarray)
scores = np.empty((n_generations, n_agents), dtype=float)
children = np.empty((n_generations, n_weights), dtype=np.ndarray)
# initialize agents
agents = [Agent() for _ in range(n_agents)]
for i in range(n_generations):
agents_weights[i] = np.array([a.model.get_weights() for a in agents],
dtype=np.ndarray)
for j, agent in enumerate(agents): # TODO parallelize
scores[i][j] = agent.run_agent()
child = crossover_function(agents, scores[i])
children[i] = np.array(child, dtype=np.ndarray).reshape(n_weights)
agents = generate_population(child, n_agents, agents, noise=0.1)
if save:
save_results(agents_weights, scores)
return agents_weights, scores, children
def evaluate_model(train, n_input, epochs, batch_size):
# fit model
model = build_model(train, n_input, epochs, batch_size)
# history is a list of weekly data
history = [x for x in train]
# walk-forward validation over each week
prediction = list()
for i in range(len(test)):
# predict the week
yhat_sequence = forecast_multichannel(model, history, n_input)
# store the predictions
prediction.append(yhat_sequence)
# get real observation and add to history for predicting the next week
history.append(test[i, :])
# evaluate predictions days for each week
# get array of predictions
prediction = np.array(prediction)
prediction = np.ravel(prediction)
# get array of actual values from test set
actual = test[:, :, 0].copy()
actual[actual == 0] = np.nanmean(actual)
actual = np.ravel(actual)
# print test parameters
print('Epochs: %d Batch Size: %d' % (epochs, batch_size))
# calaculate and print scores
scores = calculate_various_scores(actual, prediction)
# save prediction plot
save_prediction_plot(actual, prediction, epochs, batch_size)
# save results
result = [epochs, batch_size, scores, prediction]
save_results('temp/multichannel_gridsearch_summary.csv', result)
# clear keras model
K.clear_session()
def main(args):
# ensure directories are setup
dirs = [args.data_dir, args.ckpt_dir]
prepare_dirs(dirs)
# create base model
model = get_base_model()
# define params
params = {
# '0_dropout': ['uniform', 0.1, 0.5],
# '0_act': ['choice', ['relu', 'selu', 'elu', 'tanh', 'sigmoid']],
# '0_l2': ['log_uniform', 1e-1, 2],
# '2_act': ['choice', ['selu', 'elu', 'tanh', 'sigmoid']],
# '2_l1': ['log_uniform', 1e-1, 2],
'2_hidden': ['quniform', 512, 1000, 1],
'4_hidden': ['quniform', 128, 512, 1],
'all_act': ['choice', [[0], ['choice', ['selu', 'elu', 'tanh']]]],
'all_dropout': ['choice', [[0], ['uniform', 0.1, 0.5]]],
'all_batchnorm': ['choice', [0, 1]],
'all_l2': ['uniform', 1e-8, 1e-5],
'optim': ['choice', ["adam", "sgd"]],
'lr': ['uniform', 1e-3, 8e-3],
# 'batch_size': ['quniform', 32, 128, 1]
}
# instantiate hyperband object
hyperband = Hyperband(args, model, params)
# tune
results = hyperband.tune()
# dump results
save_results(results)
def get_org_repos(self, dept_org_dict, fields):
"""
takes in dept_org_dict: dict w/ department keys, github org values
return df with every repo for every org as an observation
"""
query = "https://api.github.com/orgs/{0}/repos?page={1}&per_page=100"
#turn result into df?
col_list = ["repo_name", "department"]
col_list.extend(fields)
result = pd.DataFrame(columns=col_list)
for department in dept_org_dict.keys():
for org in dept_org_dict[department]:
page_results = utils.iterate_pages(query, [
org,
])
try:
result = result.append(utils.format_observations(
page_results, department, fields),
ignore_index=True)
except Exception as e:
print(e)
print(f"broke at: {org}")
pass
utils.save_results(result, "dept_repo_df")
return result
def run():
te_x = load_data(TEST,False)
df_te = pd.read_csv(TEST,header=0)
te_predType_list = predict_type()
te_pred_list = []
for i in range(te_x.shape[0]):
cur_pred_type = te_predType_list[i]
if cur_pred_type == 0:
te_pred_list.append(0)
continue
income = str(df_te['INCOME'][i])
entertainment = str(df_te['ENTERTAINMENT'][i])
baby = str(df_te['BABY'][i])
shopclass = str(df_te['SHOPPING'][i])
key = income+" "+entertainment+" "+baby+" "+shopclass
lon = df_te['LON'][i]
lat = df_te['LAT'][i]
num_clusters = CLUSTER_DICT[key]
if num_clusters > 1:
cur_te_pred = run_cluster_model(key,lon,lat,te_x[i],num_clusters)
else:
cur_te_pred = run_simple_model(key,te_x[i])
te_pred_list.append(cur_te_pred)
print("te_idx:"+str(i))
print(str(len(te_pred_list)))
save_results(result_csv_path,te_pred_list)
def batch_request_data(params,
save_results_to_disk=True,
verbose=False):
results = dict()
while True:
print('Request n°{}'.format(params['current'] + 1))
result = request_data(params)
if len(result) == 0:
break
else:
for game in result:
app_id = game['id']
results[app_id] = game
params['current'] += 1
if verbose:
print(results)
if save_results_to_disk:
save_results(results=results)
return results
def execute(ii, args):
res = optimize.minimize(optimizerFunction,
[args["x1"], args["x2"], args["x3"], args["x4"]])
log("Result:", res.x)
save_results(OUTFOLDER, res.x, ii, arg_dict.get("file_data"))
log("Finished Program: ", os.getpid())
def main(data_path='data/split/',
feature_path='data/features/',
out_path='data/pca/'):
X_train, X_test, y_train, y_test = read_data(data_path)
params = read_params('params.yaml', 'pca')
pca = PCA(**params).fit(X_train)
train_feature = pd.DataFrame(pca.transform(X_train))
test_feature = pd.DataFrame(pca.transform(X_test))
train_feature['class'] = y_train
test_feature['class'] = y_test
if not os.path.isdir(feature_path):
os.mkdir(feature_path)
train_feature.to_csv(f'{feature_path}train.csv', index=False)
test_feature.to_csv(f'{feature_path}test.csv', index=False)
save_results(out_path, pca, None)
print(f'Finished Feature Engineering:\nStats:')
print(f'\tExplained Variance: {pca.explained_variance_}')
print(f'\tExplained Variance Ratio: {pca.explained_variance_ratio_}')
log_experiment(
out_path,
params=params,
metrics=dict(explained_variance_=pca.explained_variance_,
explained_variance_ratio_=pca.explained_variance_ratio_))
def eval(cfg, saved_model_path=SAVED_MODEL_PATH):
print('start to eval ! \n')
device = torch.device(
"cuda" if torch.cuda.is_available() else "cpu") # 检测gpu
env = gym.make('CartPole-v0').unwrapped # 可google为什么unwrapped gym，此处一般不需要
env.seed(1) # 设置env随机种子
n_states = env.observation_space.shape[0]
n_actions = env.action_space.n
agent = DQN(n_states=n_states,
n_actions=n_actions,
device="cpu",
gamma=cfg.gamma,
epsilon_start=cfg.epsilon_start,
epsilon_end=cfg.epsilon_end,
epsilon_decay=cfg.epsilon_decay,
policy_lr=cfg.policy_lr,
memory_capacity=cfg.memory_capacity,
batch_size=cfg.batch_size)
agent.load_model(saved_model_path + 'checkpoint.pth')
rewards = []
moving_average_rewards = []
ep_steps = []
log_dir = os.path.split(
os.path.abspath(__file__))[0] + "/logs/eval/" + SEQUENCE
writer = SummaryWriter(log_dir)
for i_episode in range(1, cfg.eval_eps + 1):
state = env.reset() # reset环境状态
ep_reward = 0
for i_step in range(1, cfg.eval_steps + 1):
action = agent.choose_action(state,
train=False) # 根据当前环境state选择action
next_state, reward, done, _ = env.step(action) # 更新环境参数
ep_reward += reward
state = next_state # 跳转到下一个状态
if done:
break
print('Episode:', i_episode, ' Reward: %i' % int(ep_reward),
'n_steps:', i_step, 'done: ', done)
ep_steps.append(i_step)
rewards.append(ep_reward)
# 计算滑动窗口的reward
if i_episode == 1:
moving_average_rewards.append(ep_reward)
else:
moving_average_rewards.append(0.9 * moving_average_rewards[-1] +
0.1 * ep_reward)
writer.add_scalars('rewards', {
'raw': rewards[-1],
'moving_average': moving_average_rewards[-1]
}, i_episode)
writer.add_scalar('steps_of_each_episode', ep_steps[-1], i_episode)
writer.close()
'''存储reward等相关结果'''
save_results(rewards,
moving_average_rewards,
ep_steps,
tag='eval',
result_path=RESULT_PATH)
print('Complete evaling！')
def run_scenario(scenario):
filename = scenario + ".txt"
data = get_data(filename)
print('Loaded data from: {}\nLength: {}'.format(filename,
len(data['mass'])))
#plot_sqrtdeltachisq(data, scenario)
save_results(data, scenario, save=False)
def test_save_results(self):
results = utils.load_results()
temp_file_name = utils.get_data_folder() + 'temp.json'
utils.save_results(results, file_name=temp_file_name)
temp = utils.load_results(file_name=temp_file_name)
self.assertEqual(results, temp)
def calc_image_similarity(args):
np.random.seed(0)
torch.manual_seed(0)
torch.cuda.manual_seed_all(0)
torch.backends.cudnn.deterministic = True
if args.dataset == "disjoint_mnist":
dataloaders = [
mnist_first5_train_loader(args.size),
mnist_last5_train_loader(args.size)
]
elif args.dataset == "mnist_cifar10":
dataloaders = [
mnist_train_loader(args.size),
cifar10_single_channel_train_loader(args.size)
]
elif args.dataset == "fmnist_kmnist":
dataloaders = [
fmnist_train_loader(args.size),
kmnist_train_loader(args.size)
]
print(f"\nDataset: {args.dataset}")
# Extract data from the first batch of both dataloaders
for batches in zip(*dataloaders):
images = []
for data, _ in batches:
images.append(data)
break
# Iterate and compare each pair of images
total_mse, total_ssim = [], []
for idx, (imageA, imageB) in enumerate(zip(*images)):
imageA, imageB = imageA.permute(1, 2, 0), imageB.permute(1, 2, 0)
m, s = compare_images(imageA.numpy(), imageB.numpy())
total_mse.append(m)
total_ssim.append(s)
if idx % args.log_interval == 0:
print(f"Calculating image {idx}...")
print(len(total_mse), len(total_ssim))
avg_mse, avg_ssim = np.mean(total_mse), np.mean(total_ssim)
print(f"Average MSE: {avg_mse} Average SSIM index: {avg_ssim}")
# Save the results in list
results = [{
"mse": avg_mse,
"ssim": avg_ssim,
}]
# Save all the results
if args.save_results:
save_results(
f"image_similarity_{args.dataset}",
results,
args.results_dir,
)
def __init__(self, built, connections_df, edge_labels,net_name):
if not built:
#node names to index the Series values
self.frm_nodename, self.to_nodename = edge_labels
self.net = self.build_network(connections_df)
utils.save_results(self.net, net_name)
else:
self.net = utils.load_results(net_name)
def train(cfg):
env, state_dim, n_actions = env_init()
device = torch.device(
"cuda" if torch.cuda.is_available() else "cpu") # 检测gpu
agent = PolicyGradient(state_dim, device=device, lr=cfg.policy_lr)
'''下面带pool都是存放的transition序列用于gradient'''
state_pool = [] # 存放每batch_size个episode的state序列
action_pool = []
reward_pool = []
''' 存储每个episode的reward用于绘图'''
rewards = []
moving_average_rewards = []
log_dir = os.path.split(
os.path.abspath(__file__))[0] + "/logs/train/" + SEQUENCE
writer = SummaryWriter(log_dir) # 使用tensorboard的writer
for i_episode in range(cfg.train_eps):
state = env.reset()
ep_reward = 0
for _ in count():
action = agent.choose_action(state) # 根据当前环境state选择action
next_state, reward, done, _ = env.step(action)
ep_reward += reward
if done:
reward = 0
state_pool.append(state)
action_pool.append(float(action))
reward_pool.append(reward)
state = next_state
if done:
print('Episode:', i_episode, ' Reward:', ep_reward)
break
if i_episode > 0 and i_episode % cfg.batch_size == 0:
agent.update(reward_pool, state_pool, action_pool)
state_pool = [] # 每个episode的state
action_pool = []
reward_pool = []
rewards.append(ep_reward)
if i_episode == 0:
moving_average_rewards.append(ep_reward)
else:
moving_average_rewards.append(0.9 * moving_average_rewards[-1] +
0.1 * ep_reward)
writer.add_scalars('rewards', {
'raw': rewards[-1],
'moving_average': moving_average_rewards[-1]
}, i_episode + 1)
writer.close()
print('Complete training！')
save_model(agent, model_path=SAVED_MODEL_PATH)
'''存储reward等相关结果'''
save_results(rewards,
moving_average_rewards,
tag='train',
result_path=RESULT_PATH)
plot(rewards)
plot(moving_average_rewards, ylabel='moving_average_rewards_train')
def run_experiment():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--approximator', type=str, default='neural_network')
parser.add_argument('--environment',
type=str,
default='PongDeterministic-v4')
parser.add_argument('--seed', type=int, default=1)
args = parser.parse_args()
approximator = args.approximator
environment = args.environment
seed = args.seed
episodes = 1500
returns = []
agent = UpsideDownAgent(environment, approximator)
for e in range(episodes):
print("Episode {}".format(e))
for i in range(100):
agent.train_behaviour_function()
print("Finished training B!")
for i in range(15):
tmp_r = []
exploratory_commands = agent.sample_exploratory_commands(
) # Line 5 Algorithm 1
desired_return = exploratory_commands[0]
desired_horizon = exploratory_commands[1]
r = agent.generate_episode(environment, e, desired_return,
desired_horizon, False)
tmp_r.append(r)
print(np.mean(tmp_r))
returns.append(np.mean(tmp_r))
exploratory_commands = agent.sample_exploratory_commands()
#agent.generate_episode(environment, 1, 200, 200, True)
utils.save_results(environment, approximator, seed, returns)
if approximator == 'neural_network':
utils.save_trained_model(environment, seed, agent.behaviour_function)
plt.plot(returns)
plt.show()
def main(_):
logger.info('Loading Models From {:}'.format(FLAGS.output_dir))
logp_col_name = FLAGS.logp_col if FLAGS.add_logp else None
test_dataset = DataSet(csv_file_path=FLAGS.test_file,
smile_col_name=FLAGS.smile_col,
target_col_name=FLAGS.target_col,
logp_col_name=logp_col_name,
contract_rings=FLAGS.contract_rings)
validation_dataset = DataSet(csv_file_path=FLAGS.validation_file,
smile_col_name=FLAGS.smile_col,
target_col_name=FLAGS.target_col,
logp_col_name=logp_col_name,
contract_rings=FLAGS.contract_rings)
validation_predictions = np.empty(
(len(FLAGS.model_names), validation_dataset.num_examples))
test_predictions_ = np.empty(
(len(FLAGS.model_names), test_dataset.num_examples))
for i in xrange(0, len(FLAGS.model_names)):
predictions = get_prediction_from_model(FLAGS.model_names[i],
FLAGS.model_params[i][0],
FLAGS.model_params[i][1],
FLAGS.model_params[i][2],
test_dataset,
validation_dataset)
validation_predictions[i, :] = predictions[0]
test_predictions_[i, :] = predictions[1]
ensemble_predictor = [
ensemble_prediction_rf_regression, ensemble_prediction_top_k,
ensemble_prediction_greedy
]
predictor_names = ["Random forest regression", "Top 10", "Greedy"]
for fun, name in zip(ensemble_predictor, predictor_names):
emsemble_preditions = fun(validation_dataset, validation_predictions,
test_predictions_)
prediction_metric = get_metric(emsemble_preditions,
test_dataset.labels)
logger.info("Method {:} RMSE: {:}, AAE: {:}, R: {:}".format(
name, prediction_metric[0], prediction_metric[1],
prediction_metric[2]))
final_prediction_path = os.path.join(FLAGS.output_dir,
"ensemble_test_prediction.csv")
save_results(final_prediction_path, test_dataset.labels,
emsemble_preditions)
logging.info(
"------------------------------DONE------------------------------")
logging.info("")
logging.info("")
def process(wav_file, outfile, csv_file=None, bpm=None, tol=0.35,
ssm_read_pk=False, read_pk=False, rho=2, is_ismir=False,
tonnetz=False, sonify=False):
"""Main process to find the patterns in a polyphonic audio file.
Parameters
----------
wav_file : str
Path to the wav file to be analyzed.
csv_file : str
Path to the csv containing the midi_score of the input audio file
(needed to produce a result that can be read for JKU dataset).
outfile : str
Path to file to save the results.
bpm : int
Beats per minute of the piece. If None, bpms are read from the JKU.
tol : float
Tolerance to find the segments in the SSM.
ssm_read_pk : bool
Whether to read the SSM from a pickle file.
read_pk : bool
Whether to read the segments from a pickle file.
rho : int
Positive integer to compute the score of the segments.
is_ismir : bool
Produce the plots that appear on the ISMIR paper.
tonnetz : bool
Whether to use Tonnetz or Chromas.
sonify : bool
Whether to sonify the patterns or not.
"""
# Get the correct bpm if needed
if bpm is None:
bpm = get_bpm(wav_file)
# Algorithm parameters
min_notes = 8
max_diff_notes = 4
h = bpm / 60. / 8. # Hop size /8 works better than /4, but it takes longer
# to process
# Obtain the Self Similarity Matrix
X = compute_ssm(wav_file, h, ssm_read_pk, is_ismir, tonnetz)
# Read CSV file
if csv_file is not None:
logging.info("Reading the CSV file for MIDI pitches...")
midi_score = utils.read_csv(csv_file)
patterns = []
csv_patterns = []
while patterns == [] or csv_patterns == []:
# Find the segments inside the self similarity matrix
logging.info("Finding segments in the self-similarity matrix...")
max_diff = int(max_diff_notes / float(h))
min_dur = int(np.ceil(min_notes / float(h)))
#print min_dur, min_notes, h, max_diff
if not read_pk:
segments = []
while segments == []:
logging.info("\ttrying tolerance %.2f" % tol)
segments = utils.find_segments(X, min_dur, th=tol, rho=rho)
tol -= 0.05
utils.write_cPickle(wav_file + "-audio.pk", segments)
else:
segments = utils.read_cPickle(wav_file + "-audio.pk")
# Obtain the patterns from the segments and split them if needed
logging.info("Obtaining the patterns from the segments...")
patterns = obtain_patterns(segments, max_diff)
# Decrease tolerance in case we couldn't find any patterns
tol -= 0.05
# Get the csv patterns if they exist
if csv_file is not None:
csv_patterns = patterns_to_csv(patterns, midi_score, h)
else:
csv_patterns = [0]
# Sonify patterns if needed
if sonify:
logging.info("Sonifying Patterns...")
utils.sonify_patterns(wav_file, patterns, h)
# Formatting csv patterns and save results
if csv_file is not None:
logging.info("Writting results into %s" % outfile)
utils.save_results(csv_patterns, outfile=outfile)
else:
# If not csv, just print the results on the screen
print_patterns(patterns, h)
if is_ismir:
ismir.plot_segments(X, segments)
# Alright, we're done :D
logging.info("Algorithm finished.")
temp2 = abs(preds2p[p] - 1)
if temp1 > temp2:
preds2[p] = preds2p[p]
#print np.mean(selectedPred)
else:
selectedPred = predictions_proba[zeroind]
#idxs = np.any(selectedPred != 0)
#selectedPred = selectedPred[idxs]
preds2[p] = np.min(selectedPred)
temp1 = abs(preds2[p] - 0)
temp2 = abs(preds2p[p] - 0)
if temp1 > temp2:
preds2[p] = preds2p[p]
#print preds2[p]
predTest = np.load('../data/predictedTest.dat')
print len(np.nonzero(predTest))
fpr, tpr, _ = metrics.roc_curve(predTest, preds2)
roc_auc = metrics.auc(fpr, tpr)
print "AUC : %f" % roc_auc
filename = raw_input("Enter name for submission file: ")
utils.save_results(preds2, "../sub/" + filename + ".csv")
print "Done..."
