Coverage for ibllib/pipes/training_status.py: 83%

1import logging (empty)

2from pathlib import Path (empty)

3from datetime import datetime (empty)

4from itertools import chain (empty)

5 

6import numpy as np (empty)

7import pandas as pd (empty)

8from iblutil.numerical import ismember (empty)

9import one.alf.io as alfio (empty)

10from one.alf.exceptions import ALFObjectNotFound (empty)

11import one.alf.path as alfiles (empty)

12import matplotlib.pyplot as plt (empty)

13import matplotlib.dates as mdates (empty)

14from matplotlib.lines import Line2D (empty)

15import seaborn as sns (empty)

16import boto3 (empty)

17from botocore.exceptions import ProfileNotFound, ClientError (empty)

18 

19from ibllib.io.raw_data_loaders import load_bpod (empty)

20from ibllib.oneibl.registration import _get_session_times (empty)

21from ibllib.io.extractors.base import get_bpod_extractor_class (empty)

22from ibllib.io.session_params import read_params (empty)

23from ibllib.io.extractors.bpod_trials import get_bpod_extractor (empty)

24from ibllib.plots.snapshot import ReportSnapshot (empty)

25from brainbox.behavior import training (empty)

26 

27logger = logging.getLogger(__name__) (empty)

28 

29 

30TRAINING_STATUS = {'untrainable': (-4, (0, 0, 0, 0)), (empty)

31 'unbiasable': (-3, (0, 0, 0, 0)), 

32 'not_computed': (-2, (0, 0, 0, 0)), 

33 'habituation': (-1, (0, 0, 0, 0)), 

34 'in training': (0, (0, 0, 0, 0)), 

35 'trained 1a': (1, (195, 90, 80, 255)), 

36 'trained 1b': (2, (255, 153, 20, 255)), 

37 'ready4ephysrig': (3, (28, 20, 255, 255)), 

38 'ready4delay': (4, (117, 117, 117, 255)), 

39 'ready4recording': (5, (20, 255, 91, 255))} 

40 

41 

42def get_training_table_from_aws(lab, subject): (empty)

43 """ 

44 If aws credentials exist on the local server download the latest training table from aws s3 private bucket 

45 :param lab: 

46 :param subject: 

47 :return: 

48 """ 

49 try: 1 ctx1a

50 session = boto3.Session(profile_name='ibl_training') 1 ctx1a

51 except ProfileNotFound: 

52 return 

53 

54 local_file_path = f'/mnt/s0/Data/Subjects/{subject}/training.csv' 1 ctx1a

55 dst_bucket_name = 'ibl-brain-wide-map-private' 1 ctx1a

56 try: 1 ctx1a

57 s3 = session.resource('s3') 1 ctx1a

58 bucket = s3.Bucket(name=dst_bucket_name) 1 ctx1a

59 bucket.download_file(f'resources/training/{lab}/{subject}/training.csv', 1 ctx1a

60 local_file_path) 

61 df = pd.read_csv(local_file_path) 

62 except ClientError: 1 ctx1a

63 return 1 ctx1a

64 

65 return df 

66 

67 

68def upload_training_table_to_aws(lab, subject): (empty)

69 """ 

70 If aws credentials exist on the local server upload the training table to aws s3 private bucket 

71 :param lab: 

72 :param subject: 

73 :return: 

74 """ 

75 try: 1 ctx1a

76 session = boto3.Session(profile_name='ibl_training') 1 ctx1a

77 except ProfileNotFound: 

78 return 

79 

80 local_file_path = f'/mnt/s0/Data/Subjects/{subject}/training.csv' 1 ctx1a

81 dst_bucket_name = 'ibl-brain-wide-map-private' 1 ctx1a

82 try: 1 ctx1a

83 s3 = session.resource('s3') 1 ctx1a

84 bucket = s3.Bucket(name=dst_bucket_name) 1 ctx1a

85 bucket.upload_file(local_file_path, 1 ctx1a

86 f'resources/training/{lab}/{subject}/training.csv') 

87 except (ClientError, FileNotFoundError): 1 ctx1a

88 return 1 ctx1a

89 

90 

91def save_path(subj_path): (empty)

92 return Path(subj_path).joinpath('training.csv') 5 ctx1cadfb

93 

94 

95def save_dataframe(df, subj_path): (empty)

96 """Save training dataframe to disk. 

97 

98 :param df: dataframe to save 

99 :param subj_path: path to subject folder 

100 :return: 

101 """ 

