Merge branch 'release/2.9.0'

juhuntenburg · juhuntenburg · commit ce861a284d81 · 2022-01-24T09:05:02.000Z
diff --git a/brainbox/behavior/dlc.py b/brainbox/behavior/dlc.py
@@ -341,7 +341,7 @@ def plot_wheel_position(wheel_position, wheel_time, trials_df):
     trials_df['wheel_position'] = [wheel_position[start_idx[w]: end_idx[w]] - wheel_position[start_idx[w]]
                                    for w in range(len(start_idx))]
     # Plotting
-    times = np.arange(len(trials_df['wheel_position'][0])) * T_BIN + WINDOW_LAG
+    times = np.arange(len(trials_df['wheel_position'].iloc[0])) * T_BIN + WINDOW_LAG
     for side, label, color in zip([-1, 1], ['right', 'left'], ['darkred', '#1f77b4']):
         side_df = trials_df[trials_df['choice'] == side]
         for idx in side_df.index:
@@ -373,7 +373,11 @@ def _bin_window_licks(lick_times, trials_df):
     lick_bins = np.squeeze(lick_bins)
     start_window, end_window = plt_window(trials_df['feedback_times'])
     # Translating the time window into an index window
-    start_idx = insert_idx(bin_times, start_window)
+    try:
+        start_idx = insert_idx(bin_times, start_window)
+    except ValueError:
+        logger.error('Lick time stamps are outside of the trials windows')
+        raise
     end_idx = np.array(start_idx + int(WINDOW_LEN / T_BIN), dtype='int64')
     # Get the binned licks for each window
     trials_df['lick_bins'] = [lick_bins[start_idx[i]:end_idx[i]] for i in range(len(start_idx))]
@@ -394,7 +398,7 @@ def plot_lick_hist(lick_times, trials_df):
     """
     licks_df = _bin_window_licks(lick_times, trials_df)
     # Plot
-    times = np.arange(len(licks_df['lick_bins'][0])) * T_BIN + WINDOW_LAG
+    times = np.arange(len(licks_df['lick_bins'].iloc[0])) * T_BIN + WINDOW_LAG
     correct = licks_df[licks_df['feedbackType'] == 1]['lick_bins']
     incorrect = licks_df[licks_df['feedbackType'] == -1]['lick_bins']
     plt.plot(times, pd.DataFrame.from_dict(dict(zip(correct.index, correct.values))).mean(axis=1),
@@ -420,7 +424,7 @@ def plot_lick_raster(lick_times, trials_df):
     """
     licks_df = _bin_window_licks(lick_times, trials_df)
     plt.imshow(list(licks_df[licks_df['feedbackType'] == 1]['lick_bins']), aspect='auto',
-               extent=[-0.5, 1.5, len(licks_df['lick_bins'][0]), 0], cmap='gray_r')
+               extent=[-0.5, 1.5, len(licks_df['lick_bins'].iloc[0]), 0], cmap='gray_r')
     plt.xticks([-0.5, 0, 0.5, 1, 1.5])
     plt.ylabel('trials')
     plt.xlabel('time [sec]')
@@ -451,7 +455,11 @@ def plot_motion_energy_hist(camera_dict, trials_df):
                 and camera_dict[cam]['times'] is not None and len(camera_dict[cam]['times']) > 0):
             try:
                 motion_energy = zscore(camera_dict[cam]['motion_energy'], nan_policy='omit')
-                start_idx = insert_idx(camera_dict[cam]['times'], start_window)
+                try:
+                    start_idx = insert_idx(camera_dict[cam]['times'], start_window)
+                except ValueError:
+                    logger.error("Camera.times are outside of the trial windows")
+                    raise
                 end_idx = np.array(start_idx + int(WINDOW_LEN * SAMPLING[cam]), dtype='int64')
                 me_all = [motion_energy[start_idx[i]:end_idx[i]] for i in range(len(start_idx))]
                 times = np.arange(len(me_all[0])) / SAMPLING[cam] + WINDOW_LAG
