def extract( self, flename, path ): if not filename.endswith( '/' ): f = os.path.join( path, flename ) dir = os.path.dirname( f ) if not os.path.exists( dir ): os.makdirs( dir ) file( f, 'wb').write( self.zfile.read( filename ))
def backup(self): logging.info('Backing up {host}'.format( host=self.host )) if self.kind == 'mongodump': logging.info('Performing mongodump...') cmd = ["mongodump", "-o", backup_dir, "-h", str(self.host.hostname), "--port", str(self.host.port), ] subprocess.Popen(cmd, stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.STDOUT ) elif self.kind == 'raw': # and check for offline status logging.info('Performing raw backup...') self.ssh_connect() # ssh -n remotehost "tar jcvf - SOURCEDIR" > DESTFILE.tar.gz #cmd = ["tar", "zcf", "-", source_dir] #stdin, stdout, sterr = self.ssh.exec_command(" ".join(cmd)) #print stdout.read() if not os.path.exists(backup_dir): os.makdirs(backup_dir) tar_cmd = '"tar jcf - {source_dir}"'.format(source_dir=source_dir) cmd = ["ssh", "-n", self.host.hostname, "-p5555", tar_cmd, ">", "backup.tar.gz"] subprocess.call(cmd) # Make a tar archive from ssh pipe #tar = tarfile.open(backup_dir + 'backup.tar.gz', 'w:gz') #tar.add(stdout) #tar.close() # tar zcvf - /wwwdata | ssh [email protected] "cat > /backup/wwwdata.tar.gz" else: # DB was not locked logging.info('Database needs to be locked for raw backup')
def check_lm_bin(dataset, lm_path): if not os.path.isdir(os.path.join(dataset, 'lm_bin')): os.makdirs(os.path.join(dataset, 'lm_bin')) for i in range(len(lm_path)): lm = np.loadtxt(lm_path[i]) lm = np.reshape(lm, [-1]) lm.tofile( os.path.join(dataset, 'lm_bin', lm_path[i].split('/')[-1].replace('txt', 'bin')))
def filterAndSave(fname,path,savepath,filterSize): vol = importStack(path,fname) try: os.makdirs(savepath) except: print(savepath+' already exists') res = np.memmap(savepath + 'filtered_Size_'+ str(filterSize) + fname,dtype = 'float64', mode = 'w+', shape = vol.shape) streaming3Dfilter(vol, res,filterSize)
def fillPlayers(): path = "./metadata/" if not os.path.exists(path): os.makdirs(path) with open((os.path.join(path, 'players.txt'))) as playerNames: playerNameList = playerNames.readlines() for playerName in playerNameList: newPlayer = player(playerName) playerList.append(newPlayer)
def dump(manager, **kwargs): data_path = get_data_path(**kwargs) # If the parent directory does not exist, create it. data_dir = os.path.dirname(data_path) try: os.makdirs(data_dir) except FileExistsError: pass with open(data_path, 'w') as fh: json.dump(manager.to_dict(), fh)
def __init__(self, root, target_type="category", train=True, transform=None, target_transform=None, download=False): super(Caltech101, self).__init__(os.path.join(root, 'caltech101')) self.train = train self.dir_name = '101_ObjectCategories_split/train' if self.train else '101_ObjectCategories_split/test' os.makdirs(self.root, exist_ok=True) if isinstance(target_type, list): self.target_type = target_type else: self.target_type = [target_type] self.transform = transform self.target_transform = target_transform if download: self.download() if not self._check_integrity(): raise RuntimeError('Dataset not found or corrupted.' + ' You can use download=True to download it') self.categories = sorted( os.listdir(os.path.join(self.root, "101_ObjectCategories"))) self.categories.remove("BACKGROUND_Google") # this is not a real class # For some reason, the category names in "101_ObjectCategories" and # "Annotations" do not always match. This is a manual map between the # two. Defaults to using same name, since most names are fine. name_map = { "Faces": "Faces_2", "Faces_easy": "Faces_3", "Motorbikes": "Motorbikes_16", "airplanes": "Airplanes_Side_2" } self.annotation_categories = list( map(lambda x: name_map[x] if x in name_map else x, self.categories)) self.index = [] self.y = [] for (i, c) in enumerate(self.categories): file_names = os.listdir(os.path.join(self.root, self.dir_name, c)) n = len(file_names) self.index.extend(file_names) self.y.extend(n * [i]) print(self.train, len(self.index))
def save_sidebar(content): filepath = current_app.config.get("SITE_SIDEBAR") if not filepath: flash("Config your site with SITE_SIDEBAR", "warn") return dirname = os.path.dirname(filepath) if not os.path.exists(dirname): os.makdirs(dirname) with open(filepath, "wb") as f: content = content.encode("utf-8") f.write(content)
def save_sidebar(content): filepath = current_app.config.get('SITE_SIDEBAR') if not filepath: flash('Config your site with SITE_SIDEBAR', 'warn') return dirname = os.path.dirname(filepath) if not os.path.exists(dirname): os.makdirs(dirname) with open(filepath, 'wb') as f: content = content.encode('utf-8') f.write(content)
def filterAndSave(fname,path,savepath,filterSize): vol = importStack(path,fname) #volsmall =vol[100:150,100:150,100:101] #volsmall = vol try: os.makdirs(savepath) except: print(savepath+' already exists') res = np.memmap(savepath + 'filtered_Size_'+ str(filterSize) + fname,dtype = 'float64', mode = 'w+', shape = vol.shape) #res = ndimage.generic_filter(vol, nanmeanFilter,size = filterSize) streaming3Dfilter(vol, res,filterSize)
def organize_by_mtime(argv): assert len(argv) == 2 src, dest = argv for root, dirs, files in os.walk(src): for basename in files: src_file = os.path.join(root, basename) t = os.path.getmtime(src_file) year, month = datetime.datetime.fromtimestamp(t).strftime('%Y %m').split() dest_dir = os.path.join(dest, year, month) dest_file = os.path.join(dest_dir, basename) if not os.path.exists(dest_dir): os.makdirs(dest_dir) print 'Moving %s to %s' % (src_file, dest_file) try: shutil.move(src_file, dest_file) except Exception, e: print e sys.exit()
def moveFiles(listOfFile, destinationDir): """ Move list of the files into different directory If the same name file exists, it add random prefix into filename :param listOfFile : <string list> list of file path :type listOfFile:str :param destinationDir :Destination directory name :type destinationDir:str :return void """ for filename in listOfFile: path, name = os.path.split(filename) prefix_num = random.randrange(1, 99999999) if not os.path.exists(destinationDir): os.makdirs(destinationDir) if (filename is destinationDir): continue #os.getcwd() + os.sep + destinationFilename = destinationDir + os.sep #+ str(prefix_num) + "_" os.rename(filename, destinationFilename + name)
#!/usr/bin/env pythong import os os.chdir('/tmp/tmp') for dirname in '1 10 11 12 2 20 21 22 3 30 31 32'.split(): try: os.makdirs(dirname) except OSError: pass for root, dirs, files in os.walk('.'): for dirname in sorted(dirs): # for dirname in sorted(dirs, key=int): print(dirname)
metavar='') parser.add_argument('-l', '--log', action='store_true', help='Write log to the consol') args = parser.parse_args() if not args.interface: print("Error: capture interface not given, try --help") sys.exit(-1) # Setup thread for sniffer # sniffer = packetsniff(args.interface) # Making folder for files # if not os.path.exists(os.path.dirname(__file__) + '/data'): os.makdirs(os.path.dirname(__file__) + '/data') folder = os.path.dirname(__file__) + '/data/' + args.output[:-4] # Check if folder exists # if os.path.exists(folder): print('Please choose another file name' '\nOne with this name already exists') # Check if tmux is running if os.system('pidof tmux') != 256: time.sleep(10) os.system("pkill tmux") sys.exit(-1) os.makedirs(folder) # Setting up csv writer and file for starting coordinates # csvFile = open(folder + '/' + args.output, 'w') wr = csv.writer(csvFile)
avg_cost = 0 # Training step for i in range(batchSize): feed_dict = {X: trainX, Y: trainY} s, _ = sess.run([summary, optimizer], feed_dict=feed_dict) writer.add_summary(s, global_step=global_step) global_step += 1 avg_cost += sess.run(loss, feed_dict=feed_dict) #/ total_batch print("Epoch= {:>5}, loss= {:>12}".format(epoch + 1, avg_cost)) sess.run(last_epoch.assign(epoch + 1)) if not os.path.exists(CHECK_POINT_DIR): os.makdirs(CHECK_POINT_DIR) saver.save(sess, CHECK_POINT_DIR + "/model", global_step=epoch + 1) # Test step test_predict = sess.run(Y_pred, feed_dict={X: testX}) rmse_val = sess.run(rmse, feed_dict={ targets: testY, predictions: test_predict }) print("RMSE: {}".format(rmse_val)) # Test step test_predict = sess.run(Y_pred, feed_dict={X: testX}) rmse_val = sess.run(rmse, feed_dict={
def createDir(path_str): if os.path.exists(path_str): return os.makdirs(path_str)
cfg = get_cfg() cfg.merge_from_file( model_zoo.get_config_file( "COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml")) cfg.DATASETS.TRAIN = ("balloon_train", ) cfg.DATASETS.TEST = () cfg.MODEL.DEVICE = 'gpu' cfg.DATALOADER.NUM_WORKERS = 2 cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url( "COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml") cfg.SOLVER.IMS_PER_BATCH = 2 cfg.SOLVER.BASE_LR = 0.00025 cfg.SOLVER.MAX_ITER = 300 cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 128 cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1 # only has one class to be detected os.makdirs(cfg.OUTPUT_DIR, exist_ok=True) trainer = DefaultTrainer(cfg) trainer.resume_or_load(resume=False) trainer.train() # eval the model cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "model_final.pth") cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.7 predictor = DefaultPredictor(cfg) dataset_dicts = get_balloon_dicts('balloon/val') for d in random.sample(dataset_dicts, 3): im = cv2.imread(d["file_name"]) outputs = predictor(im) v = Visualizer(im[:, :, ::-1], metadata=balloon_metadata, scale=0.5,
#!/usr/bin/env python import shutil, glob, os sourceModelPath = 'libs/FaceTracker/model/' examples = glob.glob('example*') for example in examples: targetModelPath = example + '/bin/data/' try: os.makdirs(targetModelPath) except: pass try: shutil.copytree(sourceModelPath, targetModelPath + 'model/') print 'Copied model data into ' + example except: print 'Did not copy model data into ' + example
def main(cfg): # Checking data directory input_directory = cfg['dataset']['input_directory'] if input_directory == None: data_dir = parentdir.replace("\hybcast", "") data_dir = parentdir.replace("/hybcast", "") input_directory = data_dir + "\\hybcast\\data\\external" if os.path.isdir(input_directory) == False: print("Creating data directory " + input_directory) os.makedirs(input_directory) else: if os.path.isdir(input_directory) == False: print("Creating data directory " + input_directory) os.makdirs(input_directory) # Checking cuda availability if torch.cuda.is_available() == False: print("CUDA is not available, using cpu instead") cfg['device'] = 'cpu' else: print("Using CUDA") print('Preparing M4 data - ' + cfg['dataset']['name']) X_train_df, y_train_df, X_test_df, y_test_df = prepare_m4_data( dataset_name=cfg['dataset']['name'], directory=input_directory, num_obs=cfg["dataset"]["num_obs"]) print("Successfully get the M4 data.\nBegin ESTransformer") #Instantiate the model model = DeployedESTransformer( # Device and dataset device=cfg['device'], root_dir=input_directory, dataset_name=cfg['dataset']['name'], # Train parameters max_epochs=500, batch_size=cfg['train_parameters']['batch_size'], freq_of_test=cfg['train_parameters']['freq_of_test'], learning_rate=float(cfg['train_parameters']['learning_rate']), per_series_lr_multip=cfg['train_parameters']['per_series_lr_multip'], lr_scheduler_step_size=cfg['train_parameters'] ['lr_scheduler_step_size'], lr_decay=cfg['train_parameters']['lr_decay'], level_variability_penalty=cfg['train_parameters'] ['level_variability_penalty'], testing_percentile=cfg['train_parameters']['testing_percentile'], training_percentile=cfg['train_parameters']['training_percentile'], ensemble=cfg['train_parameters']['ensemble'], # ES parameters seasonality=cfg['ES_parameters']['seasonality'], random_seed=cfg['ES_parameters']['random_seed'], input_size=cfg['ES_parameters']['input_size'], d_input=cfg['ES_parameters'] ['d_input'], # input_size + 6 (which is exo features) output_size=cfg['ES_parameters'] ['output_size'], # must be the same as d_output d_output=cfg['ES_parameters'] ['d_output'], # input_size + output_size >= 13 # Transformer parameter transformer_weight_decay=0.0, d_model=cfg['Transformer_parameter']['d_model'], q=cfg['Transformer_parameter']['q'], v=cfg['Transformer_parameter']['v'], h=cfg['Transformer_parameter']['h'], N=cfg['Transformer_parameter']['N'], attention_size=cfg['Transformer_parameter']['attention_size'], dropout=cfg['Transformer_parameter']['dropout'], chunk_mode=cfg['Transformer_parameter']['chunk_mode'], pe=cfg['Transformer_parameter']['pe'], pe_period=cfg['Transformer_parameter']['pe_period']) # Fit model # If y_test_df is provided the model # will evaluate predictions on this set every freq_test epochs model.fit(X_train_df, y_train_df, X_test_df, y_test_df) # Predict on test set y_hat_df = model.predict(X_test_df) # Predict on train set y_train_hat_df = model.predict(X_train_df) # Evaluate predictions final_owa, final_mase, final_smape = evaluate_prediction_owa( y_hat_df, y_train_df, X_test_df, y_test_df, naive2_seasonality=1)
def check_folder(): if not os.path.exists('data/enigmata'): print('Creating data/enigmata') os.makdirs('data/enigmata')
bead_dict[h] = beads print('Finished', pos) pickle.dump(bead_dict, open(os.path.join(bead_path, pos), 'wb')) else: bead_dict = {} for h in fnames_dict.keys(): beads = find_beads_3D(fnames_dict[h], ave_bead) bead_dict[h] = beads print('Finished', pos) pickle.dump(bead_dict, open(os.path.join(bead_path, pos), 'wb')) if __name__ == '__main__': #Setting up paths if not os.path.exists(args.analysis_path): os.makdirs(args.analysis_path) if args.md_path == 'None': deconvolved_path = os.path.join(args.analysis_path, 'deconvolved') if not os.path.exists(deconvolved_path): print('analysis path doesnt have your metadata') print('add path to metadata after analysis path') else: deconvolved_path = args.md_path bead_path = os.path.join(args.analysis_path, 'beads') if not os.path.exists(bead_path): os.makedirs(bead_path) results_path = os.path.join(args.analysis_path, 'results') if not os.path.exists(results_path): os.makedirs(results_path) #Retreiving file names and position names
def __init__(self, net_type): self.net_type = net_type self.anchor_per_scale = cfg.YOLO.ANCHOR_PER_SCALE self.classes = utils.read_class_names(cfg.YOLO.CLASSES) self.num_classes = len(self.classes) self.learn_rate_init = cfg.TRAIN.LEARN_RATE_INIT self.learn_rate_end = cfg.TRAIN.LEARN_RATE_END self.first_stage_epochs = cfg.TRAIN.FISRT_STAGE_EPOCHS self.second_stage_epochs = cfg.TRAIN.SECOND_STAGE_EPOCHS self.warmup_periods = cfg.TRAIN.WARMUP_EPOCHS self.initial_weight = cfg.TRAIN.INITIAL_WEIGHT self.ckpt_path = cfg.TRAIN.CKPT_PATH if not os.path.exists(self.ckpt_path): os.makdirs(self.ckpt_path) self.time = time.strftime('%Y-%m-%d-%H-%M-%S', time.localtime(time.time())) self.moving_ave_decay = cfg.YOLO.MOVING_AVE_DECAY self.max_bbox_per_scale = 150 self.train_logdir = ("./%s/log/train" % net_type) if not os.path.exists(self.train_logdir): os.makedirs(self.train_logdir) self.trainset = Dataset('train', self.net_type) self.testset = Dataset('test', self.net_type) self.steps_per_period = len(self.trainset) self.sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) with tf.name_scope('input'): if net_type == 'tiny': self.input_data = tf.placeholder(dtype=tf.float32, name='input_data') self.label_mbbox = tf.placeholder(dtype=tf.float32, name='label_mbbox') self.label_lbbox = tf.placeholder(dtype=tf.float32, name='label_lbbox') self.true_mbboxes = tf.placeholder(dtype=tf.float32, name='mbboxes') self.true_lbboxes = tf.placeholder(dtype=tf.float32, name='lbboxes') self.trainable = tf.placeholder(dtype=tf.bool, name='training') else: self.input_data = tf.placeholder(dtype=tf.float32, name='input_data') self.label_sbbox = tf.placeholder(dtype=tf.float32, name='label_sbbox') self.label_mbbox = tf.placeholder(dtype=tf.float32, name='label_mbbox') self.label_lbbox = tf.placeholder(dtype=tf.float32, name='label_lbbox') self.true_sbboxes = tf.placeholder(dtype=tf.float32, name='sbboxes') self.true_mbboxes = tf.placeholder(dtype=tf.float32, name='mbboxes') self.true_lbboxes = tf.placeholder(dtype=tf.float32, name='lbboxes') self.trainable = tf.placeholder(dtype=tf.bool, name='training') with tf.name_scope("define_loss"): if self.net_type == 'tiny': self.model = YOLOV3Tiny(self.input_data, self.trainable) self.net_var = tf.global_variables() self.iou_loss, self.conf_loss, self.prob_loss = self.model.compute_loss(self.label_mbbox, self.label_lbbox, self.true_mbboxes, self.true_lbboxes) self.loss = self.iou_loss + self.conf_loss + self.prob_loss elif self.net_type == 'yolov3': self.model = YOLOV3(self.input_data, self.trainable) self.net_var = tf.global_variables() self.iou_loss, self.conf_loss, self.prob_loss = self.model.compute_loss(self.label_sbbox, self.label_mbbox, self.label_lbbox, self.true_sbboxes, self.true_mbboxes, self.true_lbboxes) self.loss = self.iou_loss + self.conf_loss + self.prob_loss elif self.net_type == 'yolov4' or self.net_type == 'yolov5' : iou_use = 1 # (0, 1, 2) ==> (giou_loss, diou_loss, ciou_loss) focal_use = False # (False, True) ==> (normal, focal_loss) label_smoothing = 0 if self.net_type == 'yolov4': self.model = YOLOV4(self.input_data, self.trainable) else: self.model = YOLOV5(self.input_data, self.trainable) self.net_var = tf.global_variables() self.iou_loss, self.conf_loss, self.prob_loss = self.model.compute_loss(self.label_sbbox, self.label_mbbox, self.label_lbbox, self.true_sbboxes, self.true_mbboxes, self.true_lbboxes, iou_use, focal_use, label_smoothing) self.loss = self.iou_loss + self.conf_loss + self.prob_loss # self.loss = tf.Print(self.loss, [self.iou_loss, self.conf_loss, self.prob_loss], message='loss: ') else: print('self.net_type=%s error' % self.net_type) with tf.name_scope('learn_rate'): self.global_step = tf.Variable(1.0, dtype=tf.float64, trainable=False, name='global_step') warmup_steps = tf.constant(self.warmup_periods * self.steps_per_period, dtype=tf.float64, name='warmup_steps') train_steps = tf.constant((self.first_stage_epochs + self.second_stage_epochs)* self.steps_per_period, dtype=tf.float64, name='train_steps') self.learn_rate = tf.cond(pred=self.global_step < warmup_steps, true_fn=lambda: self.global_step / warmup_steps * self.learn_rate_init, false_fn=lambda: self.learn_rate_end + 0.5 * (self.learn_rate_init - self.learn_rate_end) * \ (1 + tf.cos((self.global_step - warmup_steps) / (train_steps - warmup_steps) * np.pi))) global_step_update = tf.assign_add(self.global_step, 1.0) with tf.name_scope("define_weight_decay"): moving_ave = tf.train.ExponentialMovingAverage(self.moving_ave_decay).apply(tf.trainable_variables()) with tf.name_scope("define_first_stage_train"): self.first_stage_trainable_var_list = [] for var in tf.trainable_variables(): var_name = var.op.name var_name_mess = str(var_name).split('/') if net_type == 'tiny': bboxes = ['conv_sbbox', 'conv_mbbox', 'conv_lbbox'] else bboxes = ['conv_mbbox', 'conv_lbbox'] if var_name_mess[0] inbboxes: self.first_stage_trainable_var_list.append(var) first_stage_optimizer = tf.train.AdamOptimizer(self.learn_rate).minimize(self.loss, var_list=self.first_stage_trainable_var_list) with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)): with tf.control_dependencies([first_stage_optimizer, global_step_update]): with tf.control_dependencies([moving_ave]): self.train_op_with_frozen_variables = tf.no_op() with tf.name_scope("define_second_stage_train"): second_stage_trainable_var_list = tf.trainable_variables() second_stage_optimizer = tf.train.AdamOptimizer(self.learn_rate).minimize(self.loss, var_list=second_stage_trainable_var_list) with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)): with tf.control_dependencies([second_stage_optimizer, global_step_update]): with tf.control_dependencies([moving_ave]): self.train_op_with_all_variables = tf.no_op() with tf.name_scope('loader_and_saver'): self.loader = tf.train.Saver(self.net_var) self.saver = tf.train.Saver(tf.global_variables(), max_to_keep=1000) with tf.name_scope('summary'): tf.summary.scalar("learn_rate", self.learn_rate) tf.summary.scalar("iou_loss", self.iou_loss) tf.summary.scalar("conf_loss", self.conf_loss) tf.summary.scalar("prob_loss", self.prob_loss) tf.summary.scalar("total_loss", self.loss) logdir = ("./%s/log/" % self.net_type) if os.path.exists(logdir): shutil.rmtree(logdir) os.makedirs(logdir) self.write_op = tf.summary.merge_all() self.summary_writer = tf.summary.FileWriter(logdir, graph=self.sess.graph)
def save(self, global_step=None): print('Saving checkpoint') if not os.path.exists(self.ckpt_dir): os.makdirs(self.ckpt_dir) self.saver.save(self.sess, self.ckpt_dir, global_step=global_step)
example to pull out the last part of the file path: os.path.basename('c:\\folder1\\folder\\spam.png') os.path.basename('c:\\folder1\\folder') """) print(os.path.isabs('..\\..\\spam.png')) print(os.path.isabs('c:\\folder\\folder')) print(os.path.relpath('c:\\folder1\\folder2\\spam.png', 'c:\\folder')) print(os.path.dirname('c:\\folder\\folder2\\spam.png')) print(os.path.basename('c:\\folder1\\folder\\spam.png')) print(os.path.basename('c:\\folder1\\folder')) print( """To check if a filepath exists, is a file, is a directory, and the file size: os.path.exists('c:\\folder1\\folder2\\spam.png') os.path.exists('c:\\') os.path.isfile('c:\\folder1\\folder2\\spam.png') os.path.isdir('c:\\') os.path.getsize('c:\\windows\\system32\\calc.exe) """) print(os.path.exists('c:\\folder1\\folder2\\spam.png')) print(os.path.exists('c:\\')) print(os.path.isfile('c:\\folder1\\folder2\\spam.png')) print(os.path.isdir('c:\\')) print(os.path.getsize('c:\\windows\\system32\\calc.exe')) print("""To create new folders: os.makdirs('c:\\delicous\walnut\\coffee')""")
from network3 import * from node2 import * from message2 import * from constants import * import os #number of Taus #initialize and fill network with nodes net = Network() net.fill_network(V, maxX, maxY) if not os.path.exists(path_to_folder): os.makdirs(path_to_folder) #initialize output file output_file = open(path_to_folder + delivery_file_name, "w") output_file.write("ID\ts\td\tts\tte\tm\tLLC\tELC\n") output_file.write("----------------------------------------------------\n") output_file.close() output_file2 = open(path_to_folder + consumedEnergyFile, 'w') output_file2.write("Time\tEnergy\n") output_file2.close() day1_link_exists = link_exists_folder.split("/") specBW = pickle.load(open(link_exists_folder + "specBW.pkl", "rb")) LINK_EXISTS = pickle.load(open(link_exists_folder + "/LINK_EXISTS.pkl", "rb")) day1_folder_path = path_to_folder.split("/")
SAMPLERATE = 8000 DATAPATH = 'data/test' # In[100]: # Download raw data from source # and uncompress to DATAPATH os.makedirs(DATAPATH, exist_ok=True) url = 'http://download.tensorflow.org/data/' file_name = 'speech_commands_v0.01.tar.gz' if not os.path.exists(DATAPATH): os.makdirs(DATAPATH) if not os.path.exists(os.path.join(DATAPATH, file_name)): print('Downloading', file_name) rtnVal = subprocess.call( ['wget', os.path.join(url, file_name), '-P', DATAPATH]) assert rtnVal == 0, 'downloaded failed!' print(file_name, 'downloaded successfully') print('Uncompressing', os.path.basename(file_name)) rtnVal = subprocess.call( ['tar', '-C', DATAPATH, '-zxvf', os.path.join(DATAPATH, file_name)]) assert rtnVal == 0, 'file failed to uncompress!' print(file_name, 'uncompressed successfully')