102 df.to_csv(save_path(subj_path), index=False) 2 ctx1ab

103 

104 

105def load_existing_dataframe(subj_path): (empty)

106 """Load training dataframe from disk, if dataframe doesn't exist returns None. 

107 

108 :param subj_path: path to subject folder 

109 :return: 

110 """ 

111 df_location = save_path(subj_path) 4 ctx1adfb

112 if df_location.exists(): 4 ctx1adfb

113 return pd.read_csv(df_location) 3 ctx1dfb

114 else: 

115 df_location.parent.mkdir(exist_ok=True, parents=True) 4 ctx1adfb

116 return None 4 ctx1adfb

117 

118 

119def load_trials(sess_path, one, collections=None, force=True, mode='raise'): (empty)

120 """ 

121 Load trials data for session. First attempts to load from local session path, if this fails will attempt to download via ONE, 

122 if this also fails, will then attempt to re-extract locally 

123 :param sess_path: session path 

124 :param one: ONE instance 

125 :param force: when True and if the session trials can't be found, will attempt to re-extract from the disk 

126 :param mode: 'raise' or 'warn', if 'raise', will error when forcing re-extraction of past sessions 

127 :return: 

128 """ 

129 try: 3 ctx1aeb

130 # try and load all trials that are found locally in the session path locally 

131 if collections is None: 3 ctx1aeb

132 trial_locations = list(sess_path.rglob('_ibl_trials.goCueTrigger_times.*npy')) 3 ctx1aeb

133 else: 

134 trial_locations = [Path(sess_path).joinpath(c, '_ibl_trials.goCueTrigger_times.*npy') for c in collections] 2 ctx1ab

135 

136 if len(trial_locations) > 1: 3 ctx1aeb

137 trial_dict = {} 

138 for i, loc in enumerate(trial_locations): 

139 trial_dict[i] = alfio.load_object(loc.parent, 'trials', short_keys=True) 

140 trials = training.concatenate_trials(trial_dict) 

141 elif len(trial_locations) == 1: 3 ctx1aeb

142 trials = alfio.load_object(trial_locations[0].parent, 'trials', short_keys=True) 3 ctx1aeb

143 else: 

144 raise ALFObjectNotFound 

145 

146 if 'probabilityLeft' not in trials.keys(): 3 ctx1aeb

147 raise ALFObjectNotFound 

148 except ALFObjectNotFound: 

149 # Next try and load all trials data through ONE 

150 try: 

151 if not force: 

152 return None 

153 eid = one.path2eid(sess_path) 

154 if collections is None: 

155 trial_collections = one.list_datasets(eid, '_ibl_trials.goCueTrigger_times.npy') 

156 if len(trial_collections) > 0: 

157 trial_collections = ['/'.join(c.split('/')[:-1]) for c in trial_collections] 

158 else: 

159 trial_collections = collections 

160 

161 if len(trial_collections) > 1: 

162 trial_dict = {} 

163 for i, collection in enumerate(trial_collections): 

164 trial_dict[i] = one.load_object(eid, 'trials', collection=collection) 

165 trials = training.concatenate_trials(trial_dict) 

166 elif len(trial_collections) == 1: 

167 trials = one.load_object(eid, 'trials', collection=trial_collections[0]) 

168 else: 

169 raise ALFObjectNotFound 

170 

171 if 'probabilityLeft' not in trials.keys(): 

172 raise ALFObjectNotFound 

173 except Exception: 

174 # Finally try to re-extract the trials data locally 

175 try: 

176 raw_collections, _ = get_data_collection(sess_path) 

177 

178 if len(raw_collections) == 0: 

179 return None 

180 

181 trials_dict = {} 

182 for i, collection in enumerate(raw_collections): 

183 extractor = get_bpod_extractor(sess_path, task_collection=collection) 

184 trials_data, _ = extractor.extract(task_collection=collection, save=False) 

185 trials_dict[i] = alfio.AlfBunch.from_df(trials_data['table']) 

186 

187 if len(trials_dict) > 1: 

188 trials = training.concatenate_trials(trials_dict) 

189 else: 

190 trials = trials_dict[0] 

191 

192 except Exception as e: 

193 if mode == 'raise': 

194 raise Exception(f'Exhausted all possibilities for loading trials for {sess_path}') from e 

195 else: 

196 logger.warning(f'Exhausted all possibilities for loading trials for {sess_path}') 

