def main(wav_file, score_file):
'''
first detect pitches
'''
mfshs = MFSHS(wav_file)
mfshs.pitch_detector()
pitches = mfshs.pitches
zero_amp_frame = mfshs.zeroAmploc
energes = mfshs.energes
score_note, note_type, pauseLoc = parse_musescore(
score_file) ## parse musescore
'''
second detect onset
'''
onset_frame = detector_onset(wav_file, pitches, score_note)
'''
sw alignment
'''
match_loc_info = sw_alignment(pitches, onset_frame, score_note)
'''
post process and save result
'''
onset_offset_pitches = trans_onset_and_offset(match_loc_info, onset_frame,
pitches)
filename_json = os.path.splitext(wav_file)[0] + ".json"
evaluator = Evaluator(filename_json, onset_offset_pitches, zero_amp_frame,
score_note, pauseLoc, note_type)
save_files(wav_file, onset_frame, pitches, evaluator.det_note, score_note)
'''
def main(wav_file, score_file):
# mfshs = MFSHS(wav_file)
# mfshs.pitch_detector()
# pitches = mfshs.pitches #è¿â€Ã¥â€ºÅ¾Ã©Å¸Â³Ã©Â«Ë?
# print(type(pitches),pitches)
# zero_amp_frame = mfshs.zeroAmploc #音高�索�
# print(type(zero_amp_frame),zero_amp_frame)
# pitches_filepath = "/home/ywm/MUSIC/new_solfege_pYIN/data/1011_pitch.txt"
# pitches = []
# with open(pitches_filepath,'r') as f:
# a = f.readlines()
# for i in a:
# pitches.append(float(i.split()[0]))
# pitches = np.array(pitches)
pitches = demo.pYIN(wav_file)
pitches = np.array(pitches) - 20
pitches = np.where((pitches < 0.0), 0, pitches)
#print(type(pitches),pitches)
zero_amp_frame = np.where(pitches == 0)[0]
score_note, note_types, pauseLoc = parse_musescore( #解æžÂjsonä¹Âè°±,è¿â€Ã¥â€ºÅ¾Ã¤Â¹Âè°±ä¸Âçš„note值和休æ¢符ä½ÂçÂ?
score_file) # parse musescore
predictor = predictor_onset()
onset_time = predictor.predict(wav_file)
#draw_array(predictor.onset_pred)
onset_frame = predictor.onset_frame
onset_frame = post_cnn_onset(pitches, onset_frame)
#print("onset_frame:",onset_frame)
match_loc_info = sw_alignment(pitches, onset_frame, score_note)
#print(2)
onset_offset_pitches = trans_onset_and_offset(match_loc_info, onset_frame,
pitches)
#print("onset_offset_pitches:",onset_offset_pitches)
filename_json = os.path.splitext(wav_file)[0] + ".json"
evaluator = Evaluator(filename_json, onset_offset_pitches, zero_amp_frame,
score_note, pauseLoc, note_types)
#print(4)
save_files(wav_file, onset_frame, pitches, evaluator.det_note, score_note,
onset_offset_pitches['onset_frame'])
#print(5)
return evaluator.score
def __init__(self):
self.U_input = [U1, U2, U3, U4] = sp.symbols("U1:5", real=True)
self.x_state = [
u_velocity,
v_velocity,
w_velocity,
p_angle,
q_angle,
r_angle,
fi_angle,
theta_angle,
si_angle,
xI,
yI,
zI,
a_flapping,
b_flapping,
c_flapping,
d_flapping,
] = sp.symbols("x1:17", real=True)
self.My_helicopter = Helicopter()
self.My_controller = Controller()
self.t = sp.symbols("t")
self.symbolic_states_math, jacobian = self.My_helicopter.lambd_eq_maker(self.t, self.x_state, self.U_input)
self.default_range = default_range = (-20, 20)
self.observation_space_domain = {
"u_velocity": default_range,
"v_velocity": default_range,
"w_velocity": default_range,
"p_angle": default_range,
"q_angle": default_range,
"r_angle": default_range,
"fi_angle": default_range,
"theta_angle": default_range,
"si_angle": default_range,
"xI": default_range,
"yI": default_range,
"zI": default_range,
"a_flapping": default_range,
"b_flapping": default_range,
"c_flapping": default_range,
"d_flapping": default_range,
}
self.low_obs_space = np.array(list(zip(*self.observation_space_domain.values()))[0], dtype=np.float32)
self.high_obs_space = np.array(list(zip(*self.observation_space_domain.values()))[1], dtype=np.float32)
self.observation_space = spaces.Box(low=self.low_obs_space, high=self.high_obs_space, dtype=np.float32)
self.default_act_range = default_act_range = (-0.3, 0.3)
self.action_space_domain = {
"deltacol": default_act_range,
"deltalat": default_act_range,
"deltalon": default_act_range,
"deltaped": default_act_range,
# "f1": (0.1, 5), "f2": (0.5, 20), "f3": (0.5, 20), "f4": (0.5, 10),
# "lambda1": (0.5, 10), "lambda2": (0.1, 5), "lambda3": (0.1, 5), "lambda4": (0.1, 5),
# "eta1": (0.2, 5), "eta2": (0.1, 5), "eta3": (0.1, 5), "eta4": (0.1, 5),
}
self.low_action_space = np.array(list(zip(*self.action_space_domain.values()))[0], dtype=np.float32)
self.high_action_space = np.array(list(zip(*self.action_space_domain.values()))[1], dtype=np.float32)
self.action_space = spaces.Box(low=self.low_action_space, high=self.high_action_space, dtype=np.float32)
self.min_reward = -13
self.t_start, self.dt, self.t_end = 0, 0.03, 2
self.no_timesteps = int((self.t_end - self.t_start) / self.dt)
self.all_t = np.linspace(self.t_start, self.t_end, self.no_timesteps)
self.counter = 0
self.best_reward = -100_000_000
self.longest_num_step = 0
self.reward_check_time = 0.7 * self.t_end
self.high_action_diff = 0.2
obs_header = str(list(self.observation_space_domain.keys()))[1:-1]
act_header = str(list(self.action_space_domain.keys()))[1:-1]
self.header = "time, " + act_header + ", " + obs_header + ", reward" + ", control reward"
self.saver = save_files()
self.reward_array = np.array((0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), dtype=np.float32)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--config_path', type=str, default='config.ini')
parser.add_argument('--resume')
parser.add_argument('--plot_samples', type=int, default=0)
args = parser.parse_args()
config = configparser.ConfigParser()
config.read(args.config_path, 'UTF-8')
chainer.global_config.autotune = True
chainer.cuda.set_max_workspace_size(11388608)
# create result dir and copy file
logger.info('> store file to result dir %s', config.get('result', 'dir'))
save_files(config.get('result', 'dir'))
logger.info('> set up devices')
devices = setup_devices(config.get('training_param', 'gpus'))
set_random_seed(devices, config.getint('training_param', 'seed'))
logger.info('> get dataset')
dataset_type = config.get('dataset', 'type')
if dataset_type == 'coco':
# force to set `use_cache = False`
train_set = get_coco_dataset(
insize=parse_size(config.get('model_param', 'insize')),
image_root=config.get(dataset_type, 'train_images'),
annotations=config.get(dataset_type, 'train_annotations'),
min_num_keypoints=config.getint(dataset_type, 'min_num_keypoints'),
use_cache=False,
do_augmentation=True,
)
test_set = get_coco_dataset(
insize=parse_size(config.get('model_param', 'insize')),
image_root=config.get(dataset_type, 'val_images'),
annotations=config.get(dataset_type, 'val_annotations'),
min_num_keypoints=config.getint(dataset_type, 'min_num_keypoints'),
use_cache=False,
)
elif dataset_type == 'mpii':
train_set, test_set = get_mpii_dataset(
insize=parse_size(config.get('model_param', 'insize')),
image_root=config.get(dataset_type, 'images'),
annotations=config.get(dataset_type, 'annotations'),
train_size=config.getfloat(dataset_type, 'train_size'),
min_num_keypoints=config.getint(dataset_type, 'min_num_keypoints'),
use_cache=config.getboolean(dataset_type, 'use_cache'),
seed=config.getint('training_param', 'seed'),
)
else:
raise Exception('Unknown dataset {}'.format(dataset_type))
logger.info('dataset type: %s', dataset_type)
logger.info('training images: %d', len(train_set))
logger.info('validation images: %d', len(test_set))
if args.plot_samples > 0:
for i in range(args.plot_samples):
data = train_set[i]
visualize.plot('train-{}.png'.format(i), data['image'],
data['keypoints'], data['bbox'], data['is_labeled'],
data['edges'])
data = test_set[i]
visualize.plot('val-{}.png'.format(i), data['image'],
data['keypoints'], data['bbox'], data['is_labeled'],
data['edges'])
logger.info('> load model')
model = create_model(config, train_set)
logger.info('> transform dataset')
train_set = TransformDataset(train_set, model.encode)
test_set = TransformDataset(test_set, model.encode)
logger.info('> create iterators')
train_iter = chainer.iterators.MultiprocessIterator(
train_set,
config.getint('training_param', 'batchsize'),
n_processes=config.getint('training_param', 'num_process'))
test_iter = chainer.iterators.SerialIterator(test_set,
config.getint(
'training_param',
'batchsize'),
repeat=False,
shuffle=False)
logger.info('> setup optimizer')
optimizer = chainer.optimizers.MomentumSGD()
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.0005))
logger.info('> setup trainer')
updater = training.updaters.ParallelUpdater(train_iter,
optimizer,
devices=devices)
trainer = training.Trainer(
updater, (config.getint('training_param', 'train_iter'), 'iteration'),
config.get('result', 'dir'))
logger.info('> setup extensions')
trainer.extend(extensions.LinearShift(
'lr',
value_range=(config.getfloat('training_param', 'learning_rate'), 0),
time_range=(0, config.getint('training_param', 'train_iter'))),
trigger=(1, 'iteration'))
trainer.extend(
extensions.Evaluator(test_iter, model, device=devices['main']))
if extensions.PlotReport.available():
trainer.extend(
extensions.PlotReport([
'main/loss',
'validation/main/loss',
],
'epoch',
file_name='loss.png'))
trainer.extend(extensions.LogReport())
trainer.extend(extensions.observe_lr())
trainer.extend(
extensions.PrintReport([
'epoch',
'elapsed_time',
'lr',
'main/loss',
'validation/main/loss',
'main/loss_resp',
'validation/main/loss_resp',
'main/loss_iou',
'validation/main/loss_iou',
'main/loss_coor',
'validation/main/loss_coor',
'main/loss_size',
'validation/main/loss_size',
'main/loss_limb',
'validation/main/loss_limb',
]))
trainer.extend(extensions.ProgressBar())
trainer.extend(
extensions.snapshot(filename='best_snapshot'),
trigger=training.triggers.MinValueTrigger('validation/main/loss'))
trainer.extend(
extensions.snapshot_object(model, filename='bestmodel.npz'),
trigger=training.triggers.MinValueTrigger('validation/main/loss'))
if args.resume:
serializers.load_npz(args.resume, trainer)
logger.info('> start training')
trainer.run()
optimizer = optim.Adam(model.parameters(), lr=lr)
max_frames = 1_000_000
frame_idx = 0
test_rewards = []
save_iteration = 1000
model_save_iteration = max_frames / 50
state = envs.reset()
early_stop = False
def trch_ft_device(input, device):
output = torch.FloatTensor(input).to(device)
return output
saver_model = save_files()
while frame_idx < max_frames and not early_stop:
log_probs = []
values = []
states = []
actions = []
rewards = []
masks = []
entropy = 0
for _ in range(num_steps):
state = trch_ft_device(state, device)
dist, value = model(state)