def demo_configuration_space(neurons=create_feeding_snail(),
file_graph='fig/demo_graph',
file_hist='fig/demo_hist'):
inj_0 = {'ACH': 0, 'GLU': 0}
inj_1 = {'ACH': 0, 'GLU': 1}
inj_2 = {'ACH': 0, 'GLU': 1.5}
inj_3 = {'ACH': 0, 'GLU': 2}
inj_4 = {'ACH': 0, 'GLU': 2.5}
inj_5 = {'ACH': 0, 'GLU': 3}
graph_0 = conf.make_configuration_space(neurons, inj_0)
graph_1 = conf.make_configuration_space(neurons, inj_1)
graph_3 = conf.make_configuration_space(neurons, inj_3)
#print(graph.states)
#print(graph.transitions)
plt.plot_configuration_space(graph_0.states, graph_0.transitions,
file_graph + "_0")
plt.plot_configuration_space(graph_1.states, graph_1.transitions,
file_graph + "_1")
plt.plot_configuration_space(graph_3.states, graph_3.transitions,
file_graph + "_3")
#plt.plot_branches([graph.transitions[0].branch], 'snail_branches_0.gv')
#plt.plot_branches([graph.transitions[1].branch], 'snail_branches_1.gv')
#plt.plot_branches([graph.transitions[2].branch], 'snail_branches_2.gv')
injection = [inj_0] * 10 + [inj_1] * 11 + [inj_3] * 9
T = len(injection)
exp = nrn.Experiment("Test experiment", T, neurons, ['ACH', 'GLU'])
exp.injection = injection
hist, is_valid = nrn.generate_rhythm_recursive(exp)
print(len(hist))
print(is_valid)
#nrn.print_rhythm_ascii(hist)
plot_history(hist, file_hist)
def demo_recursive_activation():
neurons = create_hco()
start_activity = [
nrn.get_activities(neurons,
nrn._zeros_dict(nrn._list_transmitters(neurons)))
]
branches = nrn._recursive_activation(neurons,
start_activity,
order=[],
injection=[])
for b in branches:
print_branch(b)
exp = nrn.Experiment("Test experiment", 10, neurons, ['ACH', 'GLU'])
hist = nrn.generate_rhythm_recursive(exp)
plot_history(hist)
def demo_hco():
neurons = create_hco()
neurons[1].activity_levels = (0, 0.92, 2)
neurons[0].activity_levels = (0, 0.91, 2)
exp = nrn.Experiment("Test experiment", 10, neurons, ['ACH', 'GLU'])
hist = nrn.generate_rhythm(exp)
print("Half-center oscillator:")
nrn.print_rhythm_ascii(hist)
plot_history(hist)
neurons = create_hco()
injection = {'ACH': 0, 'GLU': 0}
graph = conf.make_configuration_space(neurons, injection)
print(graph.states)
print(graph.transitions)
plt.plot_configuration_space(graph.states, graph.transitions, 'fig/hco_no_inj.gv', \
transmitter_colors={'ach':'red', 'glu':'green'})
return neurons, graph
def demo_feeding_cpg():
duration = 20
T_INJ_ACH = 6
T_INJ_GLU = 13
exp = nrn.Experiment('Feeding CPG', duration, create_feeding_snail(),
['ach', 'glu'])
inj = [{'ach': 0, 'glu': 0}] * duration
#delta = {'ach':0, 'glu':0.15}
FIXED_INJ_ACH = 1
FIXED_INJ_GLU = 1
for i in range(T_INJ_ACH, T_INJ_GLU):
inj[i] = {'ach': FIXED_INJ_ACH, 'glu': 0}
for i in range(T_INJ_GLU, duration):
inj[i] = {'ach': 0, 'glu': FIXED_INJ_GLU}
exp.injection = inj
hist = nrn.generate_rhythm_recursive(exp)
plot_history(hist)
graph = conf.make_configuration_space(neurons, inj)
plt.plot_configuration_space(graph.states, graph.transitions, "fig/snail")
def main():
generations = 500
for use_pca in [True, False]:
for function_tuple in [(functions.FSphere, (-100, 100)),
(functions.FRastrigin, (-5, 5)),
(functions.FGrienwank, (-600, 600)),
(functions.FRosenbrock, (-100, 100))]:
start = timer()
return_dict = run(use_pca, function_tuple[0], function_tuple[1][0],
function_tuple[1][1], generations)
end = timer()
return_dict.update({"run_time": (end - start)})
filename = f"benchmark/{(function_tuple[0].__name__)}{'_pca' if use_pca else ''}"
with open(f"{filename}.pickle", 'wb') as handle:
pickle.dump(return_dict,
handle,
protocol=pickle.HIGHEST_PROTOCOL)
plot.plot_history(return_dict['history']['min_val'], generations,
f"{filename}")
os.system('shutdown -s -t 0')
def train(EPOCHS=1000):
model = _build_model()
model.summary()
history = model.fit(train_data,
train_labels,
batch_size=100,
epochs=EPOCHS,
validation_split=0.2,
verbose=0,
callbacks=[NetworkCallback(EPOCHS)])
hist = pd.DataFrame(history.history)
hist['epoch'] = history.epoch
print(hist.tail())
plot.plot_history(history)
loss, mae, mse = model.evaluate(test_data, test_labels, verbose=1)
print("Testing set Mean Abs Error: {:5.2f} Score".format(mae))
model.save('model.h5')
def main():
"""
code snippet to load the data and train a model
:return:
"""
data_directory = ""
x_train = np.load(os.path.join(data_directory, "x_train.npy"))
y_train = np.load(os.path.join(data_directory, "y_train.npy"))
x_valid = np.load(os.path.join(data_directory, "x_valid.npy"))
y_valid = np.load(os.path.join(data_directory, "y_valid.npy"))
####################################################################################################################
# do some pre processing
####################################################################################################################
# convert to grayscale if wanted (last dimension is the color channel)
####################################################################################################################
# build your model
####################################################################################################################
# in this example we use a simple linear model
model = create_model(x_train.shape[1:])
ret_values = get_config('batch_size', 'epochs')
history = model.fit(x_train, y_train, batch_size=ret_values['batch_size'],
epochs=ret_values['epochs'],
validation_data=(x_valid, y_valid),
verbose=1)
# save the model
now = datetime.now()
name_string = f"model_{now.timestamp()}"
model.save_weights(f"./models/{name_string}")
print("created and saved the model")
plot_history(history, f"{name_string}_curve")
plot_model(model, to_file=os.path.join('./plots', f'{name_string}_model.png'))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--arch',
default="model",
help='architecture (model_dir)')
parser.add_argument('--do_train', action='store_true')
parser.add_argument('--do_predict', action='store_true')
parser.add_argument('--do_plot', action='store_true')
parser.add_argument('--hidden_size', default=256, type=int)
parser.add_argument('--batch_size', default=256, type=int)
parser.add_argument('--max_epoch', default=10000, type=int)
parser.add_argument('--lr', default=1e-3, type=float)
parser.add_argument('--step_lr', default=0.5, type=float)
parser.add_argument('--cuda', default=0, type=int)
parser.add_argument('--ckpt',
type=int,
help='load pre-trained model epoch')
args = parser.parse_args()
if args.do_train:
dataset = pd.read_csv("../../data/train.csv")
dataset.drop("Id", axis=1, inplace=True)
train_set, valid_set = train_test_split(dataset,
test_size=0.1,
random_state=73)
feature_for_training = ["F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9"]
feature_for_prediction = ["F1"]
train = preprocess_samples(train_set, feature_for_training,
feature_for_prediction)
valid = preprocess_samples(valid_set, feature_for_training,
feature_for_prediction)
trainData = FeatureDataset(train)
validData = FeatureDataset(valid)
device = torch.device(
'cuda:%d' % args.cuda if torch.cuda.is_available() else 'cpu')
max_epoch = args.max_epoch
trainer = Trainer(device, trainData, validData, args)
for epoch in range(1, max_epoch + 1):
print('Epoch: {}'.format(epoch))
trainer.run_epoch(epoch, True)
trainer.run_epoch(epoch, False)
if args.do_predict:
dataset = pd.read_csv("../../data/test.csv")
dataset.drop("Id", axis=1, inplace=True)
feature_for_testing = ["F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9"]
test = preprocess_samples(dataset, feature_for_testing)
testData = FeatureDataset(test)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = SimpleNet(input_size=9,
output_size=12,
hidden_size=args.hidden_size)
model.load_state_dict(
torch.load('%s/model.pkl.%d' % (args.arch, args.ckpt)))
model.train(False)
model.to(device)
dataloader = DataLoader(dataset=testData,
batch_size=args.batch_size,
shuffle=False,
collate_fn=testData.collate_fn,
num_workers=4)
trange = tqdm(enumerate(dataloader),
total=len(dataloader),
desc='Predict')
prediction = []
for i, (ft, _, y) in trange:
b = ft.shape[0]
missing_ft = torch.zeros(b, 1)
all_ft = torch.cat([missing_ft, ft], dim=1)
o_labels, _ = model(all_ft.to(device))
o_labels = torch.argmax(o_labels, axis=1)
prediction.append(o_labels.to('cpu').numpy().tolist())
prediction = sum(prediction, [])
SubmitGenerator(prediction, "../../data/sampleSubmission.csv")
if args.do_plot:
plot_history("{file}/history.json".format(file=args.arch))
def train(model, network_input, network_output):
""" train the neural network """
filepath = "trained_models/weights-{epoch:02d}-{loss:.4f}.hdf5"
checkpoint = ModelCheckpoint(
filepath,
monitor='loss',
verbose=0,
save_best_only=True,
mode='min'
)
callbacks_list = [checkpoint]
history = model.fit(network_input, network_output, epochs=200, batch_size=64, callbacks=callbacks_list)
return history
if __name__ == '__main__':
# Pre processing of data
notes = get_notes()
n_vocab = len(set(notes))
# Data formation
network_input, network_output = prepare_sequences(notes, n_vocab)
# Model architecture
model = create_network(network_input, n_vocab)
# Treaining
history = train(model, network_input, network_output)
# Ploting
plot_history(history)
log_interval)
with open('./{}/record_history.pkl'.format(experiment_folder),
'wb') as pkl_file:
pickle.dump(record_history, pkl_file)
pkl_file.close()
torch.save(model.state_dict(), trained_weight_file)
else:
with open('./{}/record_history.pkl'.format(experiment_folder),
'rb') as pkl_file:
record_history = pickle.load(pkl_file)
pkl_file.close()
model.load_state_dict(torch.load(trained_weight_file))
plot_history(experiment_folder, record_history)
if embed_dim > 2:
train_embeddings_baseline, train_labels_baseline, train_all_images = extract_embeddings_high_dim(
train_loader, model, embed_dim)
val_embeddings_baseline, val_labels_baseline, val_all_images = extract_embeddings_high_dim(
test_loader, model, embed_dim)
else:
train_embeddings_baseline, train_labels_baseline = extract_embeddings(
train_loader, model)
val_embeddings_baseline, val_labels_baseline = extract_embeddings(
test_loader, model)
plot_embeddings(experiment_folder, 'train', train_embeddings_baseline,
train_labels_baseline)
plot_embeddings(experiment_folder, 'test', val_embeddings_baseline,
val_labels_baseline)
def main():
# Save parameters first for records
save_details()
# Load dataset
x_dataset, y_dataset = read_data(r"../customized_data/CE200",
LOAD_SONG_AMOUNT, SAMPLE_RATE, HOP_LENGTH,
MODEL_TARGET, PRED_MODE)
# Split loaded datasets into training and validating purpose
x_dataset_train = x_dataset[:int(len(x_dataset) * (1 - VALID_RATIO))]
y_dataset_train = y_dataset[:int(len(y_dataset) * (1 - VALID_RATIO))]
x_dataset_valid = x_dataset[int(len(x_dataset) * (1 - VALID_RATIO)):]
y_dataset_valid = y_dataset[int(len(y_dataset) * (1 - VALID_RATIO)):]
# Process datasets to data with input format
x_train, y_train = [], []
x_valid, y_valid = [], []
progress_bar = tqdm(range(len(x_dataset_train)),
desc="Processing train data",
total=len(x_dataset_train),
ascii=True)
# 'i' for song no.
for i in progress_bar:
# 'j' for frame no. in a song
for j in range(0,
len(x_dataset_train[i]) - BATCH_LEN + 1, DATASET_HOP):
x_train.append(x_dataset_train[i][j:j + BATCH_LEN])
y_train.append(y_dataset_train[i][j:j + BATCH_LEN])
progress_bar = tqdm(range(len(x_dataset_valid)),
desc="Processing valid data",
total=len(x_dataset_valid),
ascii=True)
for i in progress_bar:
for j in range(0,
len(x_dataset_valid[i]) - BATCH_LEN + 1, DATASET_HOP):
x_valid.append(x_dataset_valid[i][j:j + BATCH_LEN])
y_valid.append(y_dataset_valid[i][j:j + BATCH_LEN])
x_train = np.array(x_train)
y_train = np.array(y_train)
x_valid = np.array(x_valid)
y_valid = np.array(y_valid)
# Global variable 'loss_criterion' for both training and validating step
# Global variable 'optimizer', 'train_all_loss', 'train_mid_loss', 'train_all_acc' and 'train_mid_acc' for training step
# Global variable 'valid_all_loss', 'valid_mid_loss', 'valid_all_acc' and 'valid_mid_acc' for validating step
global loss_criterion, optimizer
global train_all_loss, train_mid_loss, train_all_acc, train_mid_acc
global valid_all_loss, valid_mid_loss, valid_all_acc, valid_mid_acc
if PRED_MODE == 'quality_bitmap':
loss_criterion = tf.keras.losses.MeanSquaredError(reduction='none')
else:
loss_criterion = tf.keras.losses.CategoricalCrossentropy(
reduction='none')
optimizer = tf.keras.optimizers.Adam(
CustomSchedule( # lr_schedule
initial_lr=INITIAL_LR,
warmup_steps=WARMUP_STEPS,
decay_steps=DECAY_STEPS,
decay_rate=DECAY_RATE,
min_lr=MIN_LR,
))
train_all_loss = tf.keras.metrics.Mean()
train_mid_loss = tf.keras.metrics.Mean()
train_all_acc = tf.keras.metrics.Mean()
train_mid_acc = tf.keras.metrics.Mean()
valid_all_loss = tf.keras.metrics.Mean()
valid_mid_loss = tf.keras.metrics.Mean()
valid_all_acc = tf.keras.metrics.Mean()
valid_mid_acc = tf.keras.metrics.Mean()
# Define the model & checkpoint
global model
model = MyModel(MODEL_TARGET, PRED_MODE, BATCH_LEN, DIM, DROPOUT, QKV_DIM,
N, NUM_HEADS, CONV_NUM, CONV_DIM)
ckpt = tf.train.Checkpoint(model=model, optimizer=optimizer)
min_all_loss_ckpt_manager = tf.train.CheckpointManager(
ckpt, f"{CKPT_DIR}/min_all_loss/", max_to_keep=1)
min_mid_loss_ckpt_manager = tf.train.CheckpointManager(
ckpt, f"{CKPT_DIR}/min_mid_loss/", max_to_keep=1)
max_all_acc_ckpt_manager = tf.train.CheckpointManager(
ckpt, f"{CKPT_DIR}/max_all_acc/", max_to_keep=1)
max_mid_acc_ckpt_manager = tf.train.CheckpointManager(
ckpt, f"{CKPT_DIR}/max_mid_acc/", max_to_keep=1)
# Average losses, accuracies and learning rate per epoch for plotting figures
avg_train_all_losses = []
avg_train_mid_losses = []
avg_train_all_accs = []
avg_train_mid_accs = []
avg_valid_all_losses = []
avg_valid_mid_losses = []
avg_valid_all_accs = []
avg_valid_mid_accs = []
learning_rates = []
print('')
for epoch in range(EPOCH):
# According to limited memory space (RAM),
# train the model based on part of data each epoch. (TRAIN_BATCH_LEN / total)
train_batches = []
random_train_idx = np.arange(len(x_train) - BATCH_SIZE)
np.random.shuffle(random_train_idx)
global TRAIN_BATCH_LEN
if TRAIN_BATCH_LEN is None: TRAIN_BATCH_LEN = len(random_train_idx)
else: random_train_idx = random_train_idx[:TRAIN_BATCH_LEN]
progress_bar = tqdm(
random_train_idx,
total=len(random_train_idx),
ascii=True,
desc=f"Sampling random train batches " +
f"({TRAIN_BATCH_LEN}/{len(x_train)-BATCH_SIZE}={TRAIN_BATCH_LEN/(len(x_train)-BATCH_SIZE)*100:.3f}%)"
)
for i in progress_bar:
train_batches.append(
(x_train[i:i + BATCH_SIZE], y_train[i:i + BATCH_SIZE]))
# According to limited memory space (RAM),
# validate the model based on part of data each epoch. (VALID_BATCH_LEN / total)
valid_batches = []
random_valid_idx = np.arange(len(x_valid) - BATCH_SIZE)
np.random.shuffle(random_valid_idx)
global VALID_BATCH_LEN
if VALID_BATCH_LEN is None or VALID_BATCH_LEN > len(random_valid_idx):
VALID_BATCH_LEN = len(random_valid_idx)
else:
random_valid_idx = random_valid_idx[:VALID_BATCH_LEN]
progress_bar = tqdm(
random_valid_idx,
total=len(random_valid_idx),
ascii=True,
desc=f"Sampling random valid batches " +
f"({VALID_BATCH_LEN}/{len(x_valid)-BATCH_SIZE}={VALID_BATCH_LEN/(len(x_valid)-BATCH_SIZE)*100:.3f}%)"
)
for i in progress_bar:
valid_batches.append(
(x_valid[i:i + BATCH_SIZE], y_valid[i:i + BATCH_SIZE]))
# Reset metrics
train_all_loss.reset_states()
train_mid_loss.reset_states()
train_all_acc.reset_states()
train_mid_acc.reset_states()
valid_all_loss.reset_states()
valid_mid_loss.reset_states()
valid_all_acc.reset_states()
valid_mid_acc.reset_states()
# Train model
print('')
print(f"EPOCH {epoch+1:2d}/{EPOCH} [TRAIN]:")
progress_bar = tqdm(enumerate(train_batches),
desc=f"{epoch+1:2d}/{EPOCH}",
total=len(train_batches),
ascii=True)
for (i, (x_input, y_real)) in progress_bar:
y_pred, attns_forward, attns_backward = train_step(x_input, y_real)
if MODEL_MODE == 'seq2seq':
progress_bar.set_description(
f"AL {train_all_loss.result():.4f} ML {train_mid_loss.result():.4f} "
+ # all loss & mid loss
f"AA {train_all_acc.result():.2f}% MA {train_mid_acc.result():.2f}% "
+ # all acc & mid acc
f"LR {optimizer._decayed_lr('float32').numpy():.6f}")
# f" | BATCH_LEN: {BATCH_LEN} | BATCH_SIZE: {BATCH_SIZE}")
else:
progress_bar.set_description(
f"{epoch+1:2d}/{EPOCH} TRAIN | " +
f"mid loss: {train_mid_loss.result():.4f} | " +
f"mid acc: {train_mid_acc.result():.2f}% | " +
f"lr: {optimizer._decayed_lr('float32').numpy():.10f}"
) # | ") # +
# f"BATCH_LEN: {BATCH_LEN} | BATCH_SIZE: {BATCH_SIZE}")
if MODEL_MODE == 'seq2seq':
avg_train_all_losses.append(train_all_loss.result())
avg_train_mid_losses.append(train_mid_loss.result())
if MODEL_MODE == 'seq2seq':
avg_train_all_accs.append(train_all_acc.result())
avg_train_mid_accs.append(train_mid_acc.result())
learning_rates.append(optimizer._decayed_lr('float32').numpy())
# Validate model
# os.system('cls')
# print('')
print(f"EPOCH {epoch+1:2d}/{EPOCH} [VALID]:")
progress_bar = tqdm(valid_batches,
desc=f"{epoch+1:2d}/{EPOCH}",
total=len(valid_batches),
ascii=True)
for (x_input, y_real) in progress_bar:
y_pred = valid_step(x_input, y_real)
if MODEL_MODE == 'seq2seq':
progress_bar.set_description(
f"AL {valid_all_loss.result():.4f} ML {valid_mid_loss.result():.4f} "
+ # all loss & mid loss
f"AA {valid_all_acc.result():.2f}% MA {valid_mid_acc.result():.2f}%"
) # all acc & mid acc
# f" | BATCH_LEN: {BATCH_LEN} | BATCH_SIZE: {BATCH_SIZE}")
else:
progress_bar.set_description(
f"{epoch+1:2d}/{EPOCH} VALID | " +
f"mid loss: {valid_mid_loss.result():.4f} | " +
f"mid acc: {valid_mid_acc.result():.2f}%") # | " +
# f"BATCH_LEN: {BATCH_LEN} | BATCH_SIZE: {BATCH_SIZE}")
if MODEL_MODE == 'seq2seq':
avg_valid_all_losses.append(valid_all_loss.result())
avg_valid_mid_losses.append(valid_mid_loss.result())
if MODEL_MODE == 'seq2seq':
avg_valid_all_accs.append(valid_all_acc.result())
avg_valid_mid_accs.append(valid_mid_acc.result())
# Save the model checkpoint if this is the best one (with minimum loss or maximum accuracy).
print('')
if MODEL_MODE == 'seq2seq' and valid_all_loss.result() <= min(
avg_valid_all_losses):
print("Minimum all loss: improved! Model saved.")
min_all_loss_ckpt_manager.save()
else:
print("Minimum all loss: did not improve, model not saved.")
if valid_mid_loss.result() <= min(avg_valid_mid_losses):
print("Minimum mid loss: improved! Model saved.")
min_mid_loss_ckpt_manager.save()
else:
print("Minimum mid loss: did not improve, model not saved.")
if MODEL_MODE == 'seq2seq' and valid_all_acc.result() >= max(
avg_valid_all_accs):
print("Maximum all acc : improved! Model saved.")
max_all_acc_ckpt_manager.save()
else:
print("Maximum all acc : did not improve, model not saved.")
if valid_mid_acc.result() >= max(avg_valid_mid_accs):
print("Maximum mid acc : improved! Model saved.")
max_mid_acc_ckpt_manager.save()
else:
print("Maximum mid acc : did not improve, model not saved.")
print('')
show_pred_and_truth(y_real, y_pred, PRED_MODE)
print("Plotting history figure... ", end='')
plot_history(
CKPT_DIR, {
'train_all_loss': avg_train_all_losses,
'train_mid_loss': avg_train_mid_losses,
'train_all_acc': avg_train_all_accs,
'train_mid_acc': avg_train_mid_accs,
'valid_all_loss': avg_valid_all_losses,
'valid_mid_loss': avg_valid_mid_losses,
'valid_all_acc': avg_valid_all_accs,
'valid_mid_acc': avg_valid_mid_accs,
'lr': learning_rates,
})
print("Done.")
print("Plotting attention figures... ", end='')
plot_attns(CKPT_DIR, attns_forward, attns_backward)
print("Done.\n")
return
avg_infection_rates[key] = avg_results[key][-1][2] / 1000
return avg_infection_rates
def sample_variance(sample):
return sum((sample - (sample / len(sample)))**2) / (len(sample) - 1)
def sample_average(sample):
return sum(sample) / len(sample)
def margin_of_error(sample, confidence=0.9):
var_sample = sample_variance(sample)
p_val = (1 - confidence) / 2
return (var_sample / len(sample))**0.5 * stats.t.isf(
p_val,
len(sample) - 1)
def load_90_results():
with open('90ec_100rep.p', 'rb') as f:
return pickle.load(f)
if __name__ == '__main__':
results_90 = load_90_results()
avg_results_90 = get_averaged_results(results_90)
for key in avg_results_90:
plot.plot_history(avg_results_90[key], str(key))
def run(dimension,
composition,
duration,
acceleration,
speed,
box_size,
infection_range,
probability,
efficacy,
save_name,
repeat=1,
show_graph=False,
autoexit=True):
assert infection_range <= box_size
sectors, rem = divmod(dimension, box_size)
assert rem == 0
if save_name:
target_dir = f'results/{save_name}'
if not os.path.exists(target_dir):
os.mkdir(target_dir)
clock = pygame.time.Clock()
screen = pygame.display.set_mode([dimension, dimension])
running = True
for t in range(repeat):
locations = logic.rand_loc(sum(composition), dimension)
person_state = []
for i, cnt in enumerate(composition):
person_state += [i] * cnt
person_state = np.asarray(person_state)
time_of_infection = np.zeros(len(locations))
prev_offsets = np.zeros((len(locations), 2))
history = [composition]
frame = 0
stop_sim = False
while running:
for event in pygame.event.get():
if event.type == QUIT:
running = False
if stop_sim:
continue
screen.fill(BLACK)
frame += 1
still_infected_filter = (person_state == 1) & (
frame - time_of_infection <= duration)
now_cured_filter = (person_state == 1) & (~still_infected_filter)
person_state += now_cured_filter
locations, prev_offsets = logic.rand_offset(
locations, prev_offsets, dimension, acceleration, speed)
for i, loc in enumerate(locations):
color = colors[person_state[i]]
pygame.draw.circle(screen, color, loc, radius)
infected = locations[person_state == 1]
infected_grid = logic.create_grid(infected, sectors, box_size)
for i, person in enumerate(locations):
if person_state[i] in (0, 3):
cnt = logic.radius_count(person, infected_grid, sectors,
box_size, infection_range)
spread = logic.spread(cnt, probability)
if spread:
if person_state[i] == 0 or random() > efficacy:
person_state[i] = 1
time_of_infection[i] = frame
current_composition = tuple(
np.count_nonzero(person_state == i) for i in range(4))
history.append(current_composition)
if history[-1][1] == 0:
if show_graph:
plot_history(history)
if save_name:
with open(f'results/{save_name}/{t}.p', 'wb') as f:
pickle.dump(history, f)
if not autoexit and t == repeat - 1:
stop_sim = True
else:
break
clock.tick(fps)
show_fps(screen, dimension, clock, font1)
runinfo = save_name + '_' + str(t)
show_runinfo(screen, runinfo, font2)
show_composition(screen, dimension, current_composition, font2)
pygame.display.update()
if not running:
break
async def run(self):
"""Run application."""
_LOGGER.debug("Starting application.")
plt.figure(figsize=(30, 30))
model = lmb.CV(0.9, 1.5)
sensor = lmb.PositionSensor()
sensor.lambdaB = 2
sensor.pD = 0.8
targets = [
np.array([0.0, 0.0, 1, 0.5]),
np.array([0.0, 10.0, 1, -0.5]),
]
ntargets_true = []
ntargets_verified = []
ntargets = []
plt.subplot(3, 1, 1)
history = []
origin = np.array([58.3887657, 15.6965082])
pre_enof_targets = 0
ospa, gospa = [], []
last_time = 0
for k in range(30):
# print()
print("k:", k)
if k > 0:
sensor.lambdaB = 0.2
await self.predict(model, k, last_time)
tracker_targets = await self.get_targets()
# print("Predicted: ", tracker_targets)
for target in targets:
target[0:2] += target[2:]
# if k == 5:
# targets.append(np.array([5.0, 5.0, 1.0, 0.0]))
if k % 7 == 0:
targets.append(np.random.multivariate_normal(
np.array([k, 7.0, 0.0, 0.0]),
np.diag([1, 0.5, 1, 1])))
if k % 9 == 1:
del targets[-1]
if k == 10:
targets.append(np.array([k, -30.0, 1.0, -0.5]))
# if k == 20:
# targets.append(np.array([k, 0.0, 1.0, 4.0]))
reports = [lmb.GaussianReport(
# np.random.multivariate_normal(t[0:2], np.diag([0.01] * 2)), # noqa
cf.ne2ll(t[0:2, np.newaxis], origin),
np.eye(2) * 0.1, 0.01)
for i, t in enumerate(targets)]
sensor.lambdaB = max(0.2 * (len(reports) - pre_enof_targets), 0.01 * len(reports))
await self.correct(sensor, reports, k)
tracker_targets = await self.get_targets()
history.append((k, tracker_targets))
pre_enof_targets = await self.enof_targets()
ntargets.append(pre_enof_targets)
ntargets_verified.append(await self.nof_targets(0.7))
ntargets_true.append(len(targets))
ll_targets = [np.concatenate((cf.ne2ll(t[0:2], origin), t[2:])) for t in targets]
ospa.append(self.tracker.ospa(ll_targets, 1, 2))
gospa.append(self.tracker.gospa(ll_targets, 1, 1))
plot.plot_scan(reports, origin)
plt.plot([t[0] for t in targets],
[t[1] for t in targets],
marker='D', color='y', alpha=.5, linestyle='None')
print("Nof clusters: ", self.tracker.nof_clusters)
plot.plot_history(history, origin, covellipse=False, min_r=0.7)
plt.xlim([-1, k + 3])
plt.ylabel('Tracks')
plt.subplot(3, 1, 2)
plt.plot(ntargets, label='Estimate')
plt.plot(ntargets_true, label='True')
plt.plot(ntargets_verified, label='Verified', marker='*')
plt.ylabel('# Targets')
plt.legend(fancybox=True, framealpha=0.5, loc=4, prop={'size': 10})
plt.xlim([-1, k + 3])
plt.subplot(3, 1, 3)
plt.plot(ospa, label="OSPA")
plt.plot(gospa, label="GOSPA")
plt.legend()
plt.xlim([-1, k + 3])
if new_model:
earlyStopping = EarlyStopping(monitor='val_loss',
patience=20,
verbose=0,
mode='min')
mcp_save = ModelCheckpoint(path,
save_best_only=True,
monitor='val_loss',
mode='min')
model = create_network()
final_model = model.fit(x_train,
y_train,
epochs=epochs,
verbose=0,
callbacks=[earlyStopping, mcp_save],
validation_data=(x_val, y_val))
stopped_epoch = earlyStopping.stopped_epoch if earlyStopping.stopped_epoch != 0 else epochs
print(f'Stopped epoch: {stopped_epoch}')
plot_history(final_model, f'{configuration}')
scores = model.evaluate(x_test, y_test, verbose=0)
print(f'Mean accuracy %: {100 * scores[1]}')
else:
model = load_model(path)
new_scores = model.evaluate(x_test, y_test, verbose=0)
print(f'Mean accuracy %: {100 * new_scores[1]}')
def driver(yaml_path):
"""Runs the cropping, verifying, training or testing functions based on the configuration provided.
Args:
yaml_path (str): The filepath that contains all the configurations needed.
"""
if not yaml_path.endswith('.yml'):
print("Unexpected input detected. Proper usage:\"python main.py CONFIG_NAME.yml\"")
return
print(yaml_path)
config_loaded = False
if is_assume_config_folder:
yaml_path = config_folder + yaml_path
if os.path.isfile(yaml_path):
with open(yaml_path, 'r') as stream:
try:
configs = yaml.safe_load(stream)
config_loaded = True
except yaml.YAMLError as exc:
print(exc)
else:
print(f"{yaml_path} not found.")
if config_loaded:
is_valid_configs = config_checker.check(configs)
if is_valid_configs:
filepaths = configs['filepaths']
data_types = ['train', 'val', 'test']
data_paths = filepaths['data_paths']
cropped_paths = filepaths['cropped_paths']
instance_paths = filepaths['instances_paths']
verify_progress_paths = filepaths['verify_progress_paths']
print(f"data_paths:{data_paths}")
print(f"cropped_paths:{cropped_paths}")
print(f"instance_paths:{instance_paths}")
print(f"verify_progress_paths:{verify_progress_paths}")
for each in data_types:
if cropped_paths[each] != None:
make_if_not_exist(cropped_paths[each])
if configs['mode'] == "crop":
selected_type = configs['crop_options']['dataset_choice']
if selected_type in data_types:
image_preprocessor.crop_images_driver(instance_paths[selected_type], data_paths[selected_type], cropped_paths[selected_type])
print(f"{selected_type} Image cropping complete.")
elif selected_type == "all":
for each in data_types:
image_preprocessor.crop_images_driver(instance_paths[each], data_paths[each], cropped_paths[each])
print(f"{each} Image cropping complete.")
else:
print("Unexpected error in configs['crop_options']['dataset_choice'], this should have been caught by config_checker!")
elif configs['mode'] == "verify":
selected_type = configs['verify_options']['dataset_choice']
if selected_type in data_types:
image_preprocessor.file_num_compare(instance_paths[selected_type], data_paths[selected_type], cropped_paths[selected_type], selected_type,
configs['verify_options']['remove_extra'], configs['verify_options']['crop_missing'])
elif selected_type == "all":
for each in data_types:
image_preprocessor.file_num_compare(instance_paths[each], data_paths[each], cropped_paths[each], each,
configs['verify_options']['remove_extra'], configs['verify_options']['crop_missing'])
else:
print("Unexpected error in configs['verify_options']['dataset_choice'], this should have been caught by config_checker!")
if selected_type in data_types:
image_preprocessor.verify_jpg_driver(instance_paths[selected_type], data_paths[selected_type],
cropped_paths[selected_type], verify_progress_paths[selected_type],
configs['verify_options']['reset_progress'], configs['verify_options']['verify_save_step'])
print(f"{selected_type} Verification complete.")
elif selected_type == "all":
for each in data_types:
image_preprocessor.verify_jpg_driver(instance_paths[each], data_paths[each],
cropped_paths[each], verify_progress_paths[each],
configs['verify_options']['reset_progress'], configs['verify_options']['verify_save_step'])
print(f"{each} Verification complete.")
else:
print("Unexpected error in configs['verify_options']['dataset_choice'], this should have been caught by config_checker!")
elif configs['mode'] == "train":
make_if_not_exist(filepaths['models_path'])
train_test_options = configs['train_test_options']
make_if_not_exist(filepaths['models_path'] + train_test_options['model_name'])
train.train_driver(train_test_options['model_name'], train_test_options['pretrained'], train_test_options['load_choice'],
filepaths['models_path'], cropped_paths['train'], cropped_paths['val'], train_test_options['num_epochs'],
train_test_options['batch_size'], train_test_options['image_size'],
train_test_options['num_workers'], train_test_options['use_num_worker_mult'])
elif configs['mode'] == "test":
train_test_options = configs['train_test_options']
test.test_driver(train_test_options['model_name'], train_test_options['load_choice'],
filepaths['models_path'], cropped_paths['test'],
train_test_options['batch_size'], train_test_options['image_size'],
train_test_options['num_workers'], train_test_options['use_num_worker_mult'])
elif configs['mode'] == "plot":
train_test_options = configs['train_test_options']
plot.plot_history(train_test_options['model_name'], filepaths['models_path'])
else:
print("Unexpected error in configs['mode'], this should have been caught by config_checker!")
last_run = None
for l in logs:
run_id, results = parse.parse_run(
os.path.join(result_repo_vm_root, plan, l))
runs[run_id] = results
last_run = run_id
# figure out what benchmarks we should plot in the graph. We use the benchmarks that appeared in the last run
benchmarks = [r['benchmark'] for r in runs[last_run]]
print("Plan: %s" % plan)
print("Runs: %s" % runs)
print("Last run: %s" % last_run)
print("Benchmarks: %s" % benchmarks)
# figure out the baseline and get the result for the baseline
plan_config = parse.get_config_for_plan(config, plan)
assert plan_config != None, "Cannot get config for plan"
baseline_builds = plan_config['baseline']
print("Baseline: %s" % baseline_builds)
baseline = plot.calculate_baseline(baseline_results, baseline_builds,
"execution_times")
pp.pprint(baseline)
# plot
fig = plot.plot_history(runs, plan, benchmarks, from_date, to_date,
"execution_times", baseline)
path = os.path.join(output_dir, "%s_%s_history.html" % (prefix, plan))
fig.write_html(path)