197 return 

198 

199 return trials 3 ctx1aeb

200 

201 

202def load_combined_trials(sess_paths, one, force=True): (empty)

203 """ 

204 Load and concatenate trials for multiple sessions. Used when we want to concatenate trials for two sessions on the same day 

205 :param sess_paths: list of paths to sessions 

206 :param one: ONE instance 

207 :return: 

208 """ 

209 trials_dict = {} 3 ctx1aeb

210 for sess_path in sess_paths: 3 ctx1aeb

211 trials = load_trials(Path(sess_path), one, force=force, mode='warn') 3 ctx1aeb

212 if trials is not None: 3 ctx1aeb

213 trials_dict[Path(sess_path).stem] = load_trials(Path(sess_path), one, force=force, mode='warn' 3 ctx1aeb

214 

215 ) 

216 

217 return training.concatenate_trials(trials_dict) 3 ctx1aeb

218 

219 

220def get_latest_training_information(sess_path, one, save=True): (empty)

221 """ 

222 Extracts the latest training status. 

223 

224 Parameters 

225 ---------- 

226 sess_path : pathlib.Path 

227 The session path from which to load the data. 

228 one : one.api.One 

229 An ONE instance. 

230 

231 Returns 

232 ------- 

233 pandas.DataFrame 

234 A table of training information. 

235 """ 

236 

237 subj_path = sess_path.parent.parent 2 ctx1ab

238 sub = subj_path.parts[-1] 2 ctx1ab

239 if one.mode != 'local': 2 ctx1ab

240 lab = one.alyx.rest('subjects', 'list', nickname=sub)[0]['lab'] 1 ctx1a

241 df = get_training_table_from_aws(lab, sub) 1 ctx1a

242 else: 

243 df = None 1 ctx1b

244 

245 if df is None: 2 ctx1ab

246 df = load_existing_dataframe(subj_path) 2 ctx1ab

247 

248 # Find the dates and associated session paths where we don't have data stored in our dataframe 

249 missing_dates = check_up_to_date(subj_path, df) 2 ctx1ab

250 

251 # Iterate through the dates to fill up our training dataframe 

252 for _, grp in missing_dates.groupby('date'): 2 ctx1ab

253 sess_dicts = get_training_info_for_session(grp.session_path.values, one) 2 ctx1ab

254 if len(sess_dicts) == 0: 2 ctx1ab

255 continue 

256 

257 for sess_dict in sess_dicts: 2 ctx1ab

258 if df is None: 2 ctx1ab

259 df = pd.DataFrame.from_dict(sess_dict) 2 ctx1ab

260 else: 

261 df = pd.concat([df, pd.DataFrame.from_dict(sess_dict)]) 1 ctx1b

262 

263 # Sort values by date and reset the index 

264 df = df.sort_values('date') 2 ctx1ab

265 df = df.reset_index(drop=True) 2 ctx1ab

266 # Save our dataframe 

267 if save: 2 ctx1ab

268 save_dataframe(df, subj_path) 2 ctx1ab

269 

270 # Now go through the backlog and compute the training status for sessions. If for example one was missing as it is cumulative 

271 # we need to go through and compute all the backlog 

272 # Find the earliest date in missing dates that we need to recompute the training status for 

273 missing_status = find_earliest_recompute_date(df.drop_duplicates('date').reset_index(drop=True)) 2 ctx1ab

274 for date in missing_status: 2 ctx1ab

275 df, _, _, _ = compute_training_status(df, date, one) 2 ctx1ab

276 

277 df_lim = df.drop_duplicates(subset='session_path', keep='first') 2 ctx1ab

278 

279 # Detect untrainable 

280 if 'untrainable' not in df_lim.training_status.values: 2 ctx1ab

281 un_df = df_lim[df_lim['training_status'] == 'in training'].sort_values('date') 2 ctx1ab

282 if len(un_df) >= 40: 2 ctx1ab

283 sess = un_df.iloc[39].session_path 

284 df.loc[df['session_path'] == sess, 'training_status'] = 'untrainable' 

285 

286 # Detect unbiasable 

287 if 'unbiasable' not in df_lim.training_status.values: 2 ctx1ab

288 un_df = df_lim[df_lim['task_protocol'] == 'biased'].sort_values('date') 2 ctx1ab

289 if len(un_df) >= 40: 2 ctx1ab

290 tr_st = un_df[0:40].training_status.unique() 

