def get_batch(self):
img_idx = np.random.choice(self.num_images,
size=self.batch_size,
replace=True)
batch_images = []
batch_joints = []
joint_ids = []
data_items = []
# Scale is sampled only once to transform all of the images into same size.
scale = self.get_scale()
while True:
idx = np.random.choice(self.num_images)
scale = self.get_scale()
size = self.data[idx].im_size
target_size = np.ceil(size[1:3] * scale).astype(int)
if self.is_valid_size(target_size[1] * target_size[0]):
break
stride = self.cfg.stride
for i in range(self.batch_size):
data_item = self.data[img_idx[i]]
data_items.append(data_item)
im_file = data_item.im_path
logging.debug('image %s', im_file)
image = imread(os.path.join(self.cfg.project_path, im_file),
mode='RGB')
if self.has_gt:
joints = np.copy(data_item.joints)
joint_id = [
person_joints[:, 0].astype(int) for person_joints in joints
]
joint_points = [
person_joints[:, 1:3] for person_joints in joints
]
joint_ids.append(joint_id)
batch_joints.append(arr(joint_points)[0])
batch_images.append(image)
sm_size = np.ceil(target_size / (stride * 2)).astype(int) * 2
assert len(batch_images) == self.batch_size
return batch_images, joint_ids, batch_joints, data_items, sm_size, target_size
def GetPosesofFrames(cfg, dlc_cfg, sess, inputs, outputs, directory, framelist,
nframes, batchsize, rgb):
''' Batchwise prediction of pose for frame list in directory'''
#from skimage.io import imread
from deeplabcutcore.utils.auxfun_videos import imread
print("Starting to extract posture")
if rgb:
im = imread(os.path.join(directory, framelist[0]), mode='RGB')
else:
im = imread(os.path.join(directory, framelist[0]))
ny, nx, nc = np.shape(im)
print("Overall # of frames: ", nframes,
" found with (before cropping) frame dimensions: ", nx, ny)
PredictedData = np.zeros(
(nframes,
dlc_cfg['num_outputs'] * 3 * len(dlc_cfg['all_joints_names'])))
batch_ind = 0 # keeps track of which image within a batch should be written to
batch_num = 0 # keeps track of which batch you are at
if cfg['cropping']:
print(
"Cropping based on the x1 = %s x2 = %s y1 = %s y2 = %s. You can adjust the cropping coordinates in the config.yaml file."
% (cfg['x1'], cfg['x2'], cfg['y1'], cfg['y2']))
nx, ny = cfg['x2'] - cfg['x1'], cfg['y2'] - cfg['y1']
if nx > 0 and ny > 0:
pass
else:
raise Exception('Please check the order of cropping parameter!')
if cfg['x1'] >= 0 and cfg['x2'] < int(
np.shape(im)[1]) and cfg['y1'] >= 0 and cfg['y2'] < int(
np.shape(im)[0]):
pass #good cropping box
else:
raise Exception('Please check the boundary of cropping!')
pbar = tqdm(total=nframes)
counter = 0
step = max(10, int(nframes / 100))
if batchsize == 1:
for counter, framename in enumerate(framelist):
#frame=imread(os.path.join(directory,framename),mode='RGB')
if rgb:
im = imread(os.path.join(directory, framename), mode='RGB')
else:
im = imread(os.path.join(directory, framename))
if counter % step == 0:
pbar.update(step)
if cfg['cropping']:
frame = img_as_ubyte(im[cfg['y1']:cfg['y2'],
cfg['x1']:cfg['x2'], :])
else:
frame = img_as_ubyte(im)
pose = predict.getpose(frame, dlc_cfg, sess, inputs, outputs)
PredictedData[counter, :] = pose.flatten()
else:
frames = np.empty(
(batchsize, ny, nx, 3),
dtype='ubyte') # this keeps all the frames of a batch
for counter, framename in enumerate(framelist):
if rgb:
im = imread(os.path.join(directory, framename), mode='RGB')
else:
im = imread(os.path.join(directory, framename))
if counter % step == 0:
pbar.update(step)
if cfg['cropping']:
frames[batch_ind] = img_as_ubyte(im[cfg['y1']:cfg['y2'],
cfg['x1']:cfg['x2'], :])
else:
frames[batch_ind] = img_as_ubyte(im)
if batch_ind == batchsize - 1:
pose = predict.getposeNP(frames, dlc_cfg, sess, inputs,
outputs)
PredictedData[batch_num * batchsize:(batch_num + 1) *
batchsize, :] = pose
batch_ind = 0
batch_num += 1
else:
batch_ind += 1
if batch_ind > 0: #take care of the last frames (the batch that might have been processed)
pose = predict.getposeNP(
frames, dlc_cfg, sess, inputs, outputs
) #process the whole batch (some frames might be from previous batch!)
PredictedData[batch_num * batchsize:batch_num * batchsize +
batch_ind, :] = pose[:batch_ind, :]
pbar.close()
return PredictedData, nframes, nx, ny
def evaluate_network(config,
Shuffles=[1],
trainingsetindex=0,
plotting=None,
show_errors=True,
comparisonbodyparts="all",
gputouse=None,
rescale=False):
"""
Evaluates the network based on the saved models at different stages of the training network.\n
The evaluation results are stored in the .h5 and .csv file under the subdirectory 'evaluation_results'.
Change the snapshotindex parameter in the config file to 'all' in order to evaluate all the saved models.
Parameters
----------
config : string
Full path of the config.yaml file as a string.
Shuffles: list, optional
List of integers specifying the shuffle indices of the training dataset. The default is [1]
trainingsetindex: int, optional
Integer specifying which TrainingsetFraction to use. By default the first (note that TrainingFraction is a list in config.yaml). This
variable can also be set to "all".
plotting: bool, optional
Plots the predictions on the train and test images. The default is ``False``; if provided it must be either ``True`` or ``False``
show_errors: bool, optional
Display train and test errors. The default is `True``
comparisonbodyparts: list of bodyparts, Default is "all".
The average error will be computed for those body parts only (Has to be a subset of the body parts).
gputouse: int, optional. Natural number indicating the number of your GPU (see number in nvidia-smi). If you do not have a GPU put None.
See: https://nvidia.custhelp.com/app/answers/detail/a_id/3751/~/useful-nvidia-smi-queries
rescale: bool, default False
Evaluate the model at the 'global_scale' variable (as set in the test/pose_config.yaml file for a particular project). I.e. every
image will be resized according to that scale and prediction will be compared to the resized ground truth. The error will be reported
in pixels at rescaled to the *original* size. I.e. For a [200,200] pixel image evaluated at global_scale=.5, the predictions are calculated
on [100,100] pixel images, compared to 1/2*ground truth and this error is then multiplied by 2!. The evaluation images are also shown for the
original size!
Examples
--------
If you do not want to plot
>>> deeplabcutcore.evaluate_network('/analysis/project/reaching-task/config.yaml', Shuffles=[1])
--------
If you want to plot
>>> deeplabcutcore.evaluate_network('/analysis/project/reaching-task/config.yaml',Shuffles=[1],True)
"""
import os
#import skimage.color
#from skimage.io import imread
from deeplabcutcore.utils.auxfun_videos import imread, imresize
from deeplabcutcore.pose_estimation_tensorflow.nnet import predict
from deeplabcutcore.pose_estimation_tensorflow.config import load_config
from deeplabcutcore.pose_estimation_tensorflow.dataset.pose_dataset import data_to_input
from deeplabcutcore.utils import auxiliaryfunctions
import tensorflow as tf
if 'TF_CUDNN_USE_AUTOTUNE' in os.environ:
del os.environ[
'TF_CUDNN_USE_AUTOTUNE'] #was potentially set during training
tf.compat.v1.reset_default_graph()
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' #
# tf.logging.set_verbosity(tf.logging.WARN)
start_path = os.getcwd()
# Read file path for pose_config file. >> pass it on
cfg = auxiliaryfunctions.read_config(config)
if gputouse is not None: #gpu selectinon
os.environ['CUDA_VISIBLE_DEVICES'] = str(gputouse)
if trainingsetindex == 'all':
TrainingFractions = cfg["TrainingFraction"]
else:
if trainingsetindex < len(
cfg["TrainingFraction"]) and trainingsetindex >= 0:
TrainingFractions = [
cfg["TrainingFraction"][int(trainingsetindex)]
]
else:
raise Exception('Please check the trainingsetindex! ',
trainingsetindex,
' should be an integer from 0 .. ',
int(len(cfg["TrainingFraction"]) - 1))
# Loading human annotatated data
trainingsetfolder = auxiliaryfunctions.GetTrainingSetFolder(cfg)
Data = pd.read_hdf(
os.path.join(cfg["project_path"], str(trainingsetfolder),
'CollectedData_' + cfg["scorer"] + '.h5'),
'df_with_missing')
# Get list of body parts to evaluate network for
comparisonbodyparts = auxiliaryfunctions.IntersectionofBodyPartsandOnesGivenbyUser(
cfg, comparisonbodyparts)
# Make folder for evaluation
auxiliaryfunctions.attempttomakefolder(
str(cfg["project_path"] + "/evaluation-results/"))
for shuffle in Shuffles:
for trainFraction in TrainingFractions:
##################################################
# Load and setup CNN part detector
##################################################
datafn, metadatafn = auxiliaryfunctions.GetDataandMetaDataFilenames(
trainingsetfolder, trainFraction, shuffle, cfg)
modelfolder = os.path.join(
cfg["project_path"],
str(
auxiliaryfunctions.GetModelFolder(trainFraction, shuffle,
cfg)))
path_test_config = Path(modelfolder) / 'test' / 'pose_cfg.yaml'
# Load meta data
data, trainIndices, testIndices, trainFraction = auxiliaryfunctions.LoadMetadata(
os.path.join(cfg["project_path"], metadatafn))
try:
dlc_cfg = load_config(str(path_test_config))
except FileNotFoundError:
raise FileNotFoundError(
"It seems the model for shuffle %s and trainFraction %s does not exist."
% (shuffle, trainFraction))
#change batch size, if it was edited during analysis!
dlc_cfg['batch_size'] = 1 #in case this was edited for analysis.
#Create folder structure to store results.
evaluationfolder = os.path.join(
cfg["project_path"],
str(
auxiliaryfunctions.GetEvaluationFolder(
trainFraction, shuffle, cfg)))
auxiliaryfunctions.attempttomakefolder(evaluationfolder,
recursive=True)
#path_train_config = modelfolder / 'train' / 'pose_cfg.yaml'
# Check which snapshots are available and sort them by # iterations
Snapshots = np.array([
fn.split('.')[0]
for fn in os.listdir(os.path.join(str(modelfolder), 'train'))
if "index" in fn
])
try: #check if any where found?
Snapshots[0]
except IndexError:
raise FileNotFoundError(
"Snapshots not found! It seems the dataset for shuffle %s and trainFraction %s is not trained.\nPlease train it before evaluating.\nUse the function 'train_network' to do so."
% (shuffle, trainFraction))
increasing_indices = np.argsort(
[int(m.split('-')[1]) for m in Snapshots])
Snapshots = Snapshots[increasing_indices]
if cfg["snapshotindex"] == -1:
snapindices = [-1]
elif cfg["snapshotindex"] == "all":
snapindices = range(len(Snapshots))
elif cfg["snapshotindex"] < len(Snapshots):
snapindices = [cfg["snapshotindex"]]
else:
raise ValueError(
"Invalid choice, only -1 (last), any integer up to last, or all (as string)!"
)
final_result = []
########################### RESCALING (to global scale)
if rescale == True:
scale = dlc_cfg['global_scale']
Data = pd.read_hdf(
os.path.join(cfg["project_path"], str(trainingsetfolder),
'CollectedData_' + cfg["scorer"] + '.h5'),
'df_with_missing') * scale
else:
scale = 1
##################################################
# Compute predictions over images
##################################################
for snapindex in snapindices:
dlc_cfg['init_weights'] = os.path.join(
str(modelfolder), 'train', Snapshots[snapindex]
) #setting weights to corresponding snapshot.
trainingsiterations = (
dlc_cfg['init_weights'].split(os.sep)[-1]
).split(
'-'
)[-1] #read how many training siterations that corresponds to.
# Name for deeplabcut net (based on its parameters)
DLCscorer, DLCscorerlegacy = auxiliaryfunctions.GetScorerName(
cfg, shuffle, trainFraction, trainingsiterations)
print("Running ", DLCscorer, " with # of trainingiterations:",
trainingsiterations)
notanalyzed, resultsfilename, DLCscorer = auxiliaryfunctions.CheckifNotEvaluated(
str(evaluationfolder), DLCscorer, DLCscorerlegacy,
Snapshots[snapindex])
if notanalyzed:
# Specifying state of model (snapshot / training state)
sess, inputs, outputs = predict.setup_pose_prediction(
dlc_cfg)
Numimages = len(Data.index)
PredicteData = np.zeros(
(Numimages, 3 * len(dlc_cfg['all_joints_names'])))
print("Analyzing data...")
for imageindex, imagename in tqdm(enumerate(Data.index)):
image = imread(os.path.join(cfg['project_path'],
imagename),
mode='RGB')
if scale != 1:
image = imresize(image, scale)
#image = skimage.color.gray2rgb(image)
image_batch = data_to_input(image)
# Compute prediction with the CNN
outputs_np = sess.run(outputs,
feed_dict={inputs: image_batch})
scmap, locref = predict.extract_cnn_output(
outputs_np, dlc_cfg)
# Extract maximum scoring location from the heatmap, assume 1 person
pose = predict.argmax_pose_predict(
scmap, locref, dlc_cfg.stride)
PredicteData[imageindex, :] = pose.flatten(
) # NOTE: thereby cfg_test['all_joints_names'] should be same order as bodyparts!
sess.close() #closes the current tf session
index = pd.MultiIndex.from_product(
[[DLCscorer], dlc_cfg['all_joints_names'],
['x', 'y', 'likelihood']],
names=['scorer', 'bodyparts', 'coords'])
# Saving results
DataMachine = pd.DataFrame(PredicteData,
columns=index,
index=Data.index.values)
DataMachine.to_hdf(resultsfilename,
'df_with_missing',
format='table',
mode='w')
print("Done and results stored for snapshot: ",
Snapshots[snapindex])
DataCombined = pd.concat([Data.T, DataMachine.T],
axis=0,
sort=False).T
RMSE, RMSEpcutoff = pairwisedistances(
DataCombined, cfg["scorer"], DLCscorer, cfg["pcutoff"],
comparisonbodyparts)
testerror = np.nanmean(
RMSE.iloc[testIndices].values.flatten())
trainerror = np.nanmean(
RMSE.iloc[trainIndices].values.flatten())
testerrorpcutoff = np.nanmean(
RMSEpcutoff.iloc[testIndices].values.flatten())
trainerrorpcutoff = np.nanmean(
RMSEpcutoff.iloc[trainIndices].values.flatten())
results = [
trainingsiterations,
int(100 * trainFraction), shuffle,
np.round(trainerror, 2),
np.round(testerror, 2), cfg["pcutoff"],
np.round(trainerrorpcutoff, 2),
np.round(testerrorpcutoff, 2)
]
final_result.append(results)
if show_errors == True:
print("Results for",
trainingsiterations, " training iterations:",
int(100 * trainFraction), shuffle,
"train error:",
np.round(trainerror, 2), "pixels. Test error:",
np.round(testerror, 2), " pixels.")
print("With pcutoff of",
cfg["pcutoff"], " train error:",
np.round(trainerrorpcutoff,
2), "pixels. Test error:",
np.round(testerrorpcutoff, 2), "pixels")
if scale != 1:
print(
"The predictions have been calculated for rescaled images (and rescaled ground truth). Scale:",
scale)
print(
"Thereby, the errors are given by the average distances between the labels by DLC and the scorer."
)
if plotting == True:
print("Plotting...")
foldername = os.path.join(
str(evaluationfolder), 'LabeledImages_' +
DLCscorer + '_' + Snapshots[snapindex])
auxiliaryfunctions.attempttomakefolder(foldername)
Plotting(
cfg, comparisonbodyparts, DLCscorer, trainIndices,
DataCombined * 1. / scale, foldername
) #Rescaling coordinates to have figure in original size!
tf.compat.v1.reset_default_graph()
#print(final_result)
else:
DataMachine = pd.read_hdf(resultsfilename,
'df_with_missing')
if plotting == True:
DataCombined = pd.concat([Data.T, DataMachine.T],
axis=0,
sort=False).T
print(
"Plotting...(attention scale might be inconsistent in comparison to when data was analyzed; i.e. if you used rescale)"
)
foldername = os.path.join(
str(evaluationfolder), 'LabeledImages_' +
DLCscorer + '_' + Snapshots[snapindex])
auxiliaryfunctions.attempttomakefolder(foldername)
Plotting(cfg, comparisonbodyparts, DLCscorer,
trainIndices, DataCombined * 1. / scale,
foldername)
if len(final_result) > 0: #Only append if results were calculated
make_results_file(final_result, evaluationfolder, DLCscorer)
print(
"The network is evaluated and the results are stored in the subdirectory 'evaluation_results'."
)
print(
"If it generalizes well, choose the best model for prediction and update the config file with the appropriate index for the 'snapshotindex'.\nUse the function 'analyze_video' to make predictions on new videos."
)
print(
"Otherwise consider retraining the network (see DeepLabCut workflow Fig 2)"
)
#returning to intial folder
os.chdir(str(start_path))
def make_batch(self, data_item, scale, mirror):
im_file = data_item.im_path
logging.debug('image %s', im_file)
logging.debug('mirror %r', mirror)
#print(im_file, os.getcwd())
#print(self.cfg.project_path)
image = imread(os.path.join(self.cfg.project_path, im_file),
mode='RGB')
if self.has_gt:
joints = np.copy(data_item.joints)
if self.cfg.crop: #adapted cropping for DLC
if np.random.rand() < self.cfg.cropratio:
#1. get center of joints
j = np.random.randint(
np.shape(joints)[1]) #pick a random joint
# draw random crop dimensions & subtract joint points
#print(joints,j,'ahah')
joints, image = CropImage(joints, image, joints[0, j, 1],
joints[0, j, 2], self.cfg)
#if self.has_gt:
# joints[0,:, 1] -= x0
# joints[0,:, 2] -= y0
'''
print(joints)
import matplotlib.pyplot as plt
plt.clf()
plt.imshow(image)
plt.plot(joints[0,:,1],joints[0,:,2],'.')
plt.savefig("abc"+str(np.random.randint(int(1e6)))+".png")
'''
else:
pass #no cropping!
img = imresize(image, scale) if scale != 1 else image
scaled_img_size = arr(img.shape[0:2])
if mirror:
img = np.fliplr(img)
batch = {Batch.inputs: img}
if self.has_gt:
stride = self.cfg.stride
if mirror:
joints = [
self.mirror_joints(person_joints, self.symmetric_joints,
image.shape[1])
for person_joints in joints
]
sm_size = np.ceil(scaled_img_size / (stride * 2)).astype(int) * 2
scaled_joints = [
person_joints[:, 1:3] * scale for person_joints in joints
]
joint_id = [
person_joints[:, 0].astype(int) for person_joints in joints
]
part_score_targets, part_score_weights, locref_targets, locref_mask = self.compute_target_part_scoremap(
joint_id, scaled_joints, data_item, sm_size, scale)
batch.update({
Batch.part_score_targets: part_score_targets,
Batch.part_score_weights: part_score_weights,
Batch.locref_targets: locref_targets,
Batch.locref_mask: locref_mask
})
batch = {key: data_to_input(data) for (key, data) in batch.items()}
batch[Batch.data_item] = data_item
return batch