@@ -495,6 +503,8 @@ def plot_speed_hist(dlc_df, cam_times, trials_df, feature='paw_r', cam='left', l
     dlc_df = likelihood_threshold(dlc_df)
     # For pre-GPIO sessions, remove the first few timestamps to match the number of frames
     cam_times = cam_times[-len(dlc_df):]
+    if len(cam_times) != len(dlc_df):
+        raise ValueError("Camera times length and DLC length are inconsistent")
     # Get speeds
     speeds = get_speed(dlc_df, cam_times, camera=cam, feature=feature)
     # Windows aligned to align_to
@@ -504,7 +514,7 @@ def plot_speed_hist(dlc_df, cam_times, trials_df, feature='paw_r', cam='left', l
     # Add speeds to trials_df
     trials_df[f'speed_{feature}'] = [speeds[start_idx[i]:end_idx[i]] for i in range(len(start_idx))]
     # Plot
-    times = np.arange(len(trials_df[f'speed_{feature}'][0])) / SAMPLING[cam] + WINDOW_LAG
+    times = np.arange(len(trials_df[f'speed_{feature}'].iloc[0])) / SAMPLING[cam] + WINDOW_LAG
     # Need to expand the series of lists into a dataframe first, for the nan skipping to work
     correct = trials_df[trials_df['feedbackType'] == 1][f'speed_{feature}']
     incorrect = trials_df[trials_df['feedbackType'] == -1][f'speed_{feature}']
diff --git a/ibllib/__init__.py b/ibllib/__init__.py
@@ -1,4 +1,4 @@
-__version__ = "2.8.0"
+__version__ = "2.9.0"
 import warnings
 
 from ibllib.misc import logger_config
diff --git a/ibllib/pipes/ephys_preprocessing.py b/ibllib/pipes/ephys_preprocessing.py
@@ -7,6 +7,7 @@
 from pathlib import Path
 import packaging.version
 
+import cv2
 import numpy as np
 import pandas as pd
 
@@ -15,7 +16,7 @@
 from ibllib.misc import check_nvidia_driver
 from ibllib.ephys import ephysqc, spikes, sync_probes
 from ibllib.io import ffmpeg, spikeglx
-from ibllib.io.video import label_from_path
+from ibllib.io.video import label_from_path, assert_valid_label
 from ibllib.io.extractors import ephys_fpga, ephys_passive, camera
 from ibllib.pipes import tasks
 from ibllib.pipes.training_preprocessing import TrainingRegisterRaw as EphysRegisterRaw
@@ -893,14 +894,159 @@ def get_signatures(self, **kwargs):
 
 
 class EphysDLC(tasks.Task):
+    """
+    This task relies on a correctly installed dlc environment as per
+    https://docs.google.com/document/d/1g0scP6_3EmaXCU4SsDNZWwDTaD9MG0es_grLA-d0gh0/edit#
+
+    If your environment is set up otherwise, make sure that you set the respective attributes:
+    t = EphysDLC(session_path)
+    t.dlcenv = Path('/path/to/your/dlcenv/bin/activate')
+    t.scripts = Path('/path/to/your/iblscripts/deploy/serverpc/dlc')
+    """
     gpu = 1
     cpu = 4
     io_charge = 90
     level = 2
+    force = True
 
-    def _run(self):
-        """empty placeholder for job creation only"""
-        pass
+    dlcenv = Path.home().joinpath('Documents', 'PYTHON', 'envs', 'dlcenv', 'bin', 'activate')
+    scripts = Path.home().joinpath('Documents', 'PYTHON', 'iblscripts', 'deploy', 'serverpc', 'dlc')
+    signature = {
+        'input_files': [
+            ('_iblrig_leftCamera.raw.mp4', 'raw_video_data', True),
+            ('_iblrig_rightCamera.raw.mp4', 'raw_video_data', True),
+            ('_iblrig_bodyCamera.raw.mp4', 'raw_video_data', True),
+        ],
+        'output_files': [
+            ('_ibl_leftCamera.dlc.pqt', 'alf', True),
+            ('_ibl_rightCamera.dlc.pqt', 'alf', True),
+            ('_ibl_bodyCamera.dlc.pqt', 'alf', True),
+            ('leftCamera.ROIMotionEnergy.npy', 'alf', True),
+            ('rightCamera.ROIMotionEnergy.npy', 'alf', True),
+            ('bodyCamera.ROIMotionEnergy.npy', 'alf', True),
+            ('leftROIMotionEnergy.position.npy', 'alf', True),
+            ('rightROIMotionEnergy.position.npy', 'alf', True),
+            ('bodyROIMotionEnergy.position.npy', 'alf', True),
+        ],
+    }
+
+    def _check_dlcenv(self):
+        """Check that scripts are present, dlcenv can be activated and get iblvideo version"""
+        assert len(list(self.scripts.rglob('run_dlc.*'))) == 2, \
+            f'Scripts run_dlc.sh and run_dlc.py do not exist in {self.scripts}'
+        assert len(list(self.scripts.rglob('run_motion.*'))) == 2, \
+            f'Scripts run_motion.sh and run_motion.py do not exist in {self.scripts}'
+        assert self.dlcenv.exists(), f"DLC environment does not exist in assumed location {self.dlcenv}"
+        command2run = f"source {self.dlcenv}; python -c 'import iblvideo; print(iblvideo.__version__)'"
+        process = subprocess.Popen(
+            command2run,
+            shell=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            executable="/bin/bash"
+        )
+        info, error = process.communicate()
+        if process.returncode != 0:
+            raise AssertionError(f"DLC environment check failed\n{error.decode('utf-8')}")
+        version = info.decode("utf-8").strip().split('\n')[-1]
+        return version
+
+    @staticmethod
+    def _video_intact(file_mp4):
+        """Checks that the downloaded video can be opened and is not empty"""
+        cap = cv2.VideoCapture(str(file_mp4))
+        frame_count = cap.get(cv2.CAP_PROP_FRAME_COUNT)
+        intact = True if frame_count > 0 else False
+        cap.release()
+        return intact
+
+    def _run(self, cams=None, overwrite=False):
+        # Default to all three cams
+        cams = cams or ['left', 'right', 'body']
+        cams = assert_valid_label(cams)
+        # Set up
+        self.session_id = self.one.path2eid(self.session_path)
+        actual_outputs = []
+
+        # Loop through cams
+        for cam in cams:
+            # Catch exceptions so that following cameras can still run
+            try:
+                # If all results exist and overwrite is False, skip computation
+                expected_outputs_present, expected_outputs = self.assert_expected(self.output_files, silent=True)
+                if overwrite is False and expected_outputs_present is True:
+                    actual_outputs.extend(expected_outputs)
+                    continue
+                else:
+                    file_mp4 = next(self.session_path.joinpath('raw_video_data').glob(f'_iblrig_{cam}Camera.raw*.mp4'))
+                    if not file_mp4.exists():
+                        # In this case we set the status to Incomplete.
+                        _logger.error(f"No raw video file available for {cam}, skipping.")
+                        self.status = -3
+                        continue
+                    if not self._video_intact(file_mp4):
+                        _logger.error(f"Corrupt raw video file {file_mp4}")
+                        self.status = -1
+                        continue
+                    # Check that dlc environment is ok, shell scripts exists, and get iblvideo version, GPU addressable
+                    self.version = self._check_dlcenv()
+                    _logger.info(f'iblvideo version {self.version}')
+                    check_nvidia_driver()
+
+                    _logger.info(f'Running DLC on {cam}Camera.')
+                    command2run = f"{self.scripts.joinpath('run_dlc.sh')} {str(self.dlcenv)} {file_mp4} {overwrite}"
+                    _logger.info(command2run)
+                    process = subprocess.Popen(
+                        command2run,
+                        shell=True,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                        executable="/bin/bash",
+                    )
+                    info, error = process.communicate()
+                    info_str = info.decode("utf-8").strip()
+                    _logger.info(info_str)
+                    if process.returncode != 0:
+                        error_str = error.decode("utf-8").strip()
+                        _logger.error(f'DLC failed for {cam}Camera\n {error_str}')
+                        self.status = -1
+                        # We dont' run motion energy, or add any files if dlc failed to run
+                        continue
+                    dlc_result = next(self.session_path.joinpath('alf').glob(f'_ibl_{cam}Camera.dlc*.pqt'))
+                    actual_outputs.append(dlc_result)
+
+                    _logger.info(f'Computing motion energy for {cam}Camera')
+                    command2run = f"{self.scripts.joinpath('run_motion.sh')} {str(self.dlcenv)} {file_mp4} {dlc_result}"
+                    _logger.info(command2run)
+                    process = subprocess.Popen(
+                        command2run,
+                        shell=True,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                        executable="/bin/bash",
+                    )
+                    info, error = process.communicate()
+                    info_str = info.decode("utf-8").strip()
+                    _logger.info(info_str)
+                    if process.returncode != 0:
+                        error_str = error.decode("utf-8").strip()
+                        _logger.error(f'Motion energy failed for {cam}Camera \n {error_str}')
+                        self.status = -1
+                        continue
+                    actual_outputs.append(next(self.session_path.joinpath('alf').glob(
+                        f'{cam}Camera.ROIMotionEnergy*.npy')))
+                    actual_outputs.append(next(self.session_path.joinpath('alf').glob(
+                        f'{cam}ROIMotionEnergy.position*.npy')))
+            except BaseException:
+                _logger.error(traceback.format_exc())
+                self.status = -1
+                continue
+        # If status is Incomplete, check that there is at least one output.
+        # # Otherwise make sure it gets set to Empty (outputs = None), and set status to -1 to make sure it doesn't slip
+        if self.status == -3 and len(actual_outputs) == 0:
+            actual_outputs = None
+            self.status = -1
+        return actual_outputs
 
 
 class EphysPostDLC(tasks.Task):
@@ -965,15 +1111,22 @@ def _run(self, overwrite=False, run_qc=True, plot_qc=True):
                                       f'Computations using camera.times will be skipped')
                         self.status = -1
                         times = False
+                    elif dlc_t.shape[0] < len(dlc_thresh):
+                        _logger.error(f'Camera times shorter than DLC traces for {cam} camera. '
+                                      f'Computations using camera.times will be skipped')
+                        self.status = -1
+                        times = 'short'
                     # These features are only computed from left and right cam
                     if cam in ('left', 'right'):
                         features = pd.DataFrame()
                         # If camera times are available, get the lick time stamps for combined array
-                        if times:
+                        if times is True:
                             _logger.info(f"Computing lick times for {cam} camera.")
                             combined_licks.append(get_licks(dlc_thresh, dlc_t))
-                        else:
-                            _logger.warning(f"Skipping lick times for {cam} camera as no camera.times available.")
+                        elif times is False:
+                            _logger.warning(f"Skipping lick times for {cam} camera as no camera.times available")
+                        elif times == 'short':
+                            _logger.warning(f"Skipping lick times for {cam} camera as camera.times are too short")
                         # Compute pupil diameter, raw and smoothed
                         _logger.info(f"Computing raw pupil diameter for {cam} camera.")
                         features['pupilDiameter_raw'] = get_pupil_diameter(dlc_thresh)
@@ -983,19 +1136,20 @@ def _run(self, overwrite=False, run_qc=True, plot_qc=True):
                                                                                          cam)
                         except BaseException:
                             _logger.error(f"Computing smooth pupil diameter for {cam} camera failed, saving all NaNs.")