291 if 'ready4ephysrig' not in tr_st: 

292 sess = un_df.iloc[39].session_path 

293 df.loc[df['session_path'] == sess, 'training_status'] = 'unbiasable' 

294 if save: 2 ctx1ab

295 save_dataframe(df, subj_path) 2 ctx1ab

296 

297 if one.mode != 'local' and save: 2 ctx1ab

298 upload_training_table_to_aws(lab, sub) 1 ctx1a

299 

300 return df 2 ctx1ab

301 

302 

303def find_earliest_recompute_date(df): (empty)

304 """ 

305 Find the earliest date that we need to compute the training status from. Training status depends on previous sessions 

306 so if a session was missing and now has been added we need to recompute everything from that date onwards 

307 :param df: 

308 :return: 

309 """ 

310 missing_df = df[df['training_status'] == 'not_computed'] 3 ctx1afb

311 if len(missing_df) == 0: 3 ctx1afb

312 return [] 

313 missing_df = missing_df.sort_values('date') 3 ctx1afb

314 first_index = missing_df.index[0] 3 ctx1afb

315 

316 return df[first_index:].date.values 3 ctx1afb

317 

318 

319def compute_training_status(df, compute_date, one, force=True, populate=True): (empty)

320 """ 

321 Compute the training status for compute date based on training from that session and two previous days. 

322 

323 When true and if the session trials can't be found, will attempt to re-extract from disk. 

324 :return: 

325 

326 Parameters 

327 ---------- 

328 df : pandas.DataFrame 

329 A training data frame, e.g. one generated from :func:`get_training_info_for_session`. 

330 compute_date : str, datetime.datetime, pandas.Timestamp 

331 The date to compute training on. 

332 one : one.api.One 

333 An instance of ONE for loading trials data. 

334 force : bool 

335 When true and if the session trials can't be found, will attempt to re-extract from disk. 

336 populate : bool 

337 Whether to update the training data frame with the new training status value 

338 

339 Returns 

340 ------- 

341 pandas.DataFrame 

342 The input data frame with a 'training_status' column populated for `compute_date` if populate=True 

343 Bunch 

344 Bunch containing information fit parameters information for the combined sessions 

345 Bunch 

346 Bunch cotaining the training status criteria information 

347 str 

348 The training status 

349 """ 

350 

351 # compute_date = str(alfiles.session_path_parts(session_path, as_dict=True)['date']) 

352 df_temp = df[df['date'] <= compute_date] 2 ctx1ab

353 df_temp = df_temp.drop_duplicates(subset=['session_path', 'task_protocol']) 2 ctx1ab

354 df_temp.sort_values('date') 2 ctx1ab

355 

356 dates = df_temp.date.values 2 ctx1ab

357 

358 n_sess_for_date = len(np.where(dates == compute_date)[0]) 2 ctx1ab

359 n_dates = np.min([2 + n_sess_for_date, len(dates)]).astype(int) 2 ctx1ab

360 compute_dates = dates[(-1 * n_dates):] 2 ctx1ab

361 if n_sess_for_date > 1: 2 ctx1ab

362 compute_dates = compute_dates[:(-1 * (n_sess_for_date - 1))] 1 ctx1b

363 

364 assert compute_dates[-1] == compute_date 2 ctx1ab

365 

366 df_temp_group = df_temp.groupby('date') 2 ctx1ab

367 

368 trials = {} 2 ctx1ab

369 n_delay = 0 2 ctx1ab

370 ephys_sessions = [] 2 ctx1ab

371 protocol = [] 2 ctx1ab

372 status = [] 2 ctx1ab

373 for date in compute_dates: 2 ctx1ab

374 

375 df_date = df_temp_group.get_group(date) 2 ctx1ab

376 

377 # If habituation skip 

378 if df_date.iloc[-1]['task_protocol'] == 'habituation': 2 ctx1ab

379 continue 

380 # Here we should split by protocol in an ideal world but that world isn't today. This is only really relevant for 

381 # chained protocols 

382 trials[df_date.iloc[-1]['date']] = load_combined_trials(df_date.session_path.values, one, force=force) 2 ctx1ab

383 protocol.append(df_date.iloc[-1]['task_protocol']) 2 ctx1ab

384 status.append(df_date.iloc[-1]['training_status']) 2 ctx1ab

385 if df_date.iloc[-1]['combined_n_delay'] >= 900: # delay of 15 mins 2 ctx1ab

