def main():
plt.close('all')
exit = False
while exit == False:
choice = print_usage("start")
if choice == "exit":
exit = True
sys.exit(0)
elif choice == "1":
command = create_dict_list("/data/11012579/projects/", 0)
elif choice == "2":
command = print_usage("program")
command = command.split(" ")
map_with_videos = create_dict_list("/data/11012579/videos/", 0)[0]
command.append("/data/11012579/videos/" + map_with_videos + "/" +
create_dict_list(
"/data/11012579/videos/" + map_with_videos +
"/", 1)[0])
if len(command) == 1:
exit = usingDeep(
'/data/11012579/projects/' + command[0] + '/config.yaml',
command[0])
elif len(command) == 3:
print("Check project name: \nName of project:" + command[0] +
"\nYour name:" + command[1] + "\nPath to video:" +
command[2] +
"\nto contineu type: check \nTo change type: redo")
input_2 = "redo/check"
while input_2 not in ["check", "redo"]:
print("Type check or redo!")
input_2 = str(input())
if input_2 == "check":
deeplabcut.create_new_project(
command[0],
command[1], [command[2]],
working_directory='/data/11012579/projects',
copy_videos=False)
path_config = '/data/11012579/projects/' + command[
0] + '-' + command[1] + '-' + str(
date.today()) + '/config.yaml'
print("\nGo to projects -> your project -> config.yaml\
\nEdit: numframes2pick to select how manny frames you want to add \
\nEdit: bodyparts and type the bodyparts you want to keep track of\
\nEdit: Skeleton to draw lines between the tracked bodyparts\
\nRun ipython home.py to continue")
exit = usingDeep(path_config, command[0])
else:
print_usage("error")
def create_project(self):
# Get project directory
project_dir = self.project_dir
# Check if project exists
if project_dir.exists():
print("The project directory already exists.")
else:
# Creates new project then renames according to task and subject
print("The project directory does not exist.")
# Create file name as is created in deeplabcut.create_new_project
from datetime import datetime as dt
# Deeplabcut uses the creation name in the date. We want to change this to the study date
date = dt.today().strftime('%Y-%m-%d')
old_project_dir = Path("-".join([self.task, self.subject, date]))
# Create new project
deeplabcut.create_new_project(
self.task,
self.subject,
self.video,
working_directory=self.project_dir.resolve().parent,
copy_videos=True)
# Rename project to have project date not current date
old_project_dir.rename(project_dir)
from deeplabcut.utils import auxiliaryfunctions
# Get config file path
main_config_file = Path(self.project_dir).resolve() / self.config
# load config.yaml
main_config = auxiliaryfunctions.read_config(main_config_file)
# Update values in config file:
main_config['bodyparts'] = self.bodyparts
main_config['date'] = self.date
main_config['numframes2pick'] = self.numframes2pick
# Write dictionary to yaml config file
auxiliaryfunctions.write_config(main_config_file, main_config)
# Update project paths
self.update_project_paths()
return
def create():
name = request.json['project_name']
experimenter = request.json['experimenter']
config_path = deeplabcut.create_new_project(name, experimenter, [])
projectId = projectRepository.insert_one({
'project_name': name,
'experimenter': experimenter,
'config_path': config_path
}).inserted_id
return "Project " + str(
projectId) + " created." #TODO: Return real response
def create_dlc_project(name, author, files, props):
config_path = deeplabcut.create_new_project(name, author, files)
update_dlc_config(config_path, props)
deeplabcut.extract_frames(config_path,
'automatic',
'kmeans',
userfeedback=False)
deeplabcut.label_frames(config_path)
deeplabcut.check_labels(config_path)
return config_path.replace('/config.yaml', '')
def clicked_create():
self.select_working_directory(window)
window.destroy()
self.get_window_for_project_name()
self.path_config_file = deeplabcut.create_new_project(self.name_of_project, self.experimenter, self.video_list,
working_directory=self.working_directory,
copy_videos=True)
self.select_body_parts()
self.add_new_videos()
print(self.video_list)
if len(self.video_list) > 0:
deeplabcut.add_new_videos(self.path_config_file, self.video_list, copy_videos=True)
deeplabcut.extract_frames(self.path_config_file, 'automatic', 'kmeans', checkcropping=False, crop=True)
self.working_window_for_deeplabcut()
def setup():
# Check if having admin privilege if running Windows
if helpers.platform() == "Windows" and helpers.has_admin() == False:
print("Run with Administrative privilege for Windows")
# todo output something so that the batch script would terminate immediately
return
pre_config_handler = YAML(typ='safe')
with open("../pre_config.yaml", 'r') as stream:
pre_config = pre_config_handler.load(stream)
none_handler = helpers.ConfigReader(pre_config)
task = none_handler.read("task")
researchers = none_handler.read("researchers")
relative_path_to_working_directory = none_handler.read("relative_path_to_working_directory")
# Get full path here
video_full_paths = helpers.get_video_full_paths(pre_config["relative_path_to_videos"])
# Create project
path_config_file = dlc.create_new_project(task, researchers, video_full_paths, working_directory=relative_path_to_working_directory, copy_videos=False)
# Store the project path for future processes
path_config = {"path_config_file" : path_config_file}
with open('./config.json', 'w+') as fp:
json.dump(path_config, fp, indent=4)
# Change the auto generated config file
bodyparts = none_handler.read("bodyparts")
numframes2pick = none_handler.read("numframes2pick")
config_handler = YAML()
config_handler.preserve_quotes = True
with open(path_config_file, 'r') as stream:
config = config_handler.load(stream)
config["bodyparts"] = bodyparts
config["numframes2pick"] = numframes2pick
with open(path_config_file, 'w') as fp:
config_handler.dump(config, fp)
frame_extraction_mode = none_handler.read("frame_extraction_mode")
frame_extraction_algorithm = none_handler.read("frame_extraction_algorithm")
extract.extract(path_config_file, mode=frame_extraction_mode, algo=frame_extraction_algorithm)
def export_dlc(expdir,
dlcdir,
*,
session=None,
movlist: parse_movlist = None,
antlist=None,
nimages=100,
video=False,
username='******'):
"""Export trainset for DeepLabCut"""
import deeplabcut as dlc
from antrax.dlc import create_trainset
ex = axExperiment(expdir, session)
if isdir(dlcdir) and not isfile(dlcdir + '/config.yaml'):
report(
'E',
'directory exists, but does contain a deeplabcut configuration file! check your parameters'
)
return
if not isdir(dlcdir):
report('I', 'DLC project does not exists, creating')
pathlist = os.path.normpath(dlcdir).split(os.path.sep)
wd = os.path.sep.join(pathlist[:-1])
projname = pathlist[-1]
dlcdir = dlc.create_new_project(projname,
username, [],
working_directory=wd)
create_trainset(ex,
dlcdir,
n=nimages,
antlist=antlist,
movlist=movlist,
vid=video)
def DLCPrep(project_name,
your_name,
img_path,
output_dir_base,
copy_videos_bool=True):
img_array = []
filenames = glob.glob(os.path.join(img_path, "*.png"))
filenames.sort(key=natural_sort_key)
size = (512, 512)
for filename in filenames:
img = cv2.imread(filename)
height, width, layers = img.shape
size = (width, height)
img_array.append(img)
if len(img_array) > 0:
if not os.path.isdir(os.path.join(output_dir_base, "img_for_label")):
os.mkdir(os.path.join(output_dir_base, "img_for_label"))
video_output_path = os.path.join(output_dir_base, "img_for_label")
video_name = os.path.join(video_output_path, "video_for_label.mp4")
if not os.path.isdir(video_output_path):
os.mkdir(video_output_path)
out = cv2.VideoWriter(video_name, cv2.VideoWriter_fourcc(*"MP4V"), 30,
size)
for i in range(len(img_array)):
out.write(img_array[i])
out.release()
config_path = deeplabcut.create_new_project(
project_name,
your_name,
[video_name],
copy_videos=copy_videos_bool,
working_directory=output_dir_base,
)
return config_path
task = 'gaitdatatestv2' # use the videos of dlc examples
experimenter = 'Jordan'
if prjexist:
# project already exist
print("Use exist project!!!")
path_prj = os.path.join(os.getcwd(), 'OurPrj',
task + '-' + experimenter + '-2019-04-16')
path_config_file = os.path.join(path_prj, 'config.yaml')
else:
video = os.path.join(os.getcwd(), 'OurPrj',
task + '-' + experimenter + '-2019-04-16', 'videos',
'Az_Neural.avi')
path_config_file = deeplabcut.create_new_project(
task,
experimenter,
video,
working_directory=working_dir,
copy_videos=True)
path_prj, config_file_name = os.path.split(path_config_file)
if not framesextracted:
print("Extracting frame from videos")
deeplabcut.extract_frames(path_config_file,
'automatic',
'uniform',
crop=False)
else:
print("frames have been extracted already!!")
if not frameslabeled:
print("Need labeled frames")
# "filterpredictions" (set videos_to_filter_predictions variable)
# "step_12" or "plot_trajectories" (set videos_to_plot_trajectories variable)
# 'step_12_bis" or "analyzeskeleton"
# "step_13" or "create_labeled_video" (set videos_to_create_with_labels variable)
# "step_14" or "extract_outlier_frames" (set videos_to_extract_outlier_frames variable)
# "step_15" or "refine_labels"
# "step_16" or "merge_datasets"
stages_to_run = ["analyzeskeleton"]
# ------------------------------------------------------------------
# STAGE I: Stage I: opening DeepLabCut and creation of a new project
# Steps 1, 2
# ------------------------------------------------------------------
if "step_2" in stages_to_run or "create_new_project" in stages_to_run:
config_path = deeplabcut.create_new_project(project="test_valentin", experimenter="Robin", videos=[movie_file],
copy_videos=True,
videotype='.avi',
working_directory=working_dir)
if "step_2_bis" in stages_to_run or "add_new_videos" in stages_to_run:
deeplabcut.add_new_videos(config=config_path, videos=new_videos_to_add, copy_videos=True)
# ------------------------------------------------------------------
# STAGE II: configuration of the project, open the config.yaml file
# Step 3
# ------------------------------------------------------------------
# start stop indicate which portion of the movie to extract the frames from, ex 0 & 0.5 means first 50%
"""
Exemple of config:
bodyparts:
- forepaw
def create_new_project(self, event):
"""
Finally create the new project
"""
if self.sel_config.IsShown():
self.cfg = self.sel_config.GetPath()
if self.cfg == "":
wx.MessageBox(
"Please choose the config.yaml file to load the project",
"Error",
wx.OK | wx.ICON_ERROR,
)
self.loaded = False
else:
wx.MessageBox("Project Loaded!", "Info",
wx.OK | wx.ICON_INFORMATION)
self.loaded = True
self.sel_vids_new.Enable(True)
self.addvid.Enable(True)
self.edit_config_file.Enable(True)
else:
self.task = self.proj_name_txt_box.GetValue()
self.scorer = self.exp_txt_box.GetValue()
if self.task != "" and self.scorer != "" and self.filelist != []:
self.cfg = deeplabcut.create_new_project(
self.task,
self.scorer,
self.filelist,
self.dir,
copy_videos=self.copy,
multianimal=self.multi_choice.IsChecked(),
)
else:
wx.MessageBox(
"Some of the enteries are missing.\n\nMake sure that the task and experimenter name are specified and videos are selected!",
"Error",
wx.OK | wx.ICON_ERROR,
)
self.cfg = False
if self.cfg:
wx.MessageBox("New Project Created", "Info",
wx.OK | wx.ICON_INFORMATION)
self.loaded = True
self.edit_config_file.Enable(True)
# Remove the pages in case the user goes back to the create new project and creates/load a new project
if self.parent.GetPageCount() > 3:
for i in range(2, self.parent.GetPageCount()):
self.parent.RemovePage(2)
self.parent.Layout()
# Add all the other pages
if self.loaded:
self.edit_config_file.Enable(True)
cfg = auxiliaryfunctions.read_config(self.cfg)
if self.parent.GetPageCount() < 3:
page3 = Extract_frames(self.parent, self.gui_size, self.cfg)
self.parent.AddPage(page3, "Extract frames")
page4 = Label_frames(self.parent, self.gui_size, self.cfg)
self.parent.AddPage(page4, "Label frames")
page5 = Create_training_dataset(self.parent, self.gui_size,
self.cfg)
self.parent.AddPage(page5, "Create training dataset")
page6 = Train_network(self.parent, self.gui_size, self.cfg)
self.parent.AddPage(page6, "Train network")
page7 = Evaluate_network(self.parent, self.gui_size, self.cfg)
self.parent.AddPage(page7, "Evaluate network")
page12 = Video_Editing(self.parent, self.gui_size, self.cfg)
self.parent.AddPage(page12, "Video editor")
page8 = Analyze_videos(self.parent, self.gui_size, self.cfg)
self.parent.AddPage(page8, "Analyze videos")
if cfg.get("multianimalproject", False):
page = Refine_tracklets(self.parent, self.gui_size,
self.cfg)
self.parent.AddPage(page, "Refine tracklets")
page11 = Create_Labeled_Videos(self.parent, self.gui_size,
self.cfg)
self.parent.AddPage(page11, "Create videos")
page9 = Extract_outlier_frames(self.parent, self.gui_size,
self.cfg)
self.parent.AddPage(page9, "Extract outlier frames")
page10 = Refine_labels(self.parent, self.gui_size, self.cfg,
page5)
self.parent.AddPage(page10, "Refine labels")
self.edit_config_file.Enable(True)
# check GPU (optional)
from tensorflow.python.client import device_lib
device_lib.list_local_devices()
# start projects
import glob
import os
os.chdir('chage to your path')
videos = glob.glob('*.mp4')
learningVideo = ["add video name for learning"]
config_path = dlc.create_new_project('PJ name',
'my name',
learningVideo,
working_directory='add your directory',
copy_videos=False)
# if the project was already created, run this
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)
# In[4]:
pwd
# In[5]:
ls
# In[6]:
deeplabcut.create_new_project('Mouse', 'Amr', ['/home/amr/Trial_DeepLabCut/mouse.avi'])
# # <font color=red>Now, You open the config.yaml file to modify the body part you want to track and if you want, you can modify the number of frames to pick</font>
# In[3]:
path_config = '/home/amr/Trial_DeepLabCut/Mouse-Amr-2018-12-03/config.yaml'
# In[4]:
deeplabcut.extract_frames(path_config, 'automatic', 'kmeans')
NET = "dlcrnet_ms5"
# Always test a different model from list above
NET = random.choice(MODELS)
basepath = os.path.dirname(os.path.realpath(__file__))
DESTFOLDER = basepath
video = "m3v1mp4"
video_path = os.path.join(
basepath, "openfield-Pranav-2018-10-30", "videos", video + ".mp4"
)
print("Creating project...")
config_path = deeplabcut.create_new_project(
TASK, SCORER, [video_path], copy_videos=True, multianimal=True
)
print("Project created.")
print("Editing config...")
cfg = auxiliaryfunctions.edit_config(
config_path,
{
"numframes2pick": NUM_FRAMES,
"TrainingFraction": [TRAIN_SIZE],
"identity": True,
"uniquebodyparts": ["corner1", "corner2"],
},
)
print("Config edited.")
import os
experimenter = 'Theresa'
project = 'Armina_model_1'
videos = glob.glob(
'/home/weertman/Documents/Theresa_FHL/Armina_DeepLabCut/random_train_images/*.png'
)
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)
dfolder = None
net_type = 'resnet_50' #'mobilenet_v2_0.35' #'resnet_50'
augmenter_type = 'default'
augmenter_type2 = 'imgaug'
if platform.system() == 'Darwin' or platform.system() == 'Windows':
print("On Windows/OSX tensorpack is not tested by default.")
augmenter_type3 = 'imgaug'
else:
augmenter_type3 = 'tensorpack' #Does not work on WINDOWS
numiter = 3
print("CREATING PROJECT")
path_config_file = dlc.create_new_project(task,
scorer,
video,
copy_videos=True)
cfg = dlc.auxiliaryfunctions.read_config(path_config_file)
cfg['numframes2pick'] = 5
cfg['pcutoff'] = 0.01
cfg['TrainingFraction'] = [.8]
cfg['skeleton'] = [['bodypart1', 'bodypart2'], ['bodypart1', 'bodypart3']]
dlc.auxiliaryfunctions.write_config(path_config_file, cfg)
print("EXTRACTING FRAMES")
dlc.extract_frames(path_config_file, mode='automatic', userfeedback=False)
print("CREATING SOME LABELS FOR THE FRAMES")
frames = os.listdir(
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)
for cs in camera_config['serials']:
tv = os.path.join(session_config['session_path'],
session_config['cam_dicts'][cs]['ud_video'])
tv2 = os.path.join(videos_collection_dir,
'{}_{}'.format(session_id,
os.path.split(tv)[-1]))
#shutil.copyfile(tv, tv2)
training_videos.append(tv2)
# %% 2a Make a new DLC project (this or 2b)
dlc_prj_name = '2019.12.20_8camsNoMarkers'
scorer = 'AS'
prj_date = '2019-12-23'
config_path = deeplabcut.create_new_project(dlc_prj_name,
scorer,
training_videos,
working_directory=BASE_DIR,
copy_videos=False)
dlc_proj_name = '-'.join([dlc_prj_name, scorer, prj_date])
proj_path = os.path.join(BASE_DIR, dlc_proj_name)
if config_path is None:
config_path = os.path.join(proj_path, 'config.yaml')
labeled_csv_path = os.path.join(proj_path, 'labeled_videos')
if not os.path.isdir(labeled_csv_path):
os.mkdir(labeled_csv_path)
print('New config_path: "{}"'.format(config_path))
# Edit the config file to represent your tracking
import deeplabcut as dlc
import os
import json
import helpers
config = {}
task = 'whiskers' # Enter the name of your experiment Task
experimenter = 'sail' # Enter the name of the experimenter
# get full path here
video_full_paths = helpers.get_video_full_paths()
# create project
path_config_file = dlc.create_new_project(
task,
experimenter,
video_full_paths,
working_directory=os.getcwd(),
copy_videos=False
) #change the working directory to where you want the folders created.
config["path_config_file"] = path_config_file
with open('config.json', 'w') as fp:
json.dump(config, fp, indent=4)
def setupProject(projectName, videos):
return deeplabcut.create_new_project(projectName, 'joshua', videos)
from os.path import join
from ExperimentSpecificCode._2018_Chronic_Neuroseeker_TouchingLight._2019_06_25_AK_47p2 import constants as const
import deeplabcut
# ----------------------------------------------------------------------------------------------------------------------
# FOLDERS NAMES
date = 8
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)
def create_new_project(self, event):
"""
Finally create the new project
"""
if self.sel_config.IsShown():
self.cfg = self.sel_config.GetPath()
if self.cfg == "":
wx.MessageBox(
'Please choose the config.yaml file to load the project',
'Error', wx.OK | wx.ICON_ERROR)
self.loaded = False
else:
wx.MessageBox('Project Loaded!', 'Info',
wx.OK | wx.ICON_INFORMATION)
self.loaded = True
self.edit_config_file.Enable(True)
else:
self.task = self.proj_name_txt_box.GetValue()
self.scorer = self.exp_txt_box.GetValue()
if self.task and self.scorer and len(self.filelist):
self.cfg = deeplabcut.create_new_project(
self.task, self.scorer, self.filelist, self.dir,
self.copy_choice.IsChecked())
else:
wx.MessageBox(
'Some of the entries are missing.\n\nMake sure that the task and experimenter name are specified and videos are selected!',
'Error', wx.OK | wx.ICON_ERROR)
self.cfg = False
self.loaded = False
if self.cfg:
wx.MessageBox('New Project Created', 'Info',
wx.OK | wx.ICON_INFORMATION)
self.loaded = True
self.edit_config_file.Enable(True)
# Remove the pages in case the user goes back to the create new project and creates/load a new project
if self.parent.GetPageCount() > 3:
for i in range(2, self.parent.GetPageCount()):
self.parent.RemovePage(2)
self.parent.Layout()
# Add all the other pages
if self.loaded:
self.edit_config_file.Enable(True)
if self.parent.GetPageCount() < 3:
page3 = Extract_frames(self.parent, self.gui_size, self.cfg)
self.parent.AddPage(page3, "Extract frames")
page4 = Label_frames(self.parent, self.gui_size, self.cfg)
self.parent.AddPage(page4, "Label frames")
page5 = Create_training_dataset(self.parent, self.gui_size,
self.cfg)
self.parent.AddPage(page5, "Create training dataset")
page6 = Train_network(self.parent, self.gui_size, self.cfg)
self.parent.AddPage(page6, "Train network")
page7 = Evaluate_network(self.parent, self.gui_size, self.cfg)
self.parent.AddPage(page7, "Evaluate network")
page8 = Analyze_videos(self.parent, self.gui_size, self.cfg)
self.parent.AddPage(page8, "Analyze videos")
page11 = Create_Labeled_Videos(self.parent, self.gui_size,
self.cfg)
self.parent.AddPage(page11, "Create Videos")
page9 = Extract_outlier_frames(self.parent, self.gui_size,
self.cfg)
self.parent.AddPage(page9, "Extract outlier frames")
page10 = Refine_labels(self.parent, self.gui_size, self.cfg,
page5)
self.parent.AddPage(page10, "Refine labels")
self.edit_config_file.Enable(True)
def get_video(exp_path):
for file in os.listdir(exp_path):
if "eye.mp4" in file:
return os.path.join(exp_path, file)
raise ValueError(f"No eye.mp4 found in {exp_path}")
def get_ls_of_all_videos(drive):
ls = []
add2ls = lambda path: ls.append(get_video(path))
apply_to_all_one_plane_recordings(drive, add2ls)
return ls
if __name__ == "__main__":
project_name = "mousepupils"
creator = "viviani"
vids = get_ls_of_all_videos("H:\\")
dlc.create_new_project(project_name, creator, vids, copy_vids=True)
root = "C:/Users/viviani/Desktop/micepupils-viviani-2020-07-09/"
config_path = root + "config.yaml"
vid_dir = root + "videos/"
vids = [vid_dir + file for file in os.listdir(vid_dir) if ".mp4" in file]
with open(config_path, "w") as file:
with open("config.yaml", "r") as source:
for line in source:
file.write(line)
dlc.label_frames(config_path, vids)
#Once frames are labelled, call dlc.create_training_dataset
#and then dlc.train_network
import pandas as pd
import numpy as np
print("Imported DLC!")
basepath=os.path.dirname(os.path.abspath('DLC_Helper.py'))
# videoname='reachingvideo1'
# video=[os.path.join(basepath,'Reaching-Mackenzie-2018-08-30','videos',videoname+'.avi')]
videoname = input("What is the name of the video? *No need for file type like .mpg or .avi\n")
video = input("What is the full path of the video? *Include file type like .mpg or .avi\n")
#to test destination folder:
#dfolder=basepath
dfolder= input('What is the working directory?\n')
print("CREATING PROJECT")
path_config_file=deeplabcut.create_new_project(task,scorer,video,dfolder,copy_videos=True)
cfg=deeplabcut.auxiliaryfunctions.read_config(path_config_file)
cfg['numframes2pick']=5
cfg['pcutoff']=0.01
cfg['TrainingFraction']=[.8]
cfg['skeleton']=[['bodypart1','bodypart2'],['bodypart1','bodypart3']]
deeplabcut.auxiliaryfunctions.write_config(path_config_file,cfg)
print("EXTRACTING FRAMES")
deeplabcut.extract_frames(path_config_file,mode='automatic',userfeedback=False)
print("CREATING-SOME LABELS FOR THE FRAMES")
frames=os.listdir(os.path.join(cfg['project_path'],'labeled-data',videoname))
#As this next step is manual, we update the labels by putting them on the diagonal (fixed for all frames)
def create_pretrained_human_project(project,
experimenter,
videos,
working_directory=None,
copy_videos=False,
videotype='.avi',
createlabeledvideo=True,
analyzevideo=True):
"""
Creates a demo human project and analyzes a video with ResNet 101 weights pretrained on MPII Human Pose. This is from the DeeperCut paper by Insafutdinov et al. https://arxiv.org/abs/1605.03170 Please make sure to cite it too if you use this code!
Parameters
----------
project : string
String containing the name of the project.
experimenter : string
String containing the name of the experimenter.
videos : list
A list of string containing the full paths of the videos to include in the project.
working_directory : string, optional
The directory where the project will be created. The default is the ``current working directory``; if provided, it must be a string.
copy_videos : bool, optional
If this is set to True, the videos are copied to the ``videos`` directory. If it is False,symlink of the videos are copied to the project/videos directory. The default is ``False``; if provided it must be either
``True`` or ``False``.
analyzevideo " bool, optional
If true, then the video is analzyed and a labeled video is created. If false, then only the project will be created and the weights downloaded. You can then access them
Example
--------
Linux/MacOs
>>> deeplabcut.create_pretrained_human_project('human','Linus',['/data/videos/mouse1.avi'],'/analysis/project/',copy_videos=False)
Windows:
>>> deeplabcut.create_pretrained_human_project('human','Bill',[r'C:\yourusername\rig-95\Videos\reachingvideo1.avi'],r'C:\yourusername\analysis\project' copy_videos=False)
Users must format paths with either: r'C:\ OR 'C:\\ <- i.e. a double backslash \ \ )
--------
"""
cfg = deeplabcut.create_new_project(project, experimenter, videos,
working_directory, copy_videos,
videotype)
config = auxiliaryfunctions.read_config(cfg)
config['bodyparts'] = [
'ankle1', 'knee1', 'hip1', 'hip2', 'knee2', 'ankle2', 'wrist1',
'elbow1', 'shoulder1', 'shoulder2', 'elbow2', 'wrist2', 'chin',
'forehead'
]
config['skeleton'] = [['ankle1', 'knee1'], ['ankle2', 'knee2'],
['knee1', 'hip1'], ['knee2', 'hip2'],
['hip1', 'hip2'], ['shoulder1', 'shoulder2'],
['shoulder1', 'hip1'], ['shoulder2', 'hip2'],
['shoulder1', 'elbow1'], ['shoulder2', 'elbow2'],
['chin', 'forehead'], ['elbow1', 'wrist1'],
['elbow2', 'wrist2']]
config['default_net_type'] = 'resnet_101'
auxiliaryfunctions.write_config(cfg, config)
config = auxiliaryfunctions.read_config(cfg)
train_dir = Path(
os.path.join(
config['project_path'],
str(
auxiliaryfunctions.GetModelFolder(
trainFraction=config['TrainingFraction'][0],
shuffle=1,
cfg=config)), 'train'))
test_dir = Path(
os.path.join(
config['project_path'],
str(
auxiliaryfunctions.GetModelFolder(
trainFraction=config['TrainingFraction'][0],
shuffle=1,
cfg=config)), 'test'))
# Create the model directory
train_dir.mkdir(parents=True, exist_ok=True)
test_dir.mkdir(parents=True, exist_ok=True)
modelfoldername = auxiliaryfunctions.GetModelFolder(
trainFraction=config['TrainingFraction'][0], shuffle=1, cfg=config)
path_train_config = str(
os.path.join(config['project_path'], Path(modelfoldername), 'train',
'pose_cfg.yaml'))
path_test_config = str(
os.path.join(config['project_path'], Path(modelfoldername), 'test',
'pose_cfg.yaml'))
# Download the weights and put then in appropriate directory
cwd = os.getcwd()
os.chdir(train_dir)
print(
"Checking if the weights are already available, otherwise I will download them!"
)
weightfilename = auxfun_models.download_mpii_weigths(train_dir)
os.chdir(cwd)
# Create the pose_config.yaml files
parent_path = Path(os.path.dirname(deeplabcut.__file__))
defaultconfigfile = str(parent_path / 'pose_cfg.yaml')
trainingsetfolder = auxiliaryfunctions.GetTrainingSetFolder(config)
datafilename, metadatafilename = auxiliaryfunctions.GetDataandMetaDataFilenames(
trainingsetfolder,
trainFraction=config['TrainingFraction'][0],
shuffle=1,
cfg=config)
bodyparts = config['bodyparts']
net_type = 'resnet_101'
num_shuffles = 1
model_path, num_shuffles = auxfun_models.Check4weights(
net_type, parent_path, num_shuffles)
items2change = {
"dataset": 'dataset-test.mat', #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":
weightfilename.split('.index')[0], #'models/mpii/snapshot-1030000',
"project_path": str(config['project_path']),
"net_type": net_type,
"dataset_type": "default"
}
trainingdata = MakeTrain_pose_yaml(items2change, path_train_config,
defaultconfigfile)
keys2save = [
"dataset", "dataset_type", "num_joints", "all_joints",
"all_joints_names", "net_type", 'init_weights', 'global_scale',
'location_refinement', 'locref_stdev'
]
MakeTest_pose_yaml(trainingdata, keys2save, path_test_config)
video_dir = os.path.join(config['project_path'], 'videos')
if analyzevideo == True:
# Analyze the videos
deeplabcut.analyze_videos(cfg, [video_dir],
videotype,
save_as_csv=True)
if createlabeledvideo == True:
deeplabcut.create_labeled_video(cfg, [video_dir],
videotype,
draw_skeleton=True)
deeplabcut.plot_trajectories(cfg, [video_dir], videotype)
return cfg, path_train_config
# NOTE: all MATLAB generated videos in this library have been recorded at ~500fps, but
# were generated at ~150fps by MATLAB due to ffmpeg issues. This doesn't affect the outputs
# simply the generation of a time series vector later on.
training_videos = ['videos/2018_03_08_animal_1_video_1b.mp4',
'videos/2018_03_09_animal_3_video_2.mp4',
'videos/2019_01_07_animal_2.mp4',
'videos/2019_01_07_animal_3.mp4',
'videos/2019_01_07_animal_5.mp4'
]
# Defining the working directory within the current directory. This will open a new folder for the project.
# All new training models, videos, and analyses will be carried out here.
# This also changes the current working directory (supposed to, not sure if happens in practice)
deeplabcut.create_new_project(task, sides, training_videos, working_directory='dlc-blinking',copy_videos=True)
path_config_file = '/dlc-blinking/blinking-lr-2019-02-07/config.yaml' # Enter the path of the config file that was just created from the above step (check the folder)
# if we plan on adding new videos to the project, we should use the following option:
#deeplabcut.add_new_videos(config_path,[‘full path of video X’, ‘full path of video X+1’],copy_videos=True/False)
#deeplabcut.add_new_videos(path_config_file,['videos/2019_01_07_animal_5.mp4'],copy_videos=True)
# Config file is now written.
# Go to config file for changing the bodyparts.
# As default we are monitoring both left-right eyes inner and outer points
# In addition, make sure the cropped frames for each video are correct indeed
# extracting frames, uniformly from the videos provided during setup.
# Note, in versions 2.0.4 and earlier, please set opencv to False in case the extraction is not from 0 to 100
# but something in between.
import matplotlib
import tensorflow as tf
task='eyes_only' # Enter the name of your experiment Task
sides='lr-gpu' # Enter the name of the experimenter
training_videos = ['dlc-blinking/blinking-lr-2019-02-06/videos/2018_03_08_animal_1_video_1b.mp4',
'dlc-blinking/blinking-lr-2019-02-06/videos/2018_03_09_animal_3_video_2.mp4',
'dlc-blinking/blinking-lr-2019-02-06/videos/2019_01_07_animal_2.mp4',
'dlc-blinking/blinking-lr-2019-02-06/videos/2019_01_07_animal_3.mp4',
'dlc-blinking/blinking-lr-2019-02-06/videos/2019_01_07_animal_5.mp4'
]
# video=['videos/animal_3_video_2_150fps_correct.mp4', 'videos/march_8_animal_1_video_150fps_correct.mp4'] # Enter the paths of your videos you want to grab frames from.
deeplabcut.create_new_project(task,sides,training_videos, working_directory='dlc-blinking',copy_videos=True) #change the working directory to where you want the folders created.
%matplotlib inline
path_config_file = '/dlc-blinking/an3_vid2_full/eyes_only-Guy-gpu-2019-01-29/config.yaml' # Enter the path of the config file that was just created from the above step (check the folder)
path_config_file = '/dlc-blinking/blinking-lr-2019-02-07/config.yaml' # Enter the path of the config file that was just created from the above step (check the folder)
deeplabcut.extract_frames(path_config_file,'automatic','uniform'),crop=True, checkcropping=True) #there are other ways to grab frames, such as by clustering 'kmeans'; please see the paper.
# 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
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)
Created on Mon Feb 4 16:26:09 2019 @author: gtsror """ # DLC Set up on blinking import deeplabcut import matplotlib task='whisk_only' # Enter the name of your experiment Task experimenter='Guy' # Enter the name of the experimenter video=['videos/animal_3_video_2_150fps_correct.mp4', 'videos/crush_19_01_07_animal_3.mp4'] # Enter the paths of your videos you want to grab frames from. deeplabcut.create_new_project(task,experimenter,video, working_directory='dlc-blinking/whisk',copy_videos=True) #change the working directory to where you want the folders created. %matplotlib inline path_config_file = '/dlc-blinking/whisk/whisk_only-Guy-2019-02-01/config.yaml' # Enter the path of the config file that was just created from the above step (check the folder) deeplabcut.extract_frames(path_config_file,'automatic','uniform',crop=True, checkcropping=True, opencv=False) #there are other ways to grab frames, such as by clustering 'kmeans'; please see the paper. # 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
def create_pretrained_project(
project,
experimenter,
videos,
model="full_human",
working_directory=None,
copy_videos=False,
videotype=None,
analyzevideo=True,
filtered=True,
createlabeledvideo=True,
trainFraction=None,
):
"""
Creates a new project directory, sub-directories and a basic configuration file.
Change its parameters to your projects need.
The project will also be initialized with a pre-trained model from the DeepLabCut model zoo!
http://www.mousemotorlab.org/dlc-modelzoo
Parameters
----------
project : string
String containing the name of the project.
experimenter : string
String containing the name of the experimenter.
model: string, options see http://www.mousemotorlab.org/dlc-modelzoo
Current option and default: 'full_human' Creates a demo human project and analyzes a video with ResNet 101 weights pretrained on MPII Human Pose. This is from the DeeperCut paper
by Insafutdinov et al. https://arxiv.org/abs/1605.03170 Please make sure to cite it too if you use this code!
videos : list
A list of string containing the full paths of the videos to include in the project.
working_directory : string, optional
The directory where the project will be created. The default is the ``current working directory``; if provided, it must be a string.
copy_videos : bool, optional ON WINDOWS: TRUE is often necessary!
If this is set to True, the videos are copied to the ``videos`` directory. If it is False,symlink of the videos are copied to the project/videos directory. The default is ``False``; if provided it must be either
``True`` or ``False``.
analyzevideo " bool, optional
If true, then the video is analzyed and a labeled video is created. If false, then only the project will be created and the weights downloaded. You can then access them
filtered: bool, default false
Boolean variable indicating if filtered pose data output should be plotted rather than frame-by-frame predictions.
Filtered version can be calculated with deeplabcut.filterpredictions
trainFraction: By default value from *new* projects. (0.95)
Fraction that will be used in dlc-model/trainingset folder name.
Example
--------
Linux/MacOs loading full_human model and analzying video /homosapiens1.avi
>>> deeplabcut.create_pretrained_project('humanstrokestudy','Linus',['/data/videos/homosapiens1.avi'], copy_videos=False)
Loading full_cat model and analzying video "felixfeliscatus3.avi"
>>> deeplabcut.create_pretrained_project('humanstrokestudy','Linus',['/data/videos/felixfeliscatus3.avi'], model='full_cat')
Windows:
>>> deeplabcut.create_pretrained_project('humanstrokestudy','Bill',[r'C:\yourusername\rig-95\Videos\reachingvideo1.avi'],r'C:\yourusername\analysis\project' copy_videos=True)
Users must format paths with either: r'C:\ OR 'C:\\ <- i.e. a double backslash \ \ )
"""
if model in globals()["Modeloptions"]:
cwd = os.getcwd()
cfg = deeplabcut.create_new_project(project, experimenter, videos,
working_directory, copy_videos,
videotype)
if trainFraction is not None:
auxiliaryfunctions.edit_config(
cfg, {"TrainingFraction": [tranFraction]})
config = auxiliaryfunctions.read_config(cfg)
if model == "full_human":
config["bodyparts"] = [
"ankle1",
"knee1",
"hip1",
"hip2",
"knee2",
"ankle2",
"wrist1",
"elbow1",
"shoulder1",
"shoulder2",
"elbow2",
"wrist2",
"chin",
"forehead",
]
config["skeleton"] = [
["ankle1", "knee1"],
["ankle2", "knee2"],
["knee1", "hip1"],
["knee2", "hip2"],
["hip1", "hip2"],
["shoulder1", "shoulder2"],
["shoulder1", "hip1"],
["shoulder2", "hip2"],
["shoulder1", "elbow1"],
["shoulder2", "elbow2"],
["chin", "forehead"],
["elbow1", "wrist1"],
["elbow2", "wrist2"],
]
config["default_net_type"] = "resnet_101"
else: # just make a case and put the stuff you want.
# TBD: 'partaffinityfield_graph' >> use to set skeleton!
pass
auxiliaryfunctions.write_config(cfg, config)
config = auxiliaryfunctions.read_config(cfg)
train_dir = Path(
os.path.join(
config["project_path"],
str(
auxiliaryfunctions.GetModelFolder(
trainFraction=config["TrainingFraction"][0],
shuffle=1,
cfg=config,
)),
"train",
))
test_dir = Path(
os.path.join(
config["project_path"],
str(
auxiliaryfunctions.GetModelFolder(
trainFraction=config["TrainingFraction"][0],
shuffle=1,
cfg=config,
)),
"test",
))
# Create the model directory
train_dir.mkdir(parents=True, exist_ok=True)
test_dir.mkdir(parents=True, exist_ok=True)
modelfoldername = auxiliaryfunctions.GetModelFolder(
trainFraction=config["TrainingFraction"][0], shuffle=1, cfg=config)
path_train_config = str(
os.path.join(config["project_path"], Path(modelfoldername),
"train", "pose_cfg.yaml"))
path_test_config = str(
os.path.join(config["project_path"], Path(modelfoldername), "test",
"pose_cfg.yaml"))
# Download the weights and put then in appropriate directory
print("Dowloading weights...")
auxfun_models.DownloadModel(model, train_dir)
pose_cfg = deeplabcut.auxiliaryfunctions.read_plainconfig(
path_train_config)
print(path_train_config)
# Updating config file:
dict = {
"default_net_type": pose_cfg["net_type"],
"default_augmenter": pose_cfg["dataset_type"],
"bodyparts": pose_cfg["all_joints_names"],
"skeleton": [], # TODO: update with paf_graph
"dotsize": 6,
}
auxiliaryfunctions.edit_config(cfg, dict)
# Create the pose_config.yaml files
parent_path = Path(os.path.dirname(deeplabcut.__file__))
defaultconfigfile = str(parent_path / "pose_cfg.yaml")
trainingsetfolder = auxiliaryfunctions.GetTrainingSetFolder(config)
datafilename, metadatafilename = auxiliaryfunctions.GetDataandMetaDataFilenames(
trainingsetfolder,
trainFraction=config["TrainingFraction"][0],
shuffle=1,
cfg=config,
)
# downloading base encoder / not required unless on re-trains (but when a training set is created this happens anyway)
# model_path, num_shuffles=auxfun_models.Check4weights(pose_cfg['net_type'], parent_path, num_shuffles= 1)
# Updating training and test pose_cfg:
snapshotname = [fn for fn in os.listdir(train_dir)
if ".meta" in fn][0].split(".meta")[0]
dict2change = {
"init_weights": str(os.path.join(train_dir, snapshotname)),
"project_path": str(config["project_path"]),
}
UpdateTrain_pose_yaml(pose_cfg, dict2change, path_train_config)
keys2save = [
"dataset",
"dataset_type",
"num_joints",
"all_joints",
"all_joints_names",
"net_type",
"init_weights",
"global_scale",
"location_refinement",
"locref_stdev",
]
MakeTest_pose_yaml(pose_cfg, keys2save, path_test_config)
video_dir = os.path.join(config["project_path"], "videos")
if analyzevideo == True:
print("Analyzing video...")
deeplabcut.analyze_videos(cfg, [video_dir],
videotype,
save_as_csv=True)
if createlabeledvideo == True:
if filtered:
deeplabcut.filterpredictions(cfg, [video_dir], videotype)
print("Plotting results...")
deeplabcut.create_labeled_video(cfg, [video_dir],
videotype,
draw_skeleton=True,
filtered=filtered)
deeplabcut.plot_trajectories(cfg, [video_dir],
videotype,
filtered=filtered)
os.chdir(cwd)
return cfg, path_train_config
else:
return "N/A", "N/A"
