def __init__(self, cfg): self.cfg = cfg train_dataset = getDataSet(cfg['data']['train'], 'train', cfg['data']['scale']) self.train_loader = DataLoader( train_dataset, cfg['data']['train']['batch_size'], shuffle=True, num_workers=cfg['data']['train']['n_workers']) val_dataset = getDataSet(cfg['data']['val'], 'val', cfg['data']['scale']) self.val_loader = DataLoader( val_dataset, 1, shuffle=False, num_workers=cfg['data']['val']['n_workers']) self.records = {'Epoch': [], 'PSNR': [], 'SSIM': []} self.log_dir = os.path.join( cfg['output_dir'], cfg['name'], time.strftime('%Y-%m-%d-%H:%M:%S', time.localtime(time.time()))) self.logger = utils.Logger(os.path.join(self.log_dir, 'info.log')) self.max_epochs = cfg['schedule']['num_epochs'] self.checkpoint_dir = os.path.join(self.log_dir, 'checkpoint') if not os.path.exists(self.checkpoint_dir): os.makedirs(self.checkpoint_dir) self.epoch = 1 save_config(cfg, os.path.join(self.log_dir, 'config.yml')) self.logger.log('Train dataset has {} images and {} batches.'.format( len(train_dataset), len(self.train_loader))) self.logger.log('Val dataset has {} images and {} batches.'.format( len(val_dataset), len(self.val_loader)))
def main(args): # make the export folder structure # this is made here because the Logger uses the filename if args.do_save: # make a base save directory utils.make_dir(args.save_dir) # make a directory in the base save directory with for the specific # method. save_subdir = os.path.join(args.save_dir, args.dataset + "_" + args.sampling_method) utils.make_dir(save_subdir) filename = os.path.join( save_subdir, "log-" + strftime("%Y-%m-%d-%H-%M-%S", gmtime()) + ".txt") sys.stdout = utils.Logger(filename) # confusion argument can have multiple values confusions = [float(t) for t in args.confusions.split(" ")] mixtures = [float(t) for t in args.active_sampling_percentage.split(" ")] max_dataset_size = None if args.max_dataset_size == 0 else args.max_dataset_size starting_seed = args.seed # get the dataset from file based on the data directory and dataset name X, y = utils.get_mldata(args.data_dir, args.dataset) # object to store the results in all_results = {} # percentage of labels to randomize for c in confusions: # Mixture weights on active sampling." for m in mixtures: # the number of curves created during multiple trials for seed in range(starting_seed, starting_seed + args.trials): # get the sampler based on the name # returns a python object # also named: query strategy sampler = get_AL_sampler(args.sampling_method) # get the model score_model = utils.get_model(args.score_method, seed) # if (args.select_method == "None" or args.select_method == args.score_method): select_model = None else: select_model = utils.get_model(args.select_method, seed) # create the learning curve results, sampler_state = generate_one_curve( X, y, sampler, score_model, seed, args.warmstart_size, args.batch_size, select_model, confusion=c, active_p=m, max_points=max_dataset_size, standardize_data=args.standardize_data, norm_data=args.normalize_data, train_horizon=args.train_horizon) key = (args.dataset, args.sampling_method, args.score_method, args.select_method, m, args.warmstart_size, args.batch_size, c, args.standardize_data, args.normalize_data, seed) sampler_output = sampler_state.to_dict() results["sampler_output"] = sampler_output all_results[key] = results # Not sure why this is done in a qay like this. fields = [ "dataset", "sampler", "score_method", "select_method", "active percentage", "warmstart size", "batch size", "confusion", "standardize", "normalize", "seed" ] all_results["tuple_keys"] = fields # write the results to a file if args.do_save: # format the filename filename = "results_score_{}_select_{}_norm_{}_stand_{}".format( args.score_method, args.select_method, args.normalize_data, args.standardize_data) existing_files = gfile.Glob( os.path.join(save_subdir, "{}*.pkl".format(filename))) filepath = os.path.join( save_subdir, "{}_{}.pkl".format(filename, 1000 + len(existing_files))[1:]) # dump the dict to a pickle file pickle.dump(all_results, gfile.GFile(filepath, "w")) # flush stfout sys.stdout.flush_file()
""" As implemented in https://github.com/abewley/sort but with some modifications """ from __future__ import print_function import utils.utils as utils import numpy as np from correlation_tracker import CorrelationTracker from data_association import associate_detections_to_trackers from kalman_tracker import KalmanBoxTracker from kalman_tracker import convert_x_to_bbox logger = utils.Logger("MOT") class Sort: def __init__(self, max_age=1, min_hits=3, use_dlib=False): """ Sets key parameters for SORT """ self.max_age = max_age self.min_hits = min_hits self.trackers = [] self.frame_count = 0 self.use_dlib = use_dlib def update(self, dets,
def main(argv): del argv if not gfile.Exists(FLAGS.save_dir): try: gfile.MkDir(FLAGS.save_dir) except: print(('WARNING: error creating save directory, ')) save_dir = os.path.join(FLAGS.save_dir, FLAGS.dataset + '_' + FLAGS.sampling_method) if FLAGS.do_save == "True": if not gfile.Exists(save_dir): try: gfile.MkDir(save_dir) except: print(('WARNING: error creating save directory, ' 'directory most likely already created.')) # Set up logging filename = os.path.join( save_dir, "log-" + strftime("%Y-%m-%d-%H-%M-%S", gmtime()) + ".txt") sys.stdout = utils.Logger(filename) X, y = utils.get_mldata(FLAGS.data_dir, FLAGS.dataset) #load dataset! starting_seed = FLAGS.seed all_results = {} for seed in range(starting_seed, starting_seed + FLAGS.trials): sampler = get_AL_sampler(FLAGS.sampling_method) #load sampler! score_model = utils.get_model(FLAGS.score_method, seed) #load score model! if (FLAGS.select_method == "None" or #load select model! FLAGS.select_method == FLAGS.score_method): select_model = None else: select_model = utils.get_model(FLAGS.select_method, seed) results, sampler_state = \ generate_one_curve(X=X, y=y, sampler=sampler, score_model=score_model, seed=seed, warmstart_size=FLAGS.warmstart_size, batch_size=FLAGS.batch_size, select_model=select_model, max_points=FLAGS.max_dataset_size) key = (FLAGS.dataset, FLAGS.sampling_method, FLAGS.score_method, FLAGS.select_method, FLAGS.warmstart_size, FLAGS.batch_size, seed) #sampler_output = sampler_state.to_dict() #results['sampler_output'] = sampler_output results['sampler_output'] = None all_results[key] = results fields = [ 'dataset', 'sampling_methods', 'score_method', 'select_method', 'warmstart size', 'batch size', 'seed' ] all_results['tuple_keys'] = fields if FLAGS.do_save == "True": filename = ("results_score_" + FLAGS.score_method + "_select_" + FLAGS.select_method) existing_files = gfile.Glob(os.path.join(save_dir, filename + "*.pkl")) filename = os.path.join( save_dir, filename + "_" + str(1000 + len(existing_files))[1:] + ".pkl") pickle.dump(all_results, gfile.GFile(filename, "w")) sys.stdout.flush_file()
def main(argv): del argv if not gfile.Exists(FLAGS.save_dir): try: gfile.MkDir(FLAGS.save_dir) except: print(('WARNING: error creating save directory, ' 'directory most likely already created.')) save_dir = os.path.join( FLAGS.save_dir, FLAGS.dataset + "_" + FLAGS.sampling_method) do_save = FLAGS.do_save == "True" if do_save: if not gfile.Exists(save_dir): try: gfile.MkDir(save_dir) except: print(('WARNING: error creating save directory, ' 'directory most likely already created.')) # Set up logging filename = os.path.join( save_dir, "log-" + strftime("%Y-%m-%d-%H-%M-%S", gmtime()) + ".txt") sys.stdout = utils.Logger(filename) confusions = [float(t) for t in FLAGS.confusions.split(" ")] mixtures = [float(t) for t in FLAGS.active_sampling_percentage.split(" ")] all_results = {} max_dataset_size = None if FLAGS.max_dataset_size == "0" else int( FLAGS.max_dataset_size) normalize_data = FLAGS.normalize_data == "True" standardize_data = FLAGS.standardize_data == "True" X, y = utils.get_mldata(FLAGS.data_dir, FLAGS.dataset) starting_seed = FLAGS.seed for c in confusions: for m in mixtures: for seed in range(starting_seed, starting_seed + FLAGS.trials): sampler = get_AL_sampler(FLAGS.sampling_method) score_model = utils.get_model(FLAGS.score_method, seed) if (FLAGS.select_method == "None" or FLAGS.select_method == FLAGS.score_method): select_model = None else: select_model = utils.get_model(FLAGS.select_method, seed) results, sampler_state = generate_one_curve( X, y, sampler, score_model, seed, FLAGS.warmstart_size, FLAGS.batch_size, select_model, c, m, max_dataset_size, standardize_data, normalize_data, FLAGS.train_horizon) key = (FLAGS.dataset, FLAGS.sampling_method, FLAGS.score_method, FLAGS.select_method, m, FLAGS.warmstart_size, FLAGS.batch_size, c, standardize_data, normalize_data, seed) sampler_output = sampler_state.to_dict() results["sampler_output"] = sampler_output all_results[key] = results fields = [ "dataset", "sampler", "score_method", "select_method", "active percentage", "warmstart size", "batch size", "confusion", "standardize", "normalize", "seed" ] all_results["tuple_keys"] = fields if do_save: filename = ("results_score_" + FLAGS.score_method + "_select_" + FLAGS.select_method + "_norm_" + str(normalize_data) + "_stand_" + str(standardize_data)) existing_files = gfile.Glob(os.path.join(save_dir, filename + "*.pkl")) filename = os.path.join(save_dir, filename + "_" + str(1000+len(existing_files))[1:] + ".pkl") pickle.dump(all_results, gfile.GFile(filename, "w")) sys.stdout.flush_file()
from sklearn import preprocessing from sklearn.cross_validation import train_test_split tf.app.flags.DEFINE_string("MY_DATASETSLIB_HOME", "../my_datasets", "数据集的名称,与MY_DATASETSLIB_HOME中的子文件夹相对应") tf.app.flags.DEFINE_string("dataset", "casiadatabase", "数据集的名称,与MY_DATASETSLIB_HOME中的子文件夹相对应") tf.app.flags.DEFINE_integer("random_seed", "123", "情感类别数目") tf.app.flags.DEFINE_integer("num_classes", "6", "情感类别数目") tf.app.flags.DEFINE_integer("num_features", "384", "情感特征维数") if not os.path.isdir(FLAGS.MY_DATASETSLIB_HOME): print(FLAGS.MY_DATASETSLIB_HOME, "不存在") filename = os.path.join( os.getcwd(), "log-" + strftime("%Y-%m-%d", gmtime()) + "-ch05_3_1.txt") sys.stdout = utils.Logger(filename) #原来sys.stdout指向控制台,现在重定向到文件 """ 打开语音数据集 """ dataset_path = os.path.join(FLAGS.MY_DATASETSLIB_HOME, FLAGS.dataset) print(" 数据集保存位置: " + dataset_path) loc = os.path.join(dataset_path, FLAGS.dataset + "_data.txt") # 这个是提取出来的标签和语音特征所在的txt文件 data = np.loadtxt(loc, skiprows=0) """ 生成训练集和测试集 """ y = data[:, 0] x = data[:, 1:] """ 对情感语音数据集进行预处理
score += batch_score upper_bound += (a.max(1)[0]).sum() num_data += pred.size(0) score = score / len(val_loader.dataset) upper_bound = upper_bound / len(val_loader.dataset) return score, upper_bound if __name__ == '__main__': args = parse_args() # args.MFB_O = 500 # args.MFB_K = 3 args.mima = False utils.create_dir(args.output) logger = utils.Logger(os.path.join(args.output, 'log.txt')) logger.write(args.__repr__()) os.environ['CUDA_VISIBLE_DEVICES'] = '0' device = torch.device("cuda:" + str(args.gpu) if args.gpu >= 0 else "cpu") args.device = device # Fixed ramdom seed torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) torch.backends.cudnn.benchmark = True torch.backends.cudnn.deterministic = True dictionary = dataset_RAD.Dictionary.load_from_file(os.path.join(args.RAD_dir, 'dictionary.pkl')) train_set = dataset_RAD.VQAFeatureDataset('train', args, dictionary, question_len=args.question_len) batch_size = args.batch_size model = Net(args, len(train_set.label2ans)) model.to(device)
def train(FLAGS): # config misc = dict() misc['log_steps'] = FLAGS.log_steps utils.validate_dir(FLAGS.work_dir) misc['batch_size'] = FLAGS.bsize save_dir = utils.validate_dir(os.path.join(FLAGS.work_dir, 'ckpt')) copyfile(os.path.abspath(__file__), os.path.join(FLAGS.work_dir, __file__)) # define logger if FLAGS.model_path is not None: misc['logger'] = utils.Logger(os.path.join(FLAGS.work_dir, 'log.txt'), 'a') else: misc['logger'] = utils.Logger(os.path.join(FLAGS.work_dir, 'log.txt')) # model function model_fn = utils.dynamic_import(FLAGS.model) # build graph ops = dict() with tf.device('/gpu:{}'.format(FLAGS.gpu)): # define start epoch and global step start_epoch = tf.get_variable('start_epoch', [], tf.int32, initializer=tf.constant_initializer(0), trainable=False) update_start_ep = tf.assign(start_epoch, start_epoch + 1) ops['global_step'] = tf.get_variable( 'global_step', [], tf.int32, initializer=tf.constant_initializer(0), trainable=False) # prepare dataset misc['logger'].write('Preparing dataset...') dataset = ModelNet40H5Dataset(FLAGS.train_file, FLAGS.test_file, FLAGS.bsize, FLAGS.npoints) misc['trainset_size'], misc['testset_size'] = dataset.size misc['label_map'] = dataset._label_map trainset = dataset.trainset testset = dataset.testset misc['logger'].write('Building model graph...') # define input and label ops['is_training'] = tf.placeholder(tf.bool, [], name='is_training') pointcloud = tf.cond(ops['is_training'], lambda: trainset.pointcloud, lambda: testset.pointcloud) ops['label'] = tf.cond(ops['is_training'], lambda: trainset.label, lambda: testset.label) # define model bn_decay = tf_layers.get_bn_decay(ops['global_step'], FLAGS.base_bn, FLAGS.bn_decay_steps, FLAGS.bn_decay_rate, FLAGS.end_bn, staircase=FLAGS.bn_staircase) ops['pred'], end_points = model_fn.get_model(pointcloud, ops['is_training'], bn_decay=bn_decay) # define loss ops['total_loss'] = model_fn.get_loss(ops['pred'], ops['label'], end_points) tf.summary.scalar('total loss', ops['total_loss']) # define metrics for training final_pred = tf.cast(tf.argmax(ops['pred'], 1), tf.uint8) final_label = tf.squeeze(ops['label'], 1) ops['accuracy'] = tf.contrib.metrics.accuracy(final_pred, final_label, name='accuracy') tf.summary.scalar('training accuracy', ops['accuracy']) # define optimizer lr = tf_layers.get_lr_expdecay(ops['global_step'], FLAGS.base_lr, FLAGS.lr_decay_steps, FLAGS.lr_decay_rate, FLAGS.end_lr, FLAGS.lr_staircase) tf.summary.scalar('learning rate', lr) if FLAGS.optim == 'momentum': optim = tf.train.MomentumOptimizer(lr, momentum=FLAGS.momentum) elif FLAGS.optim == 'adam': optim = tf.train.AdamOptimizer(lr) else: raise ValueError('Invalid optimizer {}'.format(FLAGS.optim)) ops['train'] = optim.minimize(ops['total_loss'], global_step=ops['global_step']) # define saver saver = tf.train.Saver(max_to_keep=20) # create a session tf_config = tf.ConfigProto() tf_config.gpu_options.allow_growth = True tf_config.allow_soft_placement = True tf_config.log_device_placement = False sess = tf.Session(config=tf_config) # define summary writer, saved log in work_dir/log ops['summary'] = tf.summary.merge_all() misc['summary_writer'] = tf.summary.FileWriter( os.path.join(FLAGS.work_dir, 'log'), sess.graph) # initialize variables misc['logger'].write('Initialize variables...') init = tf.global_variables_initializer() sess.run(init) # load pretrained model if FLAGS.model_path is not None: misc['logger'].write('Loading pretrained model from {}'.format( FLAGS.model_path)) saver.restore(sess, os.path.abspath(FLAGS.model_path)) _start_epoch = sess.run(start_epoch) # start training misc['logger'].write('Start training from epoch {}'.format(_start_epoch)) for epoch in range(_start_epoch, FLAGS.max_epoch + 1): # print epochX misc['logger'].write( '============= Epoch#{:3d} ============='.format(epoch)) # train an epoch train_an_epoch(sess, ops, misc) # evaluate once in a while if epoch % FLAGS.eval_steps == 0: evaluate_an_epoch(sess, ops, misc) # save model once in a while if epoch % FLAGS.save_steps == 0 and epoch != 0: saver.save(sess, os.path.join(save_dir, 'model-ep{}.ckpt'.format(epoch))) # update start epoch sess.run([update_start_ep])
def main(): args = parser.parse_args() LOG_FILE = args.outdir DEBUG = (args.mode == "debug") CHECKPOINT_PATH = args.checkpoint_dir + '-' + "BAC"[0] MAX_ROLLS = 7 ITER = 50000 LOG_ROUND = 10 env, MAX_PATH_LENGTH, EP_LENGTH_STOP = get_roll_params() desired_kl = args.desired_kl max_lr, min_lr = .1, 1e-6 framer = Framer(frame_num=args.frames) log_gamma_schedule = U.LinearSchedule(init_t=100, end_t=3000, init_val=-2, end_val=-8, update_every_t=100) #This is base 10 log_beta_schedule = U.LinearSchedule(init_t=100, end_t=3000, init_val=0, end_val=-4, update_every_t=100) #This is base 10 rew_to_advs = PathAdv(gamma=0.98, look_ahead=40) logger = U.Logger(logfile=LOG_FILE) np.random.seed(args.seed) if env.action_space == "discrete": act_type = 'disc' ac_dim, ac_scale = env.action_size, None print('Discrete Action Space. Numer of actions is {}.'.format( env.action_size)) else: act_type = 'cont' ac_dim, ac_scale = env.action_size, env.action_bound[1] print('Continuous Action Space. Action Scale is {}.'.format(ac_scale)) ob_dim = env.state_size * args.frames critic = pol.Critic(num_ob_feat=ob_dim) actor = pol.Actor(num_ob_feat=ob_dim, ac_dim=ac_dim, act_type=act_type, ac_scale=ac_scale) saver = tf.train.Saver(max_to_keep=3) reward = tf.placeholder(dtype=tf.float32) tf.summary.scalar("Episode Reward", reward) merged = tf.summary.merge_all() writer = tf.summary.FileWriter( os.path.join('summaries', args.outdir.split('.')[0] + '.data'), tf.get_default_graph()) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) tot_rolls = 0 for i in range(ITER): ep_obs, ep_advs, ep_logps, ep_target_vals, ep_acs = [], [], [], [], [] ep_rews = [] tot_rews, tot_ent, rolls = 0, 0, 0 while len(ep_rews) < EP_LENGTH_STOP and rolls < MAX_ROLLS: path = rollout(env=env, sess=sess, policy=actor.act, max_path_length=MAX_PATH_LENGTH, framer=framer) obs_aug = framer.full(path['obs']) ep_obs += obs_aug[:-1] ep_logps += path['logps'] ep_acs += path['acs'] tot_ent += path['entropy'] obs_vals = critic.value(obs=obs_aug, sess=sess).reshape(-1) target_val, advs = rew_to_advs(rews=path['rews'], terminal=path['terminated'], vals=obs_vals) ep_target_vals += list(target_val) ep_advs += list(advs) ep_rews += path['rews'] tot_rews += sum(path['rews']) if rolls == 0 and i % 10 == 0 and DEBUG: actor.printoo(obs=ep_obs, sess=sess) critic.printoo(obs=ep_obs, sess=sess) print('Path length %d' % len(path['rews'])) print('Terminated {}'.format(path['terminated'])) rolls += 1 avg_rew = float(tot_rews) / rolls avg_ent = tot_ent / float(len(ep_logps)) ep_obs, ep_advs, ep_logps, ep_target_vals, ep_acs, ep_rews = U.make_np( ep_obs, ep_advs, ep_logps, ep_target_vals, ep_acs, ep_rews) ep_advs.reshape(-1) ep_target_vals.reshape(-1) ep_advs = (ep_advs - np.mean(ep_advs)) / (1e-8 + np.std(ep_advs)) if i % 50 == 13 and DEBUG: perm = np.random.choice(len(ep_advs), size=20) print('Some targets', ep_target_vals[perm]) print('Some preds', critic.value(ep_obs[perm], sess=sess)) print('Some logps', ep_logps[perm]) cir_loss, ev_before, ev_after = train_critic( critic=critic, sess=sess, obs=ep_obs, targets=ep_target_vals) act_loss = train_actor(actor=actor, sess=sess, obs=ep_obs, advs=ep_advs, acs=ep_acs, logps=ep_logps) if args.tboard: summ, _, _ = sess.run([merged, actor.ac, critic.v], feed_dict={ actor.ob: ep_obs, critic.obs: ep_obs, reward: np.sum(ep_rews) }) writer.add_summary(summ, i) #logz act_lr, cur_beta, cur_gamma = actor.get_opt_param(sess) kl_dist = actor.get_kl(sess=sess, obs=ep_obs, logp_feeds=ep_logps, acs=ep_acs) #updates the learning rate based on the observed kl_distance and its multiplicative distance to desired_kl if kl_dist < desired_kl / 4: new_lr = min(max_lr, act_lr * 1.5) actor.set_opt_param(sess=sess, new_lr=new_lr) elif kl_dist > desired_kl * 4: new_lr = max(min_lr, act_lr / 1.5) actor.set_opt_param(sess=sess, new_lr=new_lr) if log_gamma_schedule.update_time(i): new_gamma = np.power(10., log_gamma_schedule.val(i)) actor.set_opt_param(sess=sess, new_gamma=new_gamma) print('\nUpdated gamma from %.4f to %.4f.' % (cur_gamma, new_gamma)) if log_beta_schedule.update_time(i): new_beta = np.power(10., log_beta_schedule.val(i)) actor.set_opt_param(sess=sess, new_beta=new_beta) print('Updated beta from %.4f to %.4f.' % (cur_beta, new_beta)) logger(i, act_loss=act_loss, circ_loss=np.sqrt(cir_loss), avg_rew=avg_rew, ev_before=ev_before, ev_after=ev_after, act_lr=act_lr, print_tog=(i % 20) == 0, kl_dist=kl_dist, avg_ent=avg_ent) if i % 100 == 50: logger.flush() if i % args.save_every == 0: saver.save(sess, CHECKPOINT_PATH, global_step=tot_rolls) tot_rolls += rolls del logger
start_epoch = components['epoch'] print("Loaded model from {}".format(args.load_path)) print("Decoder: {}".format(args.decoder)) args_for_save = encoder.args encoder = nn.DataParallel(encoder).cuda() decoder = nn.DataParallel(decoder).cuda() criterion = criterion.cuda() # ---------------------------------------------------------------------------- # training # ---------------------------------------------------------------------------- encoder.train() decoder.train() os.makedirs(args.save_path, exist_ok=True) logger = utils.Logger(os.path.join(args.save_path, 'log.txt')) running_loss = 0.0 train_begin = datetime.datetime.utcnow() print("Training start time: {}".format( datetime.datetime.strftime(train_begin, '%d-%b-%Y-%H:%M:%S'))) for epoch in range(1, model_args.num_epochs + 1): if epoch == 1: clr = utils.cyclic_lr(args.iter_per_epoch, 0.9 * 1e-3, 1.0 * 1e-3) elif epoch == 2: clr = utils.cyclic_lr(args.iter_per_epoch, 0.9 * 1e-3, 0.8 * 1e-3) elif epoch == 3: clr = utils.cyclic_lr(args.iter_per_epoch, 0.7 * 1e-3, 0.8 * 1e-3) elif epoch == 4: clr = utils.cyclic_lr(args.iter_per_epoch, 0.7 * 1e-3, 0.6 * 1e-3)
def main(argv): del argv filename = os.path.join( os.getcwd(), "log-" + strftime("%Y-%m-%d-%H-%M-%S", gmtime()) + ".txt") sys.stdout = utils.Logger(filename) #原来sys.stdout指向控制台,现在重定向到文件 if FLAGS.need_MP3_to_WAV: mp3_dir = FLAGS.mps_dir wav_dir = FLAGS.wav_dir batchpro_MP3_to_WAV(mp3_dir, wav_dir) if FLAGS.need_feature_SMILExtract: """ 需要提取特征(文件夹之间的逻辑关系要根据实际情况改写) """ wav_dir = FLAGS.wav_dir file_list = os.listdir(wav_dir) for f in file_list: sub_wav_dir = os.path.join(wav_dir, f) if os.path.isdir(sub_wav_dir): #这个函数只能判断绝对路径 feature_dir = os.path.join(wav_dir, f + "_feature") feature_SMILExtract(sub_wav_dir, feature_dir) #sub_wav_dir中不能有文件夹 if FLAGS.need_save_features: """ 需要把特征都整合到一个文件里。(文件夹之间的逻辑关系要根据实际情况改写) """ personal_dir = FLAGS.feature_dir file_list = os.listdir(personal_dir) feature_list = [] y_list = [] for t in file_list: if t.__contains__("angry"): y = 0 elif t.__contains__("fear"): y = 1 elif t.__contains__("happy"): y = 2 elif t.__contains__("neutral"): y = 3 elif t.__contains__("sad"): y = 4 else: # surprise y = 5 sub_dir = os.path.join(personal_dir, t) if os.path.isdir(sub_dir): # 这个函数只能判断绝对路径 for f in os.listdir(sub_dir): if f[-4:] == ".txt": this_feature_path = os.path.join(sub_dir, f) this_feature = np.loadtxt(this_feature_path, skiprows=0) feature_list.append(this_feature) y_list.append(y) if len(y_list) != 0: y_array = np.array(y_list) y_array = y_array.reshape(len(y_array), 1) feature_array = np.array(feature_list) feature_array = feature_array.reshape(len(feature_array), -1) data = np.column_stack((y_array, feature_array)) print("{0} 中的语音情感特征整合完成,保存在data.txt中,数据集大小{1}\n".format( personal_dir, data.shape)) loc = os.path.join(personal_dir, personal_dir.split('/')[-1] + "_data.txt") np.savetxt(loc, data) #如果txt存在,则重写;如果没有,则创建