386 n_delay += 1 1 ctx1b

387 if df_date.iloc[-1]['location'] == 'ephys_rig': 2 ctx1ab

388 ephys_sessions.append(df_date.iloc[-1]['date']) 1 ctx1b

389 

390 n_status = np.max([-2, -1 * len(status)]) 2 ctx1ab

391 training_status, info, criteria = training.get_training_status(trials, protocol, ephys_sessions, n_delay) 2 ctx1ab

392 training_status = pass_through_training_hierachy(training_status, status[n_status]) 2 ctx1ab

393 if populate: 2 ctx1ab

394 df.loc[df['date'] == compute_date, 'training_status'] = training_status 2 ctx1ab

395 

396 return df, info, criteria, training_status 2 ctx1ab

397 

398 

399def pass_through_training_hierachy(status_new, status_old): (empty)

400 """ 

401 Makes sure that the new training status is not less than the one from the previous day. e.g Subject cannot regress in 

402 performance 

403 :param status_new: latest training status 

404 :param status_old: previous training status 

405 :return: 

406 """ 

407 

408 if TRAINING_STATUS[status_old][0] > TRAINING_STATUS[status_new][0]: 3 ctx1abg

409 return status_old 1 ctx1b

410 else: 

411 return status_new 3 ctx1abg

412 

413 

414def compute_session_duration_delay_location(sess_path, collections=None, **kwargs): (empty)

415 """ 

416 Get meta information about task. Extracts session duration, delay before session start and location of session 

417 

418 Parameters 

419 ---------- 

420 sess_path : pathlib.Path, str 

421 The session path with the pattern subject/yyyy-mm-dd/nnn. 

422 collections : list 

423 The location within the session path directory of task settings and data. 

424 

425 Returns 

426 ------- 

427 int 

428 The session duration in minutes, rounded to the nearest minute. 

429 int 

430 The delay between session start time and the first trial in seconds. 

431 str {'ephys_rig', 'training_rig'} 

432 The location of the session. 

433 """ 

434 if collections is None: 2 ctx1ab

435 collections, _ = get_data_collection(sess_path) 

436 

437 session_duration = 0 2 ctx1ab

438 session_delay = 0 2 ctx1ab

439 session_location = 'training_rig' 2 ctx1ab

440 for collection in collections: 2 ctx1ab

441 md, sess_data = load_bpod(sess_path, task_collection=collection) 2 ctx1ab

442 if md is None: 2 ctx1ab

443 continue 

444 try: 2 ctx1ab

445 start_time, end_time = _get_session_times(sess_path, md, sess_data) 2 ctx1ab

446 session_duration = session_duration + int((end_time - start_time).total_seconds() / 60) 2 ctx1ab

447 session_delay = session_delay + md.get('SESSION_DELAY_START', 2 ctx1ab

448 md.get('SESSION_START_DELAY_SEC', 0)) 

449 except Exception: 

450 session_duration = session_duration + 0 

451 session_delay = session_delay + 0 

452 

453 if 'ephys' in md.get('RIG_NAME', md.get('PYBPOD_BOARD', None)): 2 ctx1ab

454 session_location = 'ephys_rig' 1 ctx1b

455 else: 

456 session_location = 'training_rig' 2 ctx1ab

457 

458 return session_duration, session_delay, session_location 2 ctx1ab

459 

460 

461def get_data_collection(session_path): (empty)

462 """Return the location of the raw behavioral data and extracted trials data for a given session. 

463 

464 For multiple locations in one session (e.g. chained protocols), returns all collections. 

465 Passive protocols are excluded. 

466 

467 Parameters 

468 ---------- 

469 session_path : pathlib.Path 

470 A session path in the form subject/date/number. 

471 

472 Returns 

473 ------- 

474 list of str 

475 A list of sub-directory names that contain raw behaviour data. 

476 list of str 

477 A list of sub-directory names that contain ALF trials data. 

478 

479 Examples 

480 -------- 

481 An iblrig v7 session 

482 

483 >>> get_data_collection(Path(r'C:/data/subject/2023-01-01/001')) 

484 ['raw_behavior_data'], ['alf'] 

485 

486 An iblrig v8 session where two protocols were run 

487 

488 >>> get_data_collection(Path(r'C:/data/subject/2023-01-01/001')) 

489 ['raw_task_data_00', 'raw_task_data_01], ['alf/task_00', 'alf/task_01'] 

490 """ 

