def train_dlc(path): os.chdir(path) folders = [name for name in os.listdir(path) if os.path.isdir(name) and name[0].isdigit()] num_folder = len(folders) for i in range(len(folders)): start = time() if os.path.exists(r"%s\%s\labeled-data"%(path, folders[i])) and os.path.exists(r"%s\%s\config.yaml"%(path, folders[i])) \ and os.path.exists(r"%s\%s\dlc-models\iteration-0"%(path, folders[i])) == False and get_size(r"%s\%s\labeled-data"%(path, folders[i])) > 0: path_config_file = r"%s\%s\config.yaml" %(path, folders[i]) deeplabcut.check_labels(path_config_file) deeplabcut.create_training_dataset(path_config_file) deeplabcut.train_network(path_config_file, shuffle = 1, autotune = True, displayiters = 5000, saveiters = 5000, maxiters = 200000) deeplabcut.analyze_videos(path_config_file, r"%s\%s\videos"%(path, folders[i]), videotype = '.mp4', save_as_csv = True) print("%s training has been done, %s left"%(folders[i], num_folder - i)) elif os.path.exists(r"%s\%s\dlc-models\iteration-0"%(path, folders[i])): path_config_file = r"%s\%s\config.yaml" %(path, folders[i]) print("%s model has been trained, do you want to retrain it? y/n"%(folders[i])) feedback = input() if feedback == "y": deeplabcut.train_network(path_config_file, shuffle = 1, autotune = True, displayiters = 5000, saveiters = 5000, maxiters = 200000) # If model was previously trained, read config.yaml to retrieve deeplabcut.analyze_videos(path_config_file, r"%s\%s\videos"%(path, folders[i]), videotype='.mp4', save_as_csv=True) print("%s training has been done, %s left"%(folders[i], num_folder - i)) else: print("labeled-data folder not found OR empty OR config not found") print("Running time for %s is %s sec" %(folders[i], time() - start))
def train(): videofile_path = ['videos/ostrich.mp4' ] #Enter a folder OR a list of videos to analyze. if not os.path.isfile(videofile_path[0]): sys.exit("File {} not found!!".format(videofile_path[0])) path_config_file = '/home/braincreator/Pose_estimation/DeepLabCut/examples/ostrich/Testing-Shan-2019-08-07/config.yaml' print("\n" + "=" * 80 + "\n\t\t\t\tTRAINING\n" + "=" * 80) print("\nCreating Training dataset from labeled frames...\n") deeplabcut.create_training_dataset(path_config_file) print("\nDataset created, Next stop Training!\n\n") deeplabcut.train_network(path_config_file, shuffle=1, saveiters=2000, displayiters=500, gputouse=None, maxiters=50000) print("\nEvauating network:\n" + "=" * 50) deeplabcut.evaluate_network(path_config_file, plotting=True) print("\n" + "=" * 80 + "\n\t\t\t\tANALYZE\n" + "=" * 80) deeplabcut.analyze_videos(path_config_file, videofile_path, gputouse=None, videotype='.mp4') print("\n" + "=" * 80 + "\n\t\t\t\tCreating video\n" + "=" * 80) deeplabcut.create_labeled_video(path_config_file, videofile_path, outputframerate=5, draw_skeleton=True)
def run_program(path_config_file): # import vars and check path if not os.path.exists(path_config_file): raise ValueError('no config file at %s' % path_config_file) # train the network deeplabcut.create_training_dataset(path_config_file, windows2linux=True) deeplabcut.train_network(path_config_file, gputouse=1, max_snapshots_to_keep=5)
def DLCTrain(config_path, displayiters, saveiters, maxiters): """ Utility to facilitate training a DeepLabCut model from the MesoNet GUI. :param config_path: (required) The path to a DeepLabCut configuration file (.yaml). :param displayiters: (required) The interval between which intervals should be shown. :param saveiters: (required) The interval after which the model should be saved. :param maxiters: (required) The number of iterations after which the model should finish training. """ deeplabcut.create_training_dataset(config_path) deeplabcut.train_network(config_path, displayiters=displayiters, saveiters=saveiters, maxiters=maxiters)
def train_network(self,event): shuffle = self.shuffles.GetValue() trainingsetindex = self.trainingindex.GetValue() max_snapshots_to_keep = self.snapshots.GetValue() displayiters = self.display_iters.GetValue() saveiters = self.save_iters.GetValue() maxiters = self.max_iters.GetValue() deeplabcut.train_network(self.config,shuffle, trainingsetindex,gputouse=None, max_snapshots_to_keep=max_snapshots_to_keep, autotune=None, displayiters=displayiters, saveiters=saveiters, maxiters=maxiters)
def train_network(self, event): if self.shuffles.Children: shuffle = int(self.shuffles.Children[0].GetValue()) else: shuffle = int(self.shuffles.GetValue()) if self.trainingindex.Children: trainingsetindex = int(self.trainingindex.Children[0].GetValue()) else: trainingsetindex = int(self.trainingindex.GetValue()) if self.snapshots.Children: max_snapshots_to_keep = int(self.snapshots.Children[0].GetValue()) else: max_snapshots_to_keep = int(self.snapshots.GetValue()) if self.display_iters.Children: displayiters = int(self.display_iters.Children[0].GetValue()) else: displayiters = int(self.display_iters.GetValue()) if self.save_iters.Children: saveiters = int(self.save_iters.Children[0].GetValue()) else: saveiters = int(self.save_iters.GetValue()) if self.max_iters.Children: maxiters = int(self.max_iters.Children[0].GetValue()) else: maxiters = int(self.max_iters.GetValue()) deeplabcut.train_network( self.config, shuffle, trainingsetindex, gputouse=None, max_snapshots_to_keep=max_snapshots_to_keep, autotune=None, displayiters=displayiters, saveiters=saveiters, maxiters=maxiters, )
projectpath=os.path.join(prefix,project) config=os.path.join(projectpath,'config.yaml') cfg=deeplabcut.auxiliaryfunctions.read_config(config) previous_path=cfg['project_path'] cfg['project_path']=projectpath deeplabcut.auxiliaryfunctions.write_config(config,cfg) print("This is the name of the script: ", sys.argv[0]) print("Shuffle: ", shuffle) print("config: ", config) deeplabcut.create_training_dataset(config, Shuffles=[shuffle],windows2linux=True) deeplabcut.train_network(config, shuffle=shuffle, max_snapshots_to_keep=5, maxiters=Maxiter) print("Evaluating...") deeplabcut.evaluate_network(config, Shuffles=[shuffle],plotting=True) print("Analyzing videos..., switching to last snapshot...") #cfg=deeplabcut.auxiliaryfunctions.read_config(config) #cfg['snapshotindex']=-1 #deeplabcut.auxiliaryfunctions.write_config(config,cfg) for vtype in ['.mp4','.m4v','.mpg']: try: deeplabcut.analyze_videos(config,[str(os.path.join(projectpath,'videos'))],shuffle=shuffle,videotype=vtype,save_as_csv=True) except: pass print("DONE WITH ", project," resetting to original path")
) path_config = '/home/weertman/Documents/Theresa_FHL/Armina_DeepLabCut/Arimina_model_1/' if os.path.exists(path_config) != True: os.mkdir(path_config) path_config = deeplabcut.create_new_project(project, experimenter, videos, copy_videos=True, working_directory=path_config) path_config = '/home/weertman/Documents/Theresa_FHL/Armina_DeepLabCut/Arimina_model_1/Armina_model_1-Theresa-2020-07-01/config.yaml' ''' deeplabcut.extract_frames(path_config, mode = 'automatic', algo = 'uniform', userfeedback = False, crop = False) ''' deeplabcut.label_frames(path_config) deeplabcut.create_training_dataset(path_config) deeplabcut.train_network(path_config, maxiters=200000, displayiters=10) deeplabcut.evaluate_network(path_config) deeplabcut.analyze_time_lapse_frames( path_config, '/home/weertman/Documents/Theresa_FHL/Armina_DeepLabCut/left_test_images/', save_as_csv=True)
def write_config(configname,cfg): with open(str(configname), 'w') as ymlfile: yaml.dump(cfg, ymlfile,default_flow_style=False) # Loading example data set path_config_file = os.path.join(os.getcwd(),'openfield-Pranav-2018-10-30/config.yaml') deeplabcut.load_demo_data(path_config_file) cfg=read_config(path_config_file) posefile=os.path.join(cfg['project_path'],'dlc-models/iteration-'+str(cfg['iteration'])+'/'+ cfg['Task'] + cfg['date'] + '-trainset' + str(int(cfg['TrainingFraction'][0] * 100)) + 'shuffle' + str(1),'train/pose_cfg.yaml') DLC_config=read_config(posefile) DLC_config['save_iters']=10 DLC_config['display_iters']=2 DLC_config['multi_step']=[[0.005,15001]] write_config(posefile,DLC_config) print("TRAIN NETWORK") deeplabcut.train_network(path_config_file, shuffle=1,saveiters=15000,displayiters=100) print("EVALUATE") deeplabcut.evaluate_network(path_config_file,plotting=False) print("Analyze Video") videofile_path = os.path.join(os.getcwd(),'openfield-Pranav-2018-10-30','videos','m3v1mp4.mp4') deeplabcut.analyze_videos(path_config_file,[videofile_path]) print("Create Labeled Video") deeplabcut.create_labeled_video(path_config_file,[videofile_path],save_frames=True)
base_dlc_folder = join(const.base_save_folder, const.rat_folder, const.date_folders[date], 'Analysis', 'Deeplabcut') base_projects_folder = join(base_dlc_folder, 'projects') cropped_video_filename = join(base_dlc_folder, 'BonsaiCroping', 'Croped_video.avi') # ---------------------------------------------------------------------------------------------------------------------- config_path = deeplabcut.create_new_project(project='V1', experimenter='', videos=[cropped_video_filename], working_directory=base_projects_folder, copy_videos=True) # Use the line below to 'reload the existing project config_path = join(base_projects_folder, 'V1--2019-06-30', 'config.yaml') # Edit the config.yaml file deeplabcut.extract_frames(config_path, 'manual') deeplabcut.label_frames(config_path) deeplabcut.check_labels(config_path) deeplabcut.create_training_dataset(config_path) deeplabcut.train_network(config_path, gputouse=1) deeplabcut.evaluate_network(config_path, plotting=True) deeplabcut.analyze_videos(config_path, [cropped_video_filename], gputouse=1, shuffle=1, save_as_csv=False, videotype='avi') deeplabcut.create_labeled_video(config_path, [cropped_video_filename])
keepdeconvweights=False ''' print("CREATING TRAININGSET", net_type) if 'resnet_50' == net_type: #this tests the default condition... deeplabcut.create_training_dataset(path_config_file, Shuffles=[shuffle], augmenter_type=augmenter_type) else: deeplabcut.create_training_dataset(path_config_file, Shuffles=[shuffle], net_type=net_type, augmenter_type=augmenter_type) Cuttrainingschedule(path_config_file, shuffle, lastvalue=stoptrain) print("TRAIN") deeplabcut.train_network(path_config_file, shuffle=shuffle) print("EVALUATE") deeplabcut.evaluate_network(path_config_file, Shuffles=[shuffle], plotting=True) print("CUT SHORT VIDEO AND ANALYZE") if shuffle == 0: # Make super short video (so the analysis is quick!) newvideo = deeplabcut.ShortenVideo(video[0], start='00:00:00', stop='00:00:00.4', outsuffix='short', outpath=os.path.join( cfg['project_path'], 'videos'))
"CollectedData_" + cfg['scorer'] + ".csv")) dataFrame.to_hdf(os.path.join(cfg['project_path'], 'labeled-data', videoname, "CollectedData_" + cfg['scorer'] + '.h5'), 'df_with_missing', format='table', mode='w') deeplabcut.create_training_dataset(configfile, Shuffles=[1]) DLC_config = deeplabcut.auxiliaryfunctions.read_plainconfig(path_train_config) DLC_config['save_iters'] = lastvalue DLC_config['display_iters'] = 1 DLC_config['multi_step'] = [[0.001, lastvalue]] DLC_config['init_weights'] = pretrainedDeeperCutweights.split('.index')[0] deeplabcut.auxiliaryfunctions.write_plainconfig(path_train_config, DLC_config) deeplabcut.train_network(configfile, shuffle=1) print("Adding bodypart!") cfg = deeplabcut.auxiliaryfunctions.read_config(configfile) cfg['bodyparts'] = [ 'ankle1', 'knee1', 'hip1', 'hip2', 'knee2', 'ankle2', 'wrist1', 'elbow1', 'shoulder1', 'shoulder2', 'elbow2', 'wrist2', 'chin', 'forehead', 'plus1more' ] deeplabcut.auxiliaryfunctions.write_config(configfile, cfg) print("CREATING-SOME More LABELS FOR THE FRAMES (including the new bodypart!)") cfg = deeplabcut.auxiliaryfunctions.read_config(configfile) frames = [ f for f in os.listdir( os.path.join(cfg['project_path'], 'labeled-data', videoname))
""" # ------------------------------------------------------------------ # Stage VII: training the network # Step 9 # ------------------------------------------------------------------ """ CRITICAL It is recommended to train for thousands of iterations (typically >100,000) until the loss plateaus. The variables display_iters and save_iters in the pose_cfg.yaml file allow the user to alter how often the loss is displayed and how often the (intermediate) weights are stored. """ if "step_9" in stages_to_run or "training_network" in stages_to_run: deeplabcut.train_network(config_path, shuffle=1, trainingsetindex=0, max_snapshots_to_keep=None, displayiters=500, saveiters=5000, maxiters=None, allow_growth=False, gputouse=0, autotune=False, keepdeconvweights=True) # gputouse=0 # saveiters is at 50000 by default """ During training, checkpoints are stored in the subdirectory ‘train’ under the respective iteration directory at user-specified iterations (‘save_iters’). If you wish to restart the training from a specific checkpoint, specify the full path of the checkpoint for the variable init_weights in the pose_cfg. yaml file under the ‘train’ subdirectory before starting to train """ # ------------------------------------------------------------------ # Stage VIII: evaluation of the trained network # Step 10 # ------------------------------------------------------------------ """
def create_training_dataset_CLARA(config, num_shuffles=1, Shuffles=None, windows2linux=False, trainIndexes=None, testIndexes=None): """ Creates a training dataset. Labels from all the extracted frames are merged into a single .h5 file.\n Only the videos included in the config file are used to create this dataset.\n [OPTIONAL] Use the function 'add_new_video' at any stage of the project to add more videos to the project. Parameter ---------- config : string Full path of the config.yaml file as a string. num_shuffles : int, optional Number of shuffles of training dataset to create, i.e. [1,2,3] for num_shuffles=3. Default is set to 1. Shuffles: list of shuffles. Alternatively the user can also give a list of shuffles (integers!). windows2linux: bool. The annotation files contain path formated according to your operating system. If you label on windows but train & evaluate on a unix system (e.g. ubunt, colab, Mac) set this variable to True to convert the paths. Example -------- >>> deeplabcut.create_training_dataset('/analysis/project/reaching-task/config.yaml',num_shuffles=1) Windows: >>> deeplabcut.create_training_dataset('C:\\Users\\Ulf\\looming-task\\config.yaml',Shuffles=[3,17,5]) -------- """ from skimage import io import scipy.io as sio from deeplabcut.utils import auxiliaryfunctions, auxfun_models # Loading metadata from config file: cfg = auxiliaryfunctions.read_config(config) scorer = cfg['scorer'] project_path = cfg['project_path'] # Create path for training sets & store data there trainingsetfolder = auxiliaryfunctions.GetTrainingSetFolder( cfg) #Path concatenation OS platform independent auxiliaryfunctions.attempttomakefolder(Path( os.path.join(project_path, str(trainingsetfolder))), recursive=True) """ Merges all the h5 files for all labeled-datasets (from individual videos). """ AnnotationData = None data_path = Path(os.path.join(project_path, 'labeled-data')) videos = cfg['video_sets'].keys() video_names = [Path(i).stem for i in videos] for i in video_names: try: data = pd.read_hdf((str(data_path / Path(i)) + '/CollectedData_' + cfg['scorer'] + '.h5'), 'df_with_missing') smlData = data.dropna(how='all') smlKeys = list(smlData.index.values) smlKeyLong = list() for sk in smlKeys: smlKeyLong.append('labeled-data/' + str(Path(i)) + '/' + sk) smlData.index = smlKeyLong data = smlData if AnnotationData is None: AnnotationData = data else: AnnotationData = pd.concat([AnnotationData, data]) except FileNotFoundError: print((str(data_path / Path(i)) + '/CollectedData_' + cfg['scorer'] + '.h5'), " not found (perhaps not annotated)") trainingsetfolder_full = Path(os.path.join(project_path, trainingsetfolder)) filename = str( str(trainingsetfolder_full) + '/' + '/CollectedData_' + cfg['scorer']) AnnotationData.to_hdf(filename + '.h5', key='df_with_missing', mode='w') AnnotationData.to_csv(filename + '.csv') #human readable. Data = AnnotationData Data = Data[scorer] #extract labeled data #loading & linking pretrained models net_type = 'resnet_' + str(cfg['resnet']) import deeplabcut parent_path = Path(os.path.dirname(deeplabcut.__file__)) defaultconfigfile = str(parent_path / 'pose_cfg.yaml') model_path, num_shuffles = auxfun_models.Check4weights( net_type, parent_path, num_shuffles) if Shuffles == None: Shuffles = range(1, num_shuffles + 1, 1) else: Shuffles = [i for i in Shuffles if isinstance(i, int)] bodyparts = cfg['bodyparts'] if isinstance(bodyparts, list): parts = bodyparts else: parts = list() categories = list() for cat in bodyparts.keys(): categories.append(cat) for key in categories: for ptname in bodyparts[key]: parts.append(ptname) bodyparts = parts TrainingFraction = cfg['TrainingFraction'] for shuffle in Shuffles: # Creating shuffles starting from 1 for trainFraction in TrainingFraction: #trainIndexes, testIndexes = SplitTrials(range(len(Data.index)), trainFraction) if trainIndexes is None and testIndexes is None: trainIndexes, testIndexes = SplitTrials_CLARA( range(len(Data.index)), trainFraction) else: print( "You passed a split with the following fraction:", len(trainIndexes) * 1. / (len(testIndexes) + len(trainIndexes)) * 100) #################################################### # Generating data structure with labeled information & frame metadata (for deep cut) #################################################### # Make training file! data = [] for jj in trainIndexes: H = {} # load image to get dimensions: filename = Data.index[jj] im = io.imread(os.path.join(cfg['project_path'], filename)) H['image'] = filename if np.ndim(im) == 3: H['size'] = np.array( [np.shape(im)[2], np.shape(im)[0], np.shape(im)[1]]) else: # print "Grayscale!" H['size'] = np.array([1, np.shape(im)[0], np.shape(im)[1]]) indexjoints = 0 joints = np.zeros((len(bodyparts), 3)) * np.nan for bpindex, bodypart in enumerate(bodyparts): if Data[bodypart]['x'][jj] < np.shape( im)[1] and Data[bodypart]['y'][jj] < np.shape( im)[0]: #are labels in image? joints[indexjoints, 0] = int(bpindex) joints[indexjoints, 1] = Data[bodypart]['x'][jj] joints[indexjoints, 2] = Data[bodypart]['y'][jj] indexjoints += 1 joints = joints[np.where(np.prod( np.isfinite(joints), 1))[0], :] # drop NaN, i.e. lines for missing body parts assert (np.prod(np.array(joints[:, 2]) < np.shape(im)[0]) ) # y coordinate within image? assert (np.prod(np.array(joints[:, 1]) < np.shape(im)[1]) ) # x coordinate within image? H['joints'] = np.array(joints, dtype=int) if np.size(joints) > 0: #exclude images without labels data.append(H) if len(trainIndexes) > 0: datafilename, metadatafilename = auxiliaryfunctions.GetDataandMetaDataFilenames( trainingsetfolder, trainFraction, shuffle, cfg) ################################################################################ # Saving metadata (Pickle file) ################################################################################ auxiliaryfunctions.SaveMetadata( os.path.join(project_path, metadatafilename), data, trainIndexes, testIndexes, trainFraction) ################################################################################ # Saving data file (convert to training file for deeper cut (*.mat)) ################################################################################ DTYPE = [('image', 'O'), ('size', 'O'), ('joints', 'O')] MatlabData = np.array( [(np.array([data[item]['image']], dtype='U'), np.array([data[item]['size']]), boxitintoacell_CLARA(data[item]['joints'])) for item in range(len(data))], dtype=DTYPE) sio.savemat(os.path.join(project_path, datafilename), {'dataset': MatlabData}) ################################################################################ # Creating file structure for training & # Test files as well as pose_yaml files (containing training and testing information) ################################################################################# modelfoldername = auxiliaryfunctions.GetModelFolder( trainFraction, shuffle, cfg) auxiliaryfunctions.attempttomakefolder( Path(config).parents[0] / modelfoldername, recursive=True) auxiliaryfunctions.attempttomakefolder( str(Path(config).parents[0] / modelfoldername) + '/' + '/train') auxiliaryfunctions.attempttomakefolder( str(Path(config).parents[0] / modelfoldername) + '/' + '/test') path_train_config = str( os.path.join(cfg['project_path'], Path(modelfoldername), 'train', 'pose_cfg.yaml')) path_test_config = str( os.path.join(cfg['project_path'], Path(modelfoldername), 'test', 'pose_cfg.yaml')) #str(cfg['proj_path']+'/'+Path(modelfoldername) / 'test' / 'pose_cfg.yaml') items2change = { "dataset": datafilename, "metadataset": metadatafilename, "num_joints": len(bodyparts), "all_joints": [[i] for i in range(len(bodyparts))], "all_joints_names": [str(bpt) for bpt in bodyparts], "init_weights": model_path, "project_path": str(cfg['project_path']), "net_type": net_type, "crop": 'False' } trainingdata = MakeTrain_pose_yaml_CLARA( items2change, path_train_config, defaultconfigfile) keys2save = [ "dataset", "num_joints", "all_joints", "all_joints_names", "net_type", 'init_weights', 'global_scale', 'location_refinement', 'locref_stdev' ] MakeTest_pose_yaml_CLARA(trainingdata, keys2save, path_test_config) deeplabcut.train_network(config)
config_path = 'path to yaml file' # extract frame dlc.extract_frames(config_path, 'automatic', 'kmeans') # label the data dlc.label_frames(config_path) # check labels #dlc.check_labels(config_path) # creating training dataset dlc.create_training_dataset(config_path, num_shuffles=1) # start training dlc.train_network(config_path) # evaluate the trained network #dlc.evaluate_network(config_path, plotting=True) full_path_to_videos = [] root = 'add your path' for path in videos: full_path_to_videos.append(root + '/' + path) # video analysis and plotting results dlc.analyze_videos(config_path, full_path_to_videos, shuffle=1, save_as_csv=False, videotype='.mp4')
class tutorial(): def __init__(self, algo, crop, userfeedback, shuffle, saveiters, displayiters, angle, center, scale, filenames): self.algo = "automatic" self.crop = False self.userfeedback = False self.shuffle = 1 self.saveiters = 200 self.displayiters = 100 self.angle = -4.5 self.center = None self.scale = 1.0 #Generate all rotating videos self.filenames = glob.glob('*.mp4') #Return the file name with .mp4 extention def rotate(self, image, angle, center=None, scale=1): #scale = 1: original size rows,cols,ch = image.shape if center == None: center = (cols / 2, rows / 2) M = cv2.getRotationMatrix2D(center, angle, scale) #Matrix: Rotate with center by angles dst = cv2.warpAffine(image,M,(cols,rows)) #After rotation return dst def videorotate(self, filenames, output_name, display_video = False): # capture video cap = cv2.VideoCapture(filename) #read video frame by frame #extract original video frame features sz = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))) fourcc = int(cap.get(cv2.CAP_PROP_FOURCC)) fps = int(cap.get(cv2.CAP_PROP_FPS)) #Make a directory to store the rotated videos path = "./rotated" try: os.mkdir(path) except OSError: pass else: print ("Successfully created the directory %s " % path) #Automatically name the rotated videos file = "./rotated/" + output_name out = cv2.VideoWriter(file, cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), fps, sz) #Integrate all frames to video #Read videos and rotate by certain degrees while(cap.isOpened()): #flip for truning(fliping) frames of video ret,img = cap.read() try: img2 = rotate(img, -4.5) #Flipped Vertically out.write(img2) if display_video == True: cv2.imshow('rotated video',img2) k=cv2.waitKey(30) & 0xff #once you inter Esc capturing will stop if k==27: break except: print (filename, 'successfully rotated!!!' ) break cap.release() out.release() cv2.destroyAllWindows() for i in filenames: output_name = os.path.splitext(i)[0] + " rotated.mp4" cwd = os.chdir("./rotated") #we are using rotated videos cwd = os.getcwd() mp4files = [f for f in listdir(cwd) if isfile(join(cwd, f)) and os.path.splitext(f)[1] == ".mp4"] #Get all mp4 files task='Reaching' # Enter the name of your experiment Task experimenter='Donghan' # Enter the name of the experimenter video=mp4files # Enter the paths of your videos you want to grab frames from. now = datetime.datetime.now() try: path_config_file=deeplabcut.create_new_project(task,experimenter,video, working_directory='/home/donghan/DeepLabCut/data/rotated',copy_videos=True) #change the working directory to where you want the folders created. except: overwrite = input("Do you want to overwrite the folder since it already exists? y/n:") if overwrite == 'y': os.rmdir(task + '-' + experimenter + '-' + str(now.year) + '-' + str(now.month) + '-' + str(now.day)) path_config_file=deeplabcut.create_new_project(task,experimenter,video, working_directory='/home/donghan/DeepLabCut/data/rotated',copy_videos=True) else: continue # The function returns the path, where your project is. # You could also enter this manually (e.g. if the project is already created and you want to pick up, where you stopped...) #path_config_file = '/home/Mackenzie/Reaching/config.yaml' # Enter the path of the config file that was just created from the above step (check the folder) %matplotlib inline deeplabcut.extract_frames(path_config_file,'automatic',crop=False, userfeedback=False) #there are other ways to grab frames, such as by clustering 'kmeans'; please see the paper. #You can change the cropping to false, then delete the checkcropping part! #userfeedback: ask if users would like to continue or stop %gui wx deeplabcut.label_frames(path_config_file) deeplabcut.check_labels(path_config_file) #this creates a subdirectory with the frames + your labels deeplabcut.create_training_dataset(path_config_file) deeplabcut.train_network(path_config_file, shuffle=1, saveiters=200, displayiters=10) #Other parameters include trainingsetindex=0,gputouse=None,max_snapshots_to_keep=5,autotune=False,maxiters=None #Detailed function explanation can be found here https://github.com/AlexEMG/DeepLabCut/blob/efa95129061b1ba1535f7361fe76e9267568a156/deeplabcut/pose_estimation_tensorflow/training.py deeplabcut.evaluate_network(path_config_file) videofile_path = ['1035 SI_A, Aug 15, 13 17 7 rotated.mp4'] #Enter the list of videos to analyze. deeplabcut.analyze_videos(path_config_file,videofile_path) deeplabcut.create_labeled_video(path_config_file,videofile_path)
# DLC Cropping deeplabcut.extract_frames(config_path, mode='automatic', algo='uniform', crop=False, userfeedback=False) deeplabcut.label_frames(config_path) deeplabcut.check_labels(config_path) deeplabcut.create_training_dataset(config_path) # 0 is the GPU number, see in nvidia-smi deeplabcut.train_network(config_path, gputouse=0, saveiters=25000, maxiters=250000) deeplabcut.evaluate_network(config_path, plotting=False) # DLC estimation deeplabcut.analyze_videos(config_path, training_videos, gputouse=0, save_as_csv=True, destfolder=labeled_csv_path) deeplabcut.create_labeled_video(config_path, training_videos, destfolder=labeled_csv_path, draw_skeleton=True)
import os os.environ["DLClight"] = "True" import sys import deeplabcut as dlc shuffleindex = int(sys.argv[1]) gputouse = int(sys.argv[2]) config_path = "/usr/users/onur.serce/dlc_real-alja_onur-2020-04-06/config.yaml" print("'config_path' is:", config_path) print("'dlc.__version__' is:'", dlc.__version__) print("\n") print("This is the name of the program:", sys.argv[0]) print("str(sys.argv):", str(sys.argv), "\n") dlc.train_network(config_path, shuffle=shuffleindex, trainingsetindex=0, max_snapshots_to_keep=None, displayiters=250, saveiters=None, maxiters=None, allow_growth=False, gputouse=gputouse, autotune=False, keepdeconvweights=True) print("dlc_start_training.py with the call", str(sys.argv), "is done!")
TRAIN_SIZE, 1, cfg, cfg["project_path"] ) pose_config_path = os.path.join(model_folder, "train", "pose_cfg.yaml") edits = { "global_scale": 0.5, "batch_size": 1, "save_iters": N_ITER, "display_iters": N_ITER // 2, "crop_size": [200, 200], # "multi_step": [[0.001, N_ITER]], } deeplabcut.auxiliaryfunctions.edit_config(pose_config_path, edits) print("Pose config edited.") print("Training network...") deeplabcut.train_network(config_path, maxiters=N_ITER) print("Network trained.") print("Evaluating network...") deeplabcut.evaluate_network(config_path, plotting=True) print("Network evaluated....") print("Extracting maps...") deeplabcut.extract_save_all_maps(config_path, Indices=[0, 1, 2]) new_video_path = deeplabcut.ShortenVideo( video_path, start="00:00:00", stop="00:00:01", outsuffix="short",
print("CREATING TRAININGSET") deeplabcut.create_training_dataset(path_config_file) posefile=os.path.join(cfg['project_path'],'dlc-models/iteration-'+str(cfg['iteration'])+'/'+ cfg['Task'] + cfg['date'] + '-trainset' + str(int(cfg['TrainingFraction'][0] * 100)) + 'shuffle' + str(1),'train/pose_cfg.yaml') DLC_config=deeplabcut.auxiliaryfunctions.read_plainconfig(posefile) DLC_config['save_iters']=10 DLC_config['display_iters']=2 DLC_config['multi_step']=[[0.001,10]] print("CHANGING training parameters to end quickly!") deeplabcut.auxiliaryfunctions.write_plainconfig(posefile,DLC_config) print("TRAIN") deeplabcut.train_network(path_config_file) print("EVALUATE") deeplabcut.evaluate_network(path_config_file,plotting=True) print("CUT SHORT VIDEO AND ANALYZE") # Make super short video (so the analysis is quick!) vname='brief' newvideo=os.path.join(cfg['project_path'],'videos',vname+'.mp4') try: #you need ffmpeg command line interface subprocess.call(['ffmpeg','-i',video[0],'-ss','00:00:00','-to','00:00:00.4','-c','copy',newvideo]) except: #for windows: from moviepy.editor import VideoFileClip,VideoClip clip = VideoFileClip(video[0])
def train_network(self): deeplabcut.train_network(self.full_config_path(), shuffle=1, gputouse=0)
posefile, _, _ = deeplabcut.return_train_network_path(path_config_file, shuffle=shuffle) if shuffle % 3 == 1: # imgaug edits = {"rotation": 180, "motion_blur": True} DLC_config = deeplabcut.auxiliaryfunctions.edit_config(posefile, edits) elif shuffle % 3 == 0: # Tensorpack: edits = {"rotation": 180, "noise_sigma": 0.01} DLC_config = deeplabcut.auxiliaryfunctions.edit_config(posefile, edits) print("TRAIN NETWORK", shuffle) deeplabcut.train_network( path_config_file, shuffle=shuffle, saveiters=10000, displayiters=200, maxiters=maxiters, max_snapshots_to_keep=11, ) print("EVALUATE") deeplabcut.evaluate_network(path_config_file, Shuffles=[shuffle], plotting=True) print("Analyze Video") videofile_path = os.path.join(os.getcwd(), "openfield-Pranav-2018-10-30", "videos", "m3v1mp4.mp4") deeplabcut.analyze_videos(path_config_file, [videofile_path],
# Loading example data set path_config_file = os.path.join(os.getcwd(), "openfield-Pranav-2018-10-30/config.yaml") deeplabcut.load_demo_data(path_config_file) shuffle = 13 deeplabcut.create_training_dataset(path_config_file, Shuffles=[shuffle]) cfg = deeplabcut.auxiliaryfunctions.read_config(path_config_file) # example how to set pose config variables: posefile, _, _ = deeplabcut.return_train_network_path(path_config_file, shuffle=shuffle) edits = {"save_iters": 15000, "display_iters": 1000, "multi_step": [[0.005, 15001]]} DLC_config = deeplabcut.auxiliaryfunctions.edit_config(posefile, edits) print("TRAIN NETWORK") deeplabcut.train_network(path_config_file, shuffle=shuffle, max_snapshots_to_keep=3) print("EVALUATE") deeplabcut.evaluate_network(path_config_file, Shuffles=[shuffle], plotting=True) print("Analyze Video") videofile_path = os.path.join( os.getcwd(), "openfield-Pranav-2018-10-30", "videos", "m3v1mp4.mp4" ) deeplabcut.analyze_videos( path_config_file, [videofile_path], shuffle=shuffle ) # ,videotype='.mp4') print("Create Labeled Video") deeplabcut.create_labeled_video( path_config_file, [videofile_path], save_frames=False, shuffle=shuffle
def cli_create_project(project_path, video_paths, name='eye_video_demo', experimenter='experimenter', recursive=False, format_='mp4', exclude=[], num_frames=20, train=False, analyze=False, create_videos=False): """run all steps to create a DLC project""" if len(video_paths) == 0: # use provided example video_files = [op.join(op.split(op.realpath(__file__))[0], 'data', 'example_eye_camera_video.mp4')] else: # get video files video_files = [] for vp in list(video_paths): video_files.extend(get_video_files(vp, recursive, exclude, file_format=format_.lower())) # list all video files (and convert to mp4 if required) for i, vf in enumerate(video_files): print("found video file: %s" % vf) if op.splitext(vf)[1] == '.h264': vide_files[i] = convert_h264_to_mp4(vf) # create a new project config_path = deeplabcut.create_new_project(name, experimenter, video_files, working_directory=project_path, copy_videos=False) config = deeplabcut.utils.read_config(config_path) config['bodyparts'] = ['pupil_center', 'nasal_corner', 'temporal_corner'] config['numframes2pick'] = num_frames deeplabcut.utils.write_config(config_path, config) # extract and label frames deeplabcut.extract_frames(config_path, mode='automatic', algo='kmeans', crop=True) deeplabcut.label_frames(config_path) deeplabcut.check_labels(config_path) # create training dataset deeplabcut.create_training_dataset(config_path) if train: # train and evaluate the network deeplabcut.train_network(config_path) deeplabcut.evaluate_network(config_path) if analyze: deeplabcut.analyze_videos(config_path, video_files) if create_videos: # create a video deeplabcut.create_labeled_video(config_path, video_files)
posefile = os.path.join( cfg['project_path'], 'dlc-models/iteration-' + str(cfg['iteration']) + '/' + cfg['Task'] + cfg['date'] + '-trainset' + str(int(cfg['TrainingFraction'][0] * 100)) + 'shuffle' + str(1), 'train/pose_cfg.yaml') DLC_config = deeplabcut.auxiliaryfunctions.read_plainconfig(posefile) DLC_config['save_iters'] = numiter DLC_config['display_iters'] = 2 DLC_config['multi_step'] = [[0.001, numiter]] print("CHANGING training parameters to end quickly!") deeplabcut.auxiliaryfunctions.write_plainconfig(posefile, DLC_config) print("TRAIN") deeplabcut.train_network(path_config_file) print("EVALUATE") deeplabcut.evaluate_network(path_config_file, plotting=True) #deeplabcut.evaluate_network(path_config_file,plotting=True,trainingsetindex=33) print("CUT SHORT VIDEO AND ANALYZE (with dynamic cropping!)") # Make super short video (so the analysis is quick!) try: #you need ffmpeg command line interface #subprocess.call(['ffmpeg','-i',video[0],'-ss','00:00:00','-to','00:00:00.4','-c','copy',newvideo]) newvideo = deeplabcut.ShortenVideo(video[0], start='00:00:00', stop='00:00:00.4', outsuffix='short', outpath=os.path.join(
import deeplabcut import os configpath = os.path.join( '/home/neudata/Desktop/DeepLabCut/examples/openfield-Pranav-2018-10-30/config.yaml' ) deeplabcut.load_demo_data(configpath) deeplabcut.train_network(configpath, maxiters=5) #trains for 5 iterations #manually test GUI... deeplabcut.label_frames(configpath)
posefile = os.path.join( cfg['project_path'], 'dlc-models/iteration-' + str(cfg['iteration']) + '/' + cfg['Task'] + cfg['date'] + '-trainset' + str(int(cfg['TrainingFraction'][0] * 100)) + 'shuffle' + str(1), 'train/pose_cfg.yaml') DLC_config = dlc.auxiliaryfunctions.read_plainconfig(posefile) DLC_config['save_iters'] = numiter DLC_config['display_iters'] = 2 DLC_config['multi_step'] = [[0.001, numiter]] print("CHANGING training parameters to end quickly!") dlc.auxiliaryfunctions.write_plainconfig(posefile, DLC_config) print("TRAIN") dlc.train_network(path_config_file) print("EVALUATE") dlc.evaluate_network(path_config_file, plotting=True) videotest = os.path.join(cfg['project_path'], 'videos', videoname + ".avi") print(videotest) # quicker variant ''' print("VIDEO ANALYSIS") dlc.analyze_videos(path_config_file, [videotest], save_as_csv=True) print("CREATE VIDEO") dlc.create_labeled_video(path_config_file,[videotest], save_frames=False)
import os os.environ["DLClight"] = "True" import deeplabcut os.system('echo $$') os.system('echo imported') config_path = '/dartfs-hpc/rc/home/7/f002qw7/thesis/ir_test-markt-2020-02-28/config.yaml' os.system('echo config_path') deeplabcut.train_network(config_path) os.system('echo done')
# changed the cropping dimensions in the config.yaml file %gui wx deeplabcut.label_frames(path_config_file) # Lables have now been created deeplabcut.check_labels(path_config_file) #this creates a subdirectory with the frames + your labels # Reviewed the labels, the seem to be ok # Downloading the ResNets dataset: deeplabcut.create_training_dataset(path_config_file) # Training the dataset deeplabcut.train_network(path_config_file) # Evaluating the results deeplabcut.evaluate_network(path_config_file) # Analyzing video videofile_path = ['dlc-blinking/an3_vid2_full/eyes_only-Guy-2019-01-25/videos/animal_3_video_2_150fps_correct.mp4', 'dlc-blinking/an3_vid2_full/eyes_only-Guy-2019-01-25/videos/march_8_animal_1_video_150fps_correct.mp4'] #Enter the list of videos to analyze. videofile_path = ['dlc-blinking/whisk/whisk_only-Guy-2019-02-01/videos/crush_19_01_07_animal_3.mp4', 'dlc-blinking/whisk/whisk_only-Guy-2019-02-01/videos/animal_3_video_2_150fps_correct.mp4'] deeplabcut.analyze_videos(path_config_file,videofile_path,save_as_csv=True) deeplabcut.create_labeled_video(path_config_file, ['D:\\dlc-blinking\\an3_vid2_full\\whisk_only-Guy-2019-02-01\\videos\\crush_19_01_07_animal_3.mp4'], save_frames=True) deeplabcut.create_labeled_video(path_config_file, ['D:\\dlc-blinking\\whisk\\whisk_only-Guy-2019-02-01\\videos\\animal_3_video_2_150fps_correct.mp4'], save_frames=True)
if not traindatasetexist: # create training dataset if not exist deeplabcut.check_labels(path_config_file) deeplabcut.create_training_dataset(path_config_file, num_shuffles=1) else: print("Training dataset exists") if tag_train: # train data argments, saveiters, displayiters, maxiters are the same as in pose_cfg.yaml, here are for visualization saveiters = 10000 displayiters = 1000 maxiters = 100000 train_start = time.time() deeplabcut.train_network(path_config_file, shuffle=1, saveiters=saveiters, displayiters=displayiters, maxiters=maxiters) train_end = time.time() train_time = train_end - train_start print('maxiters is %d' % maxiters) print('training time is %f' % train_time) with open(os.path.join(path_prj, 'traintime.csv'), 'w') as csv_file: csv_writer = csv.writer(csv_file, delimiter=',') csv_writer.writerow(['maxiters', 'training time']) csv_writer.writerow([maxiters, train_time]) else: print("No need to train!") if tag_evaluation: deeplabcut.evaluate_network(path_config_file, plotting=True) # evaluation