+                            _logger.error(traceback.format_exc())
                             features['pupilDiameter_smooth'] = np.nan
                         # Safe to pqt
                         features_file = Path(self.session_path).joinpath('alf', f'_ibl_{cam}Camera.features.pqt')
                         features.to_parquet(features_file)
                         output_files.append(features_file)
 
                     # For all cams, compute DLC qc if times available
-                    if times and run_qc:
+                    if times is True or times == 'short' and run_qc:
                         # Setting download_data to False because at this point the data should be there
                         qc = DlcQC(self.session_path, side=cam, one=self.one, download_data=False)
                         qc.run(update=True)
                     else:
-                        if not times:
+                        if times is False:
                             _logger.warning(f"Skipping QC for {cam} camera as no camera.times available")
                         if not run_qc:
                             _logger.warning(f"Skipping QC for {cam} camera as run_qc=False")
diff --git a/ibllib/plots/figures.py b/ibllib/plots/figures.py
@@ -652,7 +652,7 @@ def dlc_qc_plot(eid, one=None):
             logger.warning(f"Could not load {alf_object} object for session {eid}, some plots have to be skipped.")
             data[f'{alf_object}'] = None
     # Simplify to what we actually need
-    data['licks'] = data['licks'].times if data['licks'] else None
+    data['licks'] = data['licks'].times if data['licks'] and data['licks'].times.shape[0] > 0 else None
     data['left_pupil'] = data['left_features'].pupilDiameter_smooth if (
         data['left_features'] is not None and not np.all(np.isnan(data['left_features'].pupilDiameter_smooth))
     ) else None