491 experiment_description = read_params(session_path) 2 ctx1ab

492 collections = [] 2 ctx1ab

493 if experiment_description is not None: 2 ctx1ab

494 task_protocols = experiment_description.get('tasks', []) 2 ctx1ab

495 for i, (protocol, task_info) in enumerate(chain(*map(dict.items, task_protocols))): 2 ctx1ab

496 if 'passiveChoiceWorld' in protocol: 2 ctx1ab

497 continue 1 ctx1b

498 collection = task_info.get('collection', f'raw_task_data_{i:02}') 2 ctx1ab

499 if collection == 'raw_passive_data': 2 ctx1ab

500 continue 

501 collections.append(collection) 2 ctx1ab

502 else: 

503 settings = Path(session_path).rglob('_iblrig_taskSettings.raw*.json') 1 ctx1b

504 for setting in settings: 1 ctx1b

505 if setting.parent.name != 'raw_passive_data': 1 ctx1b

506 collections.append(setting.parent.name) 1 ctx1b

507 

508 if len(collections) == 1 and collections[0] == 'raw_behavior_data': 2 ctx1ab

509 alf_collections = ['alf'] 2 ctx1ab

510 elif all(['raw_task_data' in c for c in collections]): 1 ctx1b

511 alf_collections = [f'alf/task_{c[-2:]}' for c in collections] 1 ctx1b

512 else: 

513 alf_collections = None 

514 

515 return collections, alf_collections 2 ctx1ab

516 

517 

518def get_sess_dict(session_path, one, protocol, alf_collections=None, raw_collections=None, force=True): (empty)

519 

520 sess_dict = {} 2 ctx1ab

521 sess_dict['date'] = str(alfiles.session_path_parts(session_path, as_dict=True)['date']) 2 ctx1ab

522 sess_dict['session_path'] = str(session_path) 2 ctx1ab

523 sess_dict['task_protocol'] = protocol 2 ctx1ab

524 

525 if sess_dict['task_protocol'] == 'habituation': 2 ctx1ab

526 nan_array = np.array([np.nan]) 

527 sess_dict['performance'], sess_dict['contrasts'], _ = (nan_array, nan_array, np.nan) 

528 sess_dict['performance_easy'] = np.nan 

529 sess_dict['reaction_time'] = np.nan 

530 sess_dict['n_trials'] = np.nan 

531 sess_dict['sess_duration'] = np.nan 

532 sess_dict['n_delay'] = np.nan 

533 sess_dict['location'] = np.nan 

534 sess_dict['training_status'] = 'habituation' 

535 sess_dict['bias_50'], sess_dict['thres_50'], sess_dict['lapselow_50'], sess_dict['lapsehigh_50'] = \ 

536 (np.nan, np.nan, np.nan, np.nan) 

537 sess_dict['bias_20'], sess_dict['thres_20'], sess_dict['lapselow_20'], sess_dict['lapsehigh_20'] = \ 

538 (np.nan, np.nan, np.nan, np.nan) 

539 sess_dict['bias_80'], sess_dict['thres_80'], sess_dict['lapselow_80'], sess_dict['lapsehigh_80'] = \ 

540 (np.nan, np.nan, np.nan, np.nan) 

541 

542 else: 

543 # if we can't compute trials then we need to pass 

544 trials = load_trials(session_path, one, collections=alf_collections, force=force, mode='warn') 2 ctx1ab

545 if trials is None: 2 ctx1ab

546 return 

547 

548 sess_dict['performance'], sess_dict['contrasts'], _ = training.compute_performance(trials, prob_right=True) 2 ctx1ab

549 if sess_dict['task_protocol'] == 'training': 2 ctx1ab

550 sess_dict['bias_50'], sess_dict['thres_50'], sess_dict['lapselow_50'], sess_dict['lapsehigh_50'] = \ 1 ctx1b

551 training.compute_psychometric(trials) 

552 sess_dict['bias_20'], sess_dict['thres_20'], sess_dict['lapselow_20'], sess_dict['lapsehigh_20'] = \ 1 ctx1b

553 (np.nan, np.nan, np.nan, np.nan) 

554 sess_dict['bias_80'], sess_dict['thres_80'], sess_dict['lapselow_80'], sess_dict['lapsehigh_80'] = \ 1 ctx1b

555 (np.nan, np.nan, np.nan, np.nan) 

556 else: 

557 sess_dict['bias_50'], sess_dict['thres_50'], sess_dict['lapselow_50'], sess_dict['lapsehigh_50'] = \ 2 ctx1ab

558 training.compute_psychometric(trials, block=0.5) 

559 sess_dict['bias_20'], sess_dict['thres_20'], sess_dict['lapselow_20'], sess_dict['lapsehigh_20'] = \ 2 ctx1ab

560 training.compute_psychometric(trials, block=0.2) 

561 sess_dict['bias_80'], sess_dict['thres_80'], sess_dict['lapselow_80'], sess_dict['lapsehigh_80'] = \ 2 ctx1ab

562 training.compute_psychometric(trials, block=0.8) 

563 

564 sess_dict['performance_easy'] = training.compute_performance_easy(trials) 2 ctx1ab

565 sess_dict['reaction_time'] = training.compute_median_reaction_time(trials) 2 ctx1ab

566 sess_dict['n_trials'] = training.compute_n_trials(trials) 2 ctx1ab

567 sess_dict['sess_duration'], sess_dict['n_delay'], sess_dict['location'] = \ 2 ctx1ab

568 compute_session_duration_delay_location(session_path, collections=raw_collections) 

569 sess_dict['training_status'] = 'not_computed' 2 ctx1ab

570 

571 return sess_dict 2 ctx1ab

572 

573 

574def get_training_info_for_session(session_paths, one, force=True): (empty)

575 """ 

576 Extract the training information needed for plots for each session. 

577 

578 Parameters 

579 ---------- 

580 session_paths : list of pathlib.Path 

581 List of session paths on same date. 

582 one : one.api.One 

583 An ONE instance. 

584 force : bool 

585 When true and if the session trials can't be found, will attempt to re-extract from disk. 

586 

587 Returns 

588 ------- 

589 list of dict 

590 A list of dictionaries the length of `session_paths` containing individual and aggregate 

591 performance information. 

592 """ 

593 

594 # return list of dicts to add 

595 sess_dicts = [] 2 ctx1ab

596 for session_path in session_paths: 2 ctx1ab

597 collections, alf_collections = get_data_collection(session_path) 2 ctx1ab

598 session_path = Path(session_path) 2 ctx1ab

599 protocols = [] 2 ctx1ab

600 for c in collections: 2 ctx1ab

601 try: 2 ctx1ab

602 prot = get_bpod_extractor_class(session_path, task_collection=c) 2 ctx1ab

603 prot = prot[:-6].lower() 2 ctx1ab

604 protocols.append(prot) 2 ctx1ab

605 except ValueError: 

606 continue 

607 

608 un_protocols = np.unique(protocols) 2 ctx1ab

609 # Example, training, training, biased - training would be combined, biased not 

610 sess_dict = None 2 ctx1ab

611 if len(un_protocols) != 1: 2 ctx1ab

612 print(f'Different protocols in same session {session_path} : {protocols}') 

613 for prot in un_protocols: 

614 if prot is False: 

615 continue 

616 try: 

617 alf = alf_collections[np.where(protocols == prot)[0]] 

618 raw = collections[np.where(protocols == prot)[0]] 

619 except TypeError: 

620 alf = None 

621 raw = None 

622 sess_dict = get_sess_dict(session_path, one, prot, alf_collections=alf, raw_collections=raw, force=force) 

623 else: 

624 prot = un_protocols[0] 2 ctx1ab

625 sess_dict = get_sess_dict( 2 ctx1ab

626 session_path, one, prot, alf_collections=alf_collections, raw_collections=collections, force=force) 

627 

628 if sess_dict is not None: 2 ctx1ab

629 sess_dicts.append(sess_dict) 2 ctx1ab

630 

631 protocols = [s['task_protocol'] for s in sess_dicts] 2 ctx1ab

632 

633 if len(protocols) > 0 and len(set(protocols)) != 1: 2 ctx1ab

634 print(f'Different protocols on same date {sess_dicts[0]["date"]} : {protocols}') 

635 

636 # Only if all protocols are the same and are not habituation 

637 if len(sess_dicts) > 1 and len(set(protocols)) == 1 and protocols[0] != 'habituation': # Only if all protocols are the same 2 ctx1ab

638 print(f'{len(sess_dicts)} sessions being combined for date {sess_dicts[0]["date"]}') 1 ctx1b

639 combined_trials = load_combined_trials(session_paths, one, force=force) 1 ctx1b