@@ -686,15 +686,28 @@ def dlc_qc_plot(eid, one=None):
               (plot_pupil_diameter_hist,
                {'pupil_diameter': data['left_pupil'], 'cam_times': data['left_times'], 'trials_df': data['trials']})
               ]
+
+    # If camera times is shorter than dlc traces, many plots will fail. Don't even try those and give informative error
+    if data['left_dlc'] is not None and data['left_times'] is not None:
+        if len(data['left_times']) < len(data['left_dlc']):
+            for p in range(5, 10):
+                panels[p] = (panels[p][0], 'cam_times')
+
     # Plotting
     plt.rcParams.update({'font.size': 10})
     fig = plt.figure(figsize=(17, 10))
     for i, panel in enumerate(panels):
         ax = plt.subplot(2, 5, i + 1)
         ax.text(-0.1, 1.15, ascii_uppercase[i], transform=ax.transAxes, fontsize=16, fontweight='bold')
+        # Check if we have the cam times issue:
+        if panel[1] == 'cam_times':
+            ax.text(.5, .5, "Issue with camera.times\nsee task logs", color='r', fontweight='bold',
+                    fontsize=12, horizontalalignment='center', verticalalignment='center', transform=ax.transAxes)
+            plt.axis('off')
+
         # Check if any of the inputs is None
-        if any([v is None for v in panel[1].values()]) or any([v.values() is None for v in panel[1].values()
-                                                               if isinstance(v, dict)]):
+        elif any([v is None for v in panel[1].values()]) or any([v.values() is None for v in panel[1].values()
+                                                                 if isinstance(v, dict)]):
             ax.text(.5, .5, f"Data incomplete\n{panel[0].__name__}", color='r', fontweight='bold',
                     fontsize=12, horizontalalignment='center', verticalalignment='center', transform=ax.transAxes)
             plt.axis('off')
diff --git a/release_notes.md b/release_notes.md
@@ -1,3 +1,10 @@
+## Release Note 2.9
+
+### Release Note 2.9.0 2022-01-24
+- Adding EphysDLC task in ephys_preprocessing pipeline
+- NOTE: requires DLC environment to be set up on local servers! 
+- Fixes to EphysPostDLC dlc_qc_plot
+
 ## Release Note 2.8
 
 ### Release Notes 2.8.0 2022-01-19

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-__version__ = "2.8.0"`
	`1`	`+__version__ = "2.9.0"`
`2`	`2`	`import warnings`
`3`	`3`
`4`	`4`	`from ibllib.misc import logger_config`