640 performance, contrasts, _ = training.compute_performance(combined_trials, prob_right=True) 1 ctx1b

641 psychs = {} 1 ctx1b

642 psychs['50'] = training.compute_psychometric(combined_trials, block=0.5) 1 ctx1b

643 psychs['20'] = training.compute_psychometric(combined_trials, block=0.2) 1 ctx1b

644 psychs['80'] = training.compute_psychometric(combined_trials, block=0.8) 1 ctx1b

645 

646 performance_easy = training.compute_performance_easy(combined_trials) 1 ctx1b

647 reaction_time = training.compute_median_reaction_time(combined_trials) 1 ctx1b

648 n_trials = training.compute_n_trials(combined_trials) 1 ctx1b

649 

650 sess_duration = np.nansum([s['sess_duration'] for s in sess_dicts]) 1 ctx1b

651 n_delay = np.nanmax([s['n_delay'] for s in sess_dicts]) 1 ctx1b

652 

653 for sess_dict in sess_dicts: 1 ctx1b

654 sess_dict['combined_performance'] = performance 1 ctx1b

655 sess_dict['combined_contrasts'] = contrasts 1 ctx1b

656 sess_dict['combined_performance_easy'] = performance_easy 1 ctx1b

657 sess_dict['combined_reaction_time'] = reaction_time 1 ctx1b

658 sess_dict['combined_n_trials'] = n_trials 1 ctx1b

659 sess_dict['combined_sess_duration'] = sess_duration 1 ctx1b

660 sess_dict['combined_n_delay'] = n_delay 1 ctx1b

661 

662 for bias in [50, 20, 80]: 1 ctx1b

663 sess_dict[f'combined_bias_{bias}'] = psychs[f'{bias}'][0] 1 ctx1b

664 sess_dict[f'combined_thres_{bias}'] = psychs[f'{bias}'][1] 1 ctx1b

665 sess_dict[f'combined_lapselow_{bias}'] = psychs[f'{bias}'][2] 1 ctx1b

666 sess_dict[f'combined_lapsehigh_{bias}'] = psychs[f'{bias}'][3] 1 ctx1b

667 

668 # Case where two sessions on same day with different number of contrasts! Oh boy 

669 if sess_dict['combined_performance'].size != sess_dict['performance'].size: 1 ctx1b

670 sess_dict['performance'] = \ 

671 np.r_[sess_dict['performance'], 

672 np.full(sess_dict['combined_performance'].size - sess_dict['performance'].size, np.nan)] 

673 sess_dict['contrasts'] = \ 

674 np.r_[sess_dict['contrasts'], 

675 np.full(sess_dict['combined_contrasts'].size - sess_dict['contrasts'].size, np.nan)] 

676 

677 else: 

678 for sess_dict in sess_dicts: 2 ctx1ab

679 sess_dict['combined_performance'] = sess_dict['performance'] 2 ctx1ab

680 sess_dict['combined_contrasts'] = sess_dict['contrasts'] 2 ctx1ab

681 sess_dict['combined_performance_easy'] = sess_dict['performance_easy'] 2 ctx1ab

682 sess_dict['combined_reaction_time'] = sess_dict['reaction_time'] 2 ctx1ab

683 sess_dict['combined_n_trials'] = sess_dict['n_trials'] 2 ctx1ab

684 sess_dict['combined_sess_duration'] = sess_dict['sess_duration'] 2 ctx1ab

685 sess_dict['combined_n_delay'] = sess_dict['n_delay'] 2 ctx1ab

686 

687 for bias in [50, 20, 80]: 2 ctx1ab

688 sess_dict[f'combined_bias_{bias}'] = sess_dict[f'bias_{bias}'] 2 ctx1ab

689 sess_dict[f'combined_thres_{bias}'] = sess_dict[f'thres_{bias}'] 2 ctx1ab

690 sess_dict[f'combined_lapsehigh_{bias}'] = sess_dict[f'lapsehigh_{bias}'] 2 ctx1ab

691 sess_dict[f'combined_lapselow_{bias}'] = sess_dict[f'lapselow_{bias}'] 2 ctx1ab

692 

693 return sess_dicts 2 ctx1ab

694 

695 

696def check_up_to_date(subj_path, df): (empty)

697 """ 

698 Check which sessions on local file system are missing from the computed training table. 

699 

700 Parameters 

701 ---------- 

702 subj_path : pathlib.Path