diff --git a/livecellx/core/pl_utils.py b/livecellx/core/pl_utils.py index c66d1ab..4eee83c 100644 --- a/livecellx/core/pl_utils.py +++ b/livecellx/core/pl_utils.py @@ -1,7 +1,91 @@ from mpl_toolkits.axes_grid1 import make_axes_locatable +import numpy as np +from typing import List +from livecellx.core.single_cell import SingleCellStatic +from livecellx.core.utils import crop_or_pad_img +from livecellx.livecell_logger import main_info, main_warning def add_colorbar(im, ax, fig): divider = make_axes_locatable(ax) cax = divider.append_axes("right", size="3%", pad=0.05) fig.colorbar(im, cax=cax, orientation="vertical") + + +def viz_embedding_region( + embedding, + scs: List[SingleCellStatic], + padding=40, + x_range=(float("-inf"), float("inf")), + y_range=(float("-inf"), float("inf")), + title="Single cell in Embedding Space", + max_crops=10, + fix_dims=None, + randomly_select=True, + sort_by_x=True, + dpi=300, + show_mask=False, +): + _crops = [] + mask_crops = [] + _crop_coords = [] + if fix_dims is not None: + main_info(f"Setting: fix_dims={fix_dims}") + + indices = range(len(scs)) + if randomly_select: + indices = np.random.choice(len(scs), len(scs), replace=False) + + for idx in indices: + _sc = scs[idx] + # print("embedding[idx]", embedding[idx]) + # Embedding in range + if x_range[0] <= embedding[idx][0] <= x_range[1] and y_range[0] <= embedding[idx][1] <= y_range[1]: + # _sc.show(crop=True, padding=20) + # plt.show() + if show_mask: + mask_crop = _sc.get_mask_crop(padding=padding) + img_crop = _sc.get_img_crop(padding=padding) + + if not (fix_dims is None): + img_crop = crop_or_pad_img(img_crop, fix_dims=fix_dims) + if show_mask: + mask_crop = crop_or_pad_img(mask_crop, fix_dims=fix_dims) + _crops.append(img_crop) + if show_mask: + mask_crops.append(mask_crop) + _crop_coords.append(embedding[idx]) + if len(_crops) >= max_crops: + break + + if len(_crops) == 0: + main_info(f"No single cell found in the embedding space") + return + + if sort_by_x: + main_info(f"Sorting crops by x") + sort_indices = np.argsort(np.array(_crop_coords)[:, 0]) + _crops = [_crops[i] for i in sort_indices] + if show_mask: + mask_crops = [mask_crops[i] for i in sort_indices] + _crop_coords = [_crop_coords[i] for i in sort_indices] + + # Visualize crops on one orw + import matplotlib.pyplot as plt + + if show_mask: + fig, axes = plt.subplots(2, len(_crops), figsize=(len(_crops) * 4, 10), dpi=dpi) + else: + fig, axes = plt.subplots(1, len(_crops), figsize=(len(_crops) * 4, 5), dpi=dpi) + axes = [axes] + + for idx in range(len(_crops)): + axes[0][idx].imshow(_crops[idx]) + axes[0][idx].axis("off") + if show_mask: + axes[1][idx].imshow(mask_crops[idx]) + axes[1][idx].axis("off") + + fig.suptitle(title, fontsize=20) + fig.tight_layout(rect=[0, 0.03, 1, 0.95], w_pad=0, h_pad=0) + return fig, axes diff --git a/livecellx/core/single_cell.py b/livecellx/core/single_cell.py index aeea498..c8df086 100644 --- a/livecellx/core/single_cell.py +++ b/livecellx/core/single_cell.py @@ -84,7 +84,7 @@ def __init__( self.bbox = bbox if contour is None and not empty_cell: - main_warning(">>> [SingleCellStatic] WARNING: contour is None, please check if this is intended.") + main_warning(">>> [SingleCellStatic] WARNING: contour is None, please check if this is expected.") contour = np.array([], dtype=int) self.contour = contour @@ -204,13 +204,16 @@ def get_img(self): def get_mask(self, dtype=bool): if isinstance(self.mask_dataset, SingleImageDataset): - return self.mask_dataset.get_img_by_time() - elif not (self.mask_dataset is None) and (self.timeframe in self.mask_dataset.time2url): - return self.mask_dataset[self.timeframe] - elif self.contour is not None: + try: + return self.mask_dataset.get_img_by_time() + except Exception as e: + main_exception( + f"Error getting mask for single cell {self.id} at timeframe {self.timeframe} from presented mask dataset. Using contour mask instead." + ) + if self.contour is not None: return self.get_contour_mask(crop=False, dtype=dtype) - else: - raise ValueError("mask dataset and contour are both None") + + raise ValueError("mask dataset and contour are both None") def get_label_mask(self, dtype=int): mask = self.get_mask(dtype=dtype) @@ -245,6 +248,7 @@ def gen_skimage_bbox_img_crop(bbox, img, padding=0, pad_zeros=False, preprocess_ img_crop = np.pad(img_crop, ((0, padding), (0, 0), (0, 0)), mode="constant") if max_y + padding > img.shape[1]: img_crop = np.pad(img_crop, ((0, 0), (0, padding), (0, 0)), mode="constant") + return img_crop def get_img_crop(self, padding=0, bbox=None, **kwargs): @@ -340,7 +344,9 @@ def to_json_dict(self, include_dataset_json=False, dataset_json_dir=None): self.img_dataset.get_default_json_path(out_dir=dataset_json_dir) ) self.img_dataset.write_json(out_dir=dataset_json_dir, overwrite=False) - if self.mask_dataset is not None: + if isinstance(self.mask_dataset, SingleImageDataset): + pass + elif self.mask_dataset is not None: self.meta[SCKM.JSON_MASK_DATASET_PATH] = str( self.mask_dataset.get_default_json_path(out_dir=dataset_json_dir) ) @@ -433,7 +439,7 @@ def load_from_json_dict(self, json_dict, img_dataset=None, mask_dataset=None): @staticmethod # TODO: check forward declaration change: https://peps.python.org/pep-0484/#forward-references - def load_single_cells_json(path: str) -> List["SingleCellStatic"]: + def load_single_cells_json(path: str, verbose=False) -> List["SingleCellStatic"]: """load a json file containing a list of single cells Parameters @@ -446,20 +452,20 @@ def load_single_cells_json(path: str) -> List["SingleCellStatic"]: _type_ _description_ """ - main_info("loading single cells from json file: " + str(path)) + if verbose: + main_info("loading single cells from json file: " + str(path)) with open(path, "r") as f: sc_json_dict_list = json.load(f) - main_info("loaded " + str(len(sc_json_dict_list)) + " single cells") - main_info("constructing single cells from json dict...") # contour = [] here to suppress warning single_cells = [] for sc_json_dict in tqdm.tqdm(sc_json_dict_list, desc="constructing single cells from json dict"): # Load the single cell from json dict sc = SingleCellStatic(contour=[]).load_from_json_dict(sc_json_dict) single_cells.append(sc) - - main_info("done constructing single cells from json dict") + if verbose: + main_info("Done constructing single cells from json dict") + main_info("loaded " + str(len(single_cells)) + " single cells") return single_cells @staticmethod @@ -590,7 +596,8 @@ def get_bbox_from_contour(contour, dtype=int): @staticmethod def gen_contour_mask( contour, img=None, shape=None, bbox=None, padding=0, crop=True, mask_val=255, dtype=bool - ) -> np.array: + ) -> np.array: # + # TODO: optimize: we do not need img here but shape of img. from skimage.draw import line, polygon assert img is not None or shape is not None, "either img or shape must be provided" @@ -815,6 +822,7 @@ def __init__( mother_trajectories=None, daughter_trajectories=None, meta: Dict[str, Any] = None, + tmp: Dict[str, Any] = None, ) -> None: if timeframe_to_single_cell is None: self.timeframe_to_single_cell = dict() @@ -850,6 +858,11 @@ def __init__( daughter.track_id for daughter in self.daughter_trajectories ] + if tmp is not None: + self.tmp = tmp + else: + self.tmp = {} + def __repr__(self) -> str: return f"SingleCellTrajectory(track_id={self.track_id}, #timeframe set={len(self)})" @@ -1105,7 +1118,7 @@ def is_empty(self): return len(self.timeframe_set) == 0 def subsct(self, min_time, max_time, track_id=None, keep_track_id=False): - """return a subtrajectory of this trajectory, with timeframes between min_time and max_time. Mother and daugher info will be copied if the min_time and max_time are the start and end of the new trajectory, respectively.""" + """return a subtrajectory of this trajectory, with timeframes between [min_time, max_time]. Mother and daugher info will be copied if the min_time and max_time are the start and end of the new trajectory, respectively.""" require_copy_mothers_info = False require_copy_daughters_info = False if self.is_empty(): @@ -1426,7 +1439,13 @@ def show_sct_on_grid( ax_title_fontsize=8, cmap="viridis", ax_contour_polygon_kwargs=dict(fill=None, edgecolor="r"), -) -> matplotlib.axes.Axes: + dpi=300, + show_mask=False, + fig=None, + axes=None, + crop_from_center=True, + show_contour=True, +) -> Tuple[plt.Figure, np.ndarray]: """ Display a grid of single cell images with contours overlaid. @@ -1466,16 +1485,22 @@ def show_sct_on_grid( matplotlib.axes.Axes The axes object containing the grid of subplots. """ - fig, axes = plt.subplots(nr, nc, figsize=(nc * ax_width, nr * ax_height)) - if nr == 1: - axes = np.array([axes]) + if axes is None: + fig, axes = plt.subplots(nr, nc, figsize=(nc * ax_width, nr * ax_height), dpi=dpi) + if nr == 1: + axes = np.array([axes]) + else: + assert np.array(axes).shape == (nr, nc), "axes shape mismatch" + span_range = trajectory.get_timeframe_span() traj_start, traj_end = span_range if start < traj_start: + start = span_range[0] print( - "start timeframe larger than the first timeframe of the trajectory, replace start_timeframe with the first timeframe..." + "start timeframe larger than the first timeframe of the trajectory, replace start_timeframe with the first timeframe={}".format( + int(start) + ) ) - start = span_range[0] if isinstance(ax_contour_polygon_kwargs, dict): ax_contour_polygon_kwargs_list = [ax_contour_polygon_kwargs] * nr * nc @@ -1492,31 +1517,71 @@ def show_sct_on_grid( if timeframe not in trajectory.timeframe_set: continue sc = trajectory.get_single_cell(timeframe) - sc_img = sc.get_img_crop(padding=padding) + if show_mask: + sc_img = sc.get_mask_crop(padding=padding) + else: + sc_img = sc.get_img_crop(padding=padding) contour_coords = sc.get_contour_coords_on_crop(padding=padding) if dims is not None: - sc_img = sc_img[dims_offset[0] : dims_offset[0] + dims[0], dims_offset[1] : dims_offset[1] + dims[1]] - contour_coords[:, 0] -= dims_offset[0] - contour_coords[:, 1] -= dims_offset[1] - - if pad_dims: - _pad_pixels = [max(0, dims[i] - sc_img.shape[i]) for i in range(len(dims))] - sc_img = np.pad(sc_img, _pad_pixels, mode="constant", constant_values=0) - contour_coords[:, 0] += _pad_pixels[0] - contour_coords[:, 1] += _pad_pixels[1] + center_coord = [sc_img.shape[i] // 2 for i in range(2)] + if crop_from_center: + xs, ys, xe, ye = ( + center_coord[0] - dims[0] // 2, + center_coord[1] - dims[1] // 2, + center_coord[0] + dims[0] // 2, + center_coord[1] + dims[1] // 2, + ) + + # Center padding + _center_padding = padding // 2 + xs, ys, xe, ye = ( + xs - _center_padding, + ys - _center_padding, + xe + _center_padding, + ye + _center_padding, + ) + # Fit to boundary of img shape [0, boundary] + xs, ys, xe, ye = max(0, xs), max(0, ys), min(sc_img.shape[0], xe), min(sc_img.shape[1], ye) + sc_img = sc_img[xs:xe, ys:ye] + contour_coords[:, 0] = contour_coords[:, 0] - xs + contour_coords[:, 1] = contour_coords[:, 1] - ys + if pad_dims: + _pad_pixels = [dims[0] - (xe - xs), dims[1] - (ye - ys)] + # Ensure non-neg and //2 for center + _pad_pixels = [max(0, val) // 2 for val in _pad_pixels] + sc_img = np.pad(sc_img, _pad_pixels, mode="constant", constant_values=0) + contour_coords[:, 0] += _pad_pixels[0] + contour_coords[:, 1] += _pad_pixels[1] + else: + sc_img = sc_img[ + dims_offset[0] : dims_offset[0] + dims[0], dims_offset[1] : dims_offset[1] + dims[1] + ] + contour_coords[:, 0] -= dims_offset[0] + contour_coords[:, 1] -= dims_offset[1] + if pad_dims: + _pad_pixels = [max(0, dims[i] - sc_img.shape[i]) for i in range(len(dims))] + sc_img = np.pad(sc_img, _pad_pixels, mode="constant", constant_values=0) + contour_coords[:, 0] += _pad_pixels[0] + contour_coords[:, 1] += _pad_pixels[1] + ax.imshow(sc_img, cmap=cmap) - # draw a polygon based on contour coordinates - from matplotlib.patches import Polygon - polygon = Polygon( - np.array([contour_coords[:, 1], contour_coords[:, 0]]).transpose(), - **ax_contour_polygon_kwargs_list[r * nc + c], - ) - ax.add_patch(polygon) - ax.set_title(f"time: {timeframe}", fontsize=ax_title_fontsize) - fig.tight_layout(pad=0.5, h_pad=0.4, w_pad=0.4) - return axes + if show_contour: + # draw a polygon based on contour coordinates + from matplotlib.patches import Polygon + + polygon = Polygon( + np.array([contour_coords[:, 1], contour_coords[:, 0]]).transpose(), + **ax_contour_polygon_kwargs_list[r * nc + c], + ) + ax.add_patch(polygon) + ax.set_title(f"time: {timeframe}", fontsize=ax_title_fontsize) + + if fig is not None: + main_info(f"tighting figure layout...") + fig.tight_layout(pad=0.5, h_pad=0.4, w_pad=0.4) + return fig, axes def combine_scs_label_masks(scs: SingleCellStatic, scs_labels: list = None, original_meta_label_key=None): @@ -1541,3 +1606,131 @@ def get_time2scs(scs: List[SingleCellStatic]): time2scs[sc.timeframe] = [] time2scs[sc.timeframe].append(sc) return time2scs + + +def sample_samples_from_sctc( + sctc: SingleCellTrajectoryCollection, + objective_sample_num=10000, + exclude_scs_ids=set(), + seed=0, + length_range=(6, 10), + max_trial_counter=1000, + check_nonoverlap=True, +): + def _check_in_visited_range(visited_range, track_id, start_time, end_time): + """check if the given time range of a track is in the visited range""" + if track_id not in visited_range: + return False + for _start, _end in visited_range[track_id]: + # Check if there is any overlap between [_start, _end] and [start_time, end_time] + if _start <= start_time: + ls, le = _start, _end + rs, re = start_time, end_time + else: + ls, le = start_time, end_time + rs, re = _start, _end + if rs <= le: + return True + return False + + # set numpy seed + np.random.seed(seed) + + normal_frame_len_range = length_range + counter = 0 + normal_samples = [] + normal_samples_extra_info = [] + skipped_sample_num = 0 + visited_range = {} + while counter < objective_sample_num and max_trial_counter > 0: + # randomly select a sct from sctc + # generate a list of scs + track_id = np.random.choice(list(sctc.track_id_to_trajectory.keys())) + sct = sctc.get_trajectory(track_id) + # randomly select a length + frame_len = np.random.randint(*normal_frame_len_range) + # generate a sample + times = list(sct.timeframe_to_single_cell.keys()) + times = sorted(times) + if len(times) <= frame_len: + max_trial_counter -= 1 + continue + start_idx = np.random.randint(0, len(times) - frame_len) + start_time = times[start_idx] + end_time = times[start_idx + frame_len - 1] + + if check_nonoverlap and _check_in_visited_range(visited_range, track_id, start_time, end_time): + max_trial_counter -= 1 + continue + if track_id not in visited_range: + visited_range[track_id] = [] + visited_range[track_id].append((start_time, end_time)) + + sub_sct = sct.subsct(start_time, end_time) + + is_some_sc_in_exclude_scs = False + for time, sc in sub_sct.timeframe_to_single_cell.items(): + # print("sc.id:", sc.id, type(sc.id)) + if str(sc.id) in exclude_scs_ids: + is_some_sc_in_exclude_scs = True + break + if is_some_sc_in_exclude_scs: + # print("some sc in the exclude scs list") + skipped_sample_num += 1 + continue + + new_sample = [] + for time, sc in sub_sct.timeframe_to_single_cell.items(): + new_sample.append(sc) + normal_samples.append(new_sample) + normal_samples_extra_info.append( + { + "src_dir": sub_sct.get_all_scs()[0].meta["src_dir"], + "track_id": track_id, + "start_time": start_time, + "end_time": end_time, + } + ) + counter += 1 + + if check_nonoverlap: + print("visited range:", visited_range) + # Check if the generated samples are non-overlapping + main_info("Checking if the generated samples are non-overlapping...") + for i in range(len(normal_samples)): + for j in range(i + 1, len(normal_samples)): + # Retrieve track id, start time, and end time for each sample + track_id_i = normal_samples_extra_info[i]["track_id"] + start_time_i = normal_samples_extra_info[i]["start_time"] + end_time_i = normal_samples_extra_info[i]["end_time"] + track_id_j = normal_samples_extra_info[j]["track_id"] + start_time_j = normal_samples_extra_info[j]["start_time"] + end_time_j = normal_samples_extra_info[j]["end_time"] + + # Check if the two samples overlap + if track_id_i == track_id_j: + if start_time_i <= end_time_j and start_time_j <= end_time_i: + print(f"Overlap found between samples {i} and {j}") + print(f"Sample {i}: track_id={track_id_i}, start_time={start_time_i}, end_time={end_time_i}") + print(f"Sample {j}: track_id={track_id_j}, start_time={start_time_j}, end_time={end_time_j}") + assert False, "Overlap found between samples while checking non-overlapping samples" + main_info("Success: No overlap found between the generated samples") + print("# of skipped samples based on the excluded scs list:", skipped_sample_num) + print("# of generated samples:", len(normal_samples)) + print("# of generated samples extra info:", len(normal_samples_extra_info)) + return normal_samples, normal_samples_extra_info + + +def filter_boundary_cells(scs: List[SingleCellStatic], dist_to_boundary=30): + not_boundary_scs = [] + dim = scs[0].get_img().shape[:2] + for sc in scs: + bbox = sc.get_bbox() + if ( + bbox[0] > dist_to_boundary + and bbox[1] > dist_to_boundary + and bbox[2] < dim[0] - dist_to_boundary + and bbox[3] < dim[1] - dist_to_boundary + ): + not_boundary_scs.append(sc) + return not_boundary_scs diff --git a/livecellx/core/utils.py b/livecellx/core/utils.py index 0a1741c..eeb67fd 100644 --- a/livecellx/core/utils.py +++ b/livecellx/core/utils.py @@ -148,3 +148,23 @@ def intersect(px, py, qx, qy, ax, ay, bx, by): clipped_polygon = clip_edge(clipped_polygon, 0, h, 0, 0) return np.array(clipped_polygon) + + +def crop_or_pad_img(img_crop, fix_dims): + """Crop or pad a 2D image to fix_dims; For crop, crop from the central region""" + if fix_dims is not None: + if img_crop.shape[0] > fix_dims[0]: + start = (img_crop.shape[0] - fix_dims[0]) // 2 + img_crop = img_crop[start : start + fix_dims[0], :] + else: + pad = (fix_dims[0] - img_crop.shape[0]) // 2 + img_crop = np.pad(img_crop, ((pad, pad), (0, 0)), mode="constant", constant_values=0) + + if img_crop.shape[1] > fix_dims[1]: + start = (img_crop.shape[1] - fix_dims[1]) // 2 + img_crop = img_crop[:, start : start + fix_dims[1]] + else: + pad = (fix_dims[1] - img_crop.shape[1]) // 2 + img_crop = np.pad(img_crop, ((0, 0), (pad, pad)), mode="constant", constant_values=0) + + return img_crop diff --git a/livecellx/model_zoo/segmentation/eval_csn.py b/livecellx/model_zoo/segmentation/eval_csn.py index b5b15ef..9884026 100644 --- a/livecellx/model_zoo/segmentation/eval_csn.py +++ b/livecellx/model_zoo/segmentation/eval_csn.py @@ -149,7 +149,9 @@ def evaluate_sample_v3_underseg( original_cell_count = len(np.unique(original_label_mask)) - 1 # -1 for bg assert gt_label_mask is not None, "gt_label_mask is required for evaluation" - assert len(set(np.unique(gt_seg_mask).tolist())) <= 2 + assert ( + len(set(np.unique(gt_seg_mask).tolist())) <= 2 + ), "More than two labels in the gt masks. Please remove this assertation if you are working on mapping cases with more than 2 gt cells (the case in LCA paper)." combined_over_under_seg = np.zeros([3] + list(seg_out_mask.shape[1:])) combined_over_under_seg[0, seg_out_mask[1, :] > out_threshold] = 1 diff --git a/livecellx/model_zoo/segmentation/train_csn.py b/livecellx/model_zoo/segmentation/train_csn.py index 8e77580..8ec5ec2 100644 --- a/livecellx/model_zoo/segmentation/train_csn.py +++ b/livecellx/model_zoo/segmentation/train_csn.py @@ -79,10 +79,13 @@ def parse_args(): def main_train(): args = parse_args() + train_csv_filename = "train_data.csv" + if args.ou_aux: + train_csv_filename = "train_data_aux.csv" print("[Args] ", args) # train_dir = Path("./notebook_results/a549_ccp_vim/train_data_v1") train_dir = Path(args.train_dir) - train_csv = train_dir / "train_data.csv" + train_csv = train_dir / train_csv_filename kernel_size = args.kernel_size train_df = pd.read_csv(train_csv) @@ -161,7 +164,7 @@ def df2dataset(df): test_dataset = None if args.test_dir is not None: test_dir = Path(args.test_dir) - test_csv = test_dir / "train_data.csv" + test_csv = test_dir / train_csv_filename test_df = pd.read_csv(test_csv) test_dataset = df2dataset(test_df) diff --git a/livecellx/segment/ou_utils.py b/livecellx/segment/ou_utils.py index 9ce702d..e69602b 100644 --- a/livecellx/segment/ou_utils.py +++ b/livecellx/segment/ou_utils.py @@ -324,7 +324,9 @@ def csn_augment_helper( # aug_seg_crop = dilate_or_erode_mask(seg_label_crop, scale_factor=scale) aug_seg_crop = dilate_or_erode_label_mask(seg_label_crop, scale_factor=scale) aug_values = np.unique(aug_seg_crop) - assert len(aug_values) <= 2, "only two values should be present in aug masks" + assert ( + len(aug_values) <= 2 + ), "Only two values should be present in aug masks, for over/under-seg cases. You may remove this assertion if working on multi-underseg cases." aug_seg_crop[aug_seg_crop > 0] = 1 aug_seg_crop[aug_seg_crop < 0] = 0 # not necessary, check math save_tiff(aug_seg_crop, augmented_seg_path) @@ -332,7 +334,8 @@ def csn_augment_helper( aug_diff_mask = gen_aug_diff_mask(aug_seg_crop, combined_gt_binary_mask) save_tiff(aug_diff_mask, augmented_diff_seg_path, mode="I") - raw_transformed_img_path = raw_transformed_img_dir / ("img-%d_seg-%d_aug-%d.tif" % (img_id, seg_label, idx)) + filename_pattern_aug = "aug-%d-" + filename_pattern + raw_transformed_img_path = raw_transformed_img_dir / (filename_pattern_aug % (idx, img_id, seg_label)) raw_transformed_img_crop = img_crop.copy().astype(int) raw_transformed_img_crop[aug_seg_crop == 0] *= -1 save_tiff(raw_transformed_img_crop, raw_transformed_img_path, mode="I") @@ -380,7 +383,7 @@ def csn_augment_helper( df = pd.DataFrame(train_path_tuples, columns=cols) # when generate samples in parallel mode, we need to double check race conditions - # currently disable saving when generating samples in parallel mode + # For now please avoid saving parallely when generating samples in parallel mode if df_save_path: if os.path.exists(df_save_path): df.to_csv( diff --git a/livecellx/track/classify_utils.py b/livecellx/track/classify_utils.py index 5368e5e..7e5c907 100644 --- a/livecellx/track/classify_utils.py +++ b/livecellx/track/classify_utils.py @@ -1,7 +1,7 @@ import glob from pathlib import Path import numpy as np -from typing import List, Tuple +from typing import List, Tuple, Dict from scipy import ndimage from livecellx.core.single_cell import SingleCellStatic, SingleCellTrajectory, SingleCellTrajectoryCollection @@ -32,8 +32,20 @@ def load_class2samples_from_json_dir( def load_all_json_dirs( - sample_json_dirs: Path, class_subfolders=["mitosis", "apoptosis", "normal"] -) -> tuple[dict[str, list[SingleCellStatic]], dict[str, list[dict]]]: + sample_json_dirs: List[Path], class_subfolders: List[str] = ["mitosis", "apoptosis", "normal"] +) -> Tuple[Dict[str, List[SingleCellStatic]], Dict[str, List[Dict]]]: + """ + Load annotated samples from multiple JSON directories. + + Args: + sample_json_dirs (List[Path]): List of paths to the JSON directories. + class_subfolders (List[str], optional): List of class subfolders to consider. Defaults to ["mitosis", "apoptosis", "normal"]. + + Returns: + Tuple[Dict[str, List[SingleCellStatic]], Dict[str, List[Dict]]]: A tuple containing two dictionaries: + - all_class2samples: A dictionary mapping class names to lists of SingleCellStatic objects. + - all_class2sample_extra_info: A dictionary mapping class names to lists of additional information dictionaries. + """ all_class2samples = {} all_class2sample_extra_info = {} for sample_json_dir in sample_json_dirs: diff --git a/livecellx/track/data_prep_utils.py b/livecellx/track/data_prep_utils.py index 02e304e..71020fc 100644 --- a/livecellx/track/data_prep_utils.py +++ b/livecellx/track/data_prep_utils.py @@ -1,4 +1,5 @@ from typing import Dict, List + from livecellx.core.single_cell import SingleCellStatic @@ -36,9 +37,6 @@ def is_one_sc_each_time(sample: List[SingleCellStatic]): return True -from typing import Dict, List - - def drop_multiple_cell_frames_in_samples(class2samples: Dict, tar_keys: List[str] = ["mitosis"]) -> Dict: """ Remove SingleCellStatic objects in samples where at the same timepoint, there are >=2 SingleCellStatic objects. diff --git a/livecellx/track/process_annotation_CMU_C2C12.py b/livecellx/track/process_annotation_CMU_C2C12.py new file mode 100644 index 0000000..38eed8a --- /dev/null +++ b/livecellx/track/process_annotation_CMU_C2C12.py @@ -0,0 +1,240 @@ +import argparse +from pathlib import Path +from typing import List +from matplotlib import pyplot as plt + +import numpy as np +import tqdm +from livecellx.core.parallel import parallelize +from livecellx.core.single_cell import ( + SingleCellStatic, + SingleCellTrajectory, + SingleCellTrajectoryCollection, + sample_samples_from_sctc, +) +from livecellx.track.utils_CMU_C2C12 import * +from livecellx.core.datasets import LiveCellImageDatasetManager, LiveCellImageDataset + + +argparser = argparse.ArgumentParser(description="Process annotation for CMU C2C12 dataset") +argparser.add_argument("--xml_path", type=str, help="Path to the xml file") +argparser.add_argument("--out_dir", type=str, help="Output directory", required=True) +argparser.add_argument("--img_dir", type=str, help="Path to the image directory", required=True) +argparser.add_argument("--classes", type=list, help="List of classes", default=["mitosis", "normal"]) +argparser.add_argument("--force_recalculate", action="store_true", help="Force recalculate") +args = argparser.parse_args() + + +def scs_from_CMU_frame_cell_data(cell_data, dataset: LiveCellImageDataset): + scs = [] + for i, timeframe in enumerate(cell_data["timepoints"]): + y, x = cell_data["xcoords"][i], cell_data["ycoords"][i] + # Exclude NaN values + if np.isnan(x) or np.isnan(y): + continue + timeframe = int(timeframe) + # Testing purpose + # if timeframe > 10: + # break + sc = SingleCellStatic(timeframe=timeframe, id=cell_data["cellID"], empty_cell=True, img_dataset=dataset) + sc.meta["cell_status"] = cell_data["cellStatus"][i] + sc.meta["cmu_x"] = x + sc.meta["cmu_y"] = y + sc.meta["cmu_cell_id"] = cell_data["cellID"] + sc.meta["src_dir"] = str(dataset.data_dir_path) + scs.append(sc) + return scs + + +def make_pseudo_square_contour(sc, bbox_size=20, dim_thresholds=None): + x, y = sc.meta["cmu_x"], sc.meta["cmu_y"] + # contour = np.array([[x-5, y-5], [x+5, y-5], [x+5, y+5], [x-5, y+5]], dtype=int) + contour = np.array( + [ + [x - bbox_size, y - bbox_size], + [x + bbox_size, y - bbox_size], + [x + bbox_size, y + bbox_size], + [x - bbox_size, y + bbox_size], + ], + dtype=int, + ) + if dim_thresholds is not None: + contour[:, 0] = np.clip(contour[:, 0], 0, dim_thresholds[0] - 1) + contour[:, 1] = np.clip(contour[:, 1], 0, dim_thresholds[1] - 1) + sc.update_contour(contour) + return sc + + +def make_pseudo_square_contour_sct(sct: SingleCellTrajectory, bbox_size=20): + for t, sc in sct: + make_pseudo_square_contour(sc, bbox_size=bbox_size) + return sct + + +def make_pseudo_square_contour_wrapper(sc, dim_thresholds=None): + make_pseudo_square_contour(sc, dim_thresholds=dim_thresholds) + return sc + + +def is_last_timeframe_mitotic(sct: SingleCellTrajectory) -> bool: + span = sct.get_time_span() + last_sc = sct.get_single_cell(span[1]) + return last_sc.meta["cell_status"] == MITOTIC_STATUS_CODE + + +def any_mitosis_in_sct(sct: SingleCellTrajectory) -> bool: + for t, sc in sct: + if sc.meta["cell_status"] == MITOTIC_STATUS_CODE or sc.meta["cell_status"] == MITOTIC_OR_APOPTOTIC_CODE: + return True + return False + + +def main(): + xml_path = Path(args.xml_path) + if not xml_path.exists(): + raise FileNotFoundError(f"{xml_path} does not exist") + out_dir = args.out_dir + out_dir = Path(out_dir) / xml_path.stem + out_dir.mkdir(parents=True, exist_ok=True) + + import xml.etree.ElementTree as ET + + # xml_data = xml_path.read_text() + tree = ET.parse(xml_path) + root = tree.getroot() + # Extracting all 'fs' nodes + fs_nodes = root.findall("fs") + + # Extracting lineage-centric and frame-centric data + lineage_centric_data = extract_lineage_centric_info(fs_nodes) + frame_centric_data = extract_frame_centric_info(fs_nodes) + + # Construct image dataset + img_dir_path = args.img_dir + # img_dir_path = dataset_dir_path / "images" + dataset = LiveCellImageDataset(img_dir_path, ext="tif") + + inputs = [] + for cell_data in tqdm.tqdm(frame_centric_data): + inputs.append(tuple([cell_data, dataset])) + + outputs = parallelize(scs_from_CMU_frame_cell_data, inputs, cores=32) + scs = [sc for sublist in outputs for sc in sublist] + + print("# of total scs:", len(scs)) + print("# unique cell IDs:", len(set([sc.meta["cmu_cell_id"] for sc in scs]))) + + num_mitotic = len([sc for sc in scs if sc.meta["cell_status"] == MITOTIC_STATUS_CODE]) + print("# of mitotic scs:", num_mitotic) + unique_mitotic_cell_ids = set( + [sc.meta["cmu_cell_id"] for sc in scs if sc.meta["cell_status"] == MITOTIC_STATUS_CODE] + ) + print("# of unique mitotic cell IDs:", len(unique_mitotic_cell_ids)) + + num_mitotic_or_apoptotic = len([sc for sc in scs if sc.meta["cell_status"] == MITOTIC_OR_APOPTOTIC_CODE]) + print("# of mitotic or apoptotic cells:", num_mitotic_or_apoptotic) + unique_mitotic_or_apoptotic_cell_ids = set( + [sc.meta["cmu_cell_id"] for sc in scs if sc.meta["cell_status"] == MITOTIC_OR_APOPTOTIC_CODE] + ) + print("# of unique mitotic or apoptotic cell IDs:", len(unique_mitotic_or_apoptotic_cell_ids)) + + out_dir.mkdir(parents=True, exist_ok=True) + filename = xml_path.stem + scs_out_path = out_dir / f"{filename}_scs.json" + + dims = scs[0].get_img().shape[:2] + if not scs_out_path.exists() or args.force_recalculate: + print("Making pseudo square contours...") + inputs = [(sc, dims) for sc in scs] + outputs = parallelize(make_pseudo_square_contour_wrapper, inputs, cores=32) + scs = outputs + print(f"Writing single cells to {scs_out_path}") + SingleCellStatic.write_single_cells_json(scs, scs_out_path) + else: + scs = SingleCellStatic.load_single_cells_json(scs_out_path) + + # Check and build trajectories + print("Building trajectories...") + cellId_to_scs = {} + for sc in scs: + if sc.id not in cellId_to_scs: + cellId_to_scs[sc.id] = [] + cellId_to_scs[sc.id].append(sc) + + sctc = SingleCellTrajectoryCollection() + for cell_id in cellId_to_scs: + cellId_to_scs[cell_id] = sorted(cellId_to_scs[cell_id], key=lambda x: x.timeframe) + _scs = cellId_to_scs[cell_id] + for i, sc in enumerate(_scs): + if sc == _scs[-1]: + continue + if sc.timeframe + 1 != _scs[i + 1].timeframe: + print(f"Error: {sc.timeframe} and {_scs[i+1].timeframe} are not consecutive timeframes") + + # assert _scs[i+1].timeframe == _scs[i].timeframe + 1, f"Error: {_scs[i].timeframe} and {_scs[i+1].timeframe} are not consecutive timeframes" + t2sc = {} + for sc in _scs: + t2sc[int(sc.timeframe)] = sc + sct = SingleCellTrajectory(track_id=cell_id, timeframe_to_single_cell=t2sc) + assert len(sct) > 0 + sctc.add_trajectory(sct) + + # Visualize last 8 frames of mitosis trajectories + mitosis_preview_out_dir = out_dir / "all_mitosis_preview" + mitosis_preview_out_dir.mkdir(parents=True, exist_ok=True) + nc = 5 + for tid, full_sct in tqdm.tqdm(sctc): + full_span = full_sct.get_time_span() + sct = full_sct.subsct(full_span[1] - 8, full_span[1]) + scs = sct.get_all_scs() + if scs[0].meta["cell_status"] == MITOTIC_STATUS_CODE: + nr = len(sct) // nc + 1 + fig, axes = sct.show_on_grid(padding=50, show_mask=False, nr=nr, nc=nc) + plt.savefig(mitosis_preview_out_dir / f"{tid}.png") + + mitosis_sctc = SingleCellTrajectoryCollection() + window = 8 + for tid, full_sct in tqdm.tqdm(sctc): + full_span = full_sct.get_time_span() + if not is_last_timeframe_mitotic(full_sct): + continue + scs = sct.get_all_scs() + sct = full_sct.subsct(full_span[1] - window, full_span[1]) + mitosis_sctc.add_trajectory(sct) + + mitosis_sctc_out_path = out_dir / f"mitosis_sctc.json" + print(f"Writing mitosis trajectories to {mitosis_sctc_out_path}") + mitosis_sctc.write_json(mitosis_sctc_out_path) + + normal_sctc = SingleCellTrajectoryCollection() + for tid, full_sct in tqdm.tqdm(sctc): + if any_mitosis_in_sct(full_sct): + continue + normal_sctc.add_trajectory(full_sct) + normal_sctc_out_path = out_dir / f"normal_sctc.json" + print(f"Writing normal trajectories to {normal_sctc_out_path}") + normal_sctc.write_json(normal_sctc_out_path) + + print("# of mitosis trajectories:", len(mitosis_sctc)) + print("# of normal trajectories:", len(normal_sctc)) + + def write_samples(samples: List[List[SingleCellStatic]], class_name, out_dir): + out_dir = out_dir / class_name + out_dir.mkdir(parents=True, exist_ok=True) + for i, sample in enumerate(samples): + SingleCellStatic.write_single_cells_json(sample, out_dir / f"{i}.json") + + mitosis_samples = [sct.get_all_scs() for tid, sct in mitosis_sctc] + normal_samples, normal_samples_extra_info = sample_samples_from_sctc( + normal_sctc, objective_sample_num=len(mitosis_samples) * 10 + ) + + print("# mitosis samples:", len(mitosis_samples)) + print("# normal samples:", len(normal_samples)) + + write_samples(mitosis_samples, "mitosis", out_dir) + write_samples(normal_samples, "normal", out_dir) + + +if __name__ == "__main__": + main() diff --git a/livecellx/track/timesformer_inference.py b/livecellx/track/timesformer_inference.py index 3d3a296..c492a29 100644 --- a/livecellx/track/timesformer_inference.py +++ b/livecellx/track/timesformer_inference.py @@ -60,6 +60,11 @@ def inference_recognizer( test_pipeline: Optional[Compose] = None, require_grad=True, return_data_and_grad=False, + crop_shift=False, + start_x=None, + end_x=None, # replace with your actual values + start_y=None, + end_y=None, # replace with your actual values ) -> ActionDataSample: """Inference a video with the recognizer. @@ -76,6 +81,18 @@ def inference_recognizer( predicted scores are saved at ``result.pred_score``. """ + def _crop_shift(input_data: torch.Tensor): + # Assuming input_data is a tensor of shape [3, 3, 8, 224, 224] + + # Crop the region from input_data + cropped_data = input_data[..., start_x:end_x, start_y:end_y] + # Create a new tensor of zeros with the same shape as input_data + padded_data = torch.zeros_like(input_data) + # Copy the cropped data into the new tensor + padded_data[..., : cropped_data.shape[-2], : cropped_data.shape[-1]] = cropped_data + input_data = padded_data + return input_data + if test_pipeline is None: cfg = model.cfg init_default_scope(cfg.get("default_scope", "mmaction")) @@ -102,7 +119,10 @@ def inference_recognizer( data = test_pipeline(data) data = pseudo_collate([data]) - + if crop_shift: + inputs = data["inputs"] + inputs = [_crop_shift(_input_data) for _input_data in inputs] + data["inputs"] = inputs # Forward the model if require_grad: # print("data type", type(data)) diff --git a/livecellx/track/utils_CMU_C2C12.py b/livecellx/track/utils_CMU_C2C12.py new file mode 100644 index 0000000..83c0235 --- /dev/null +++ b/livecellx/track/utils_CMU_C2C12.py @@ -0,0 +1,71 @@ +MITOTIC_STATUS_CODE = 7 +MITOTIC_OR_APOPTOTIC_CODE = 5 +NORMAL_CODE = 4 + + +# Extracting lineage-centric information +def extract_lineage_centric_info(fs_nodes): + lineage_data = [] + mitosis_count = 0 + for fs in fs_nodes: + for f in fs.findall("f"): + for _as in f.findall("as"): + for a_node in _as.findall(".//a"): + cell_id = a_node.get("id") + parent_cell_id = f.get("id") # Parent cell ID is now the ID of 'f' node + sub_as_elements = a_node.findall("as") + if len(sub_as_elements) == 0: # Cell without daughters + continue + sub_as_node = sub_as_elements[0] + sub_as_a_elements = sub_as_node.findall("a") + daughtercell_ids = [] + if len(sub_as_a_elements) == 2: # Cell with daughters + for as_element in sub_as_elements: + for daughter_cell in as_element.findall("a"): + daughtercell_ids.append(daughter_cell.get("id")) + mitosis_count += 1 + elif len(sub_as_a_elements) > 2: + print(f"Error: More than 2 'as' elements for cell ID {cell_id}") + lineage_data.append( + {"cellID": cell_id, "parentcellID": parent_cell_id, "daughtercellIDs": daughtercell_ids} + ) + print("Number of mitosis events:", mitosis_count) + return lineage_data + + +# Extracting frame-centric information +def extract_frame_centric_info(fs_nodes): + frame_data = [] + for fs in fs_nodes: + for f in fs.findall("f"): + for _as in f.findall("as"): + for a in _as.findall(".//a"): + for ss in a.findall("ss"): + cell_id = a.get("id") # Cell ID is now the ID of 'a' node + cell_color = a.get("brush") + cell_type = a.get("type") + xs, ys = [], [] + cell_status = [] + timepoints = [] + for s in ss.findall("s"): + # print("--flag1") + xcoord = float(s.get("x")) + ycoord = float(s.get("y")) + _cs = int(s.get("s")) + xs.append(xcoord) + ys.append(ycoord) + cell_status.append(_cs) + timepoints.append(s.get("i")) + + frame_data.append( + { + "cellID": cell_id, + "cellColour": cell_color, + "cellType": cell_type, + "xcoords": xs, + "ycoords": ys, + "cellStatus": cell_status, + "timepoints": timepoints, + } + ) + return frame_data diff --git a/livecellx/trajectory/lca_annotation.py b/livecellx/trajectory/lca_annotation.py new file mode 100644 index 0000000..8a70dd8 --- /dev/null +++ b/livecellx/trajectory/lca_annotation.py @@ -0,0 +1,48 @@ +from pathlib import Path +from livecellx.livecell_logger import main_info, main_warning +from livecellx.core.single_cell import SingleCellStatic +from livecellx.track.classify_utils import load_class2samples_from_json_dir, load_all_json_dirs + + +def load_hela_data( + hela_json_dirs=[ + Path(r"../datasets/mitosis-annotations-2023/DIC-C2DH-HeLa/01_annotation"), + Path(r"../datasets/mitosis-annotations-2023/DIC-C2DH-HeLa/02_annotation"), + ] +): + + hela_all_class2samples, hela_all_class2sample_extra_info = load_all_json_dirs(hela_json_dirs) + hela_scs = [] + mitosis_hela_cells = [] + for cls in hela_all_class2samples: + main_info(f"Loading {cls} samples, #samples: {len(hela_all_class2samples[cls])}") + for sample in hela_all_class2samples[cls]: + hela_scs.extend(sample) + if cls == "mitosis": + mitosis_hela_cells.extend(sample) + + all_hela_cells_paths = [hela_dir / "single_cells.json" for hela_dir in hela_json_dirs] + all_hela_scs = [] + + for hela_cells_path in all_hela_cells_paths: + _scs = SingleCellStatic.load_single_cells_json(hela_cells_path) + all_hela_scs.extend(_scs) + + mitosis_hela_cell_ids = [sc.id for sc in mitosis_hela_cells] + main_info(f"{len(all_hela_scs)} loaded") + all_non_mitosis_hela_scs = [sc for sc in all_hela_scs if sc.id not in mitosis_hela_cell_ids] + + main_info(f"Loaded {len(mitosis_hela_cells)} mitosis static single cells in total") + main_info(f"Loaded {len(all_non_mitosis_hela_scs)} interphase cells") + main_info(f"Loaded {len(all_hela_scs)} single cells in total") + + for sc in mitosis_hela_cells: + sc.meta["is_mitosis"] = True + for sc in all_non_mitosis_hela_scs: + sc.meta["is_mitosis"] = False + + return all_hela_scs, mitosis_hela_cells, all_non_mitosis_hela_scs + + +if __name__ == "__main__": + load_hela_data() diff --git a/livecellx/trajectory/lca_mitosis_utils.py b/livecellx/trajectory/lca_mitosis_utils.py index 0c98c23..cede697 100644 --- a/livecellx/trajectory/lca_mitosis_utils.py +++ b/livecellx/trajectory/lca_mitosis_utils.py @@ -47,7 +47,7 @@ def split_mitosis_sample( # Corner case, some time after break time contains only 1 sc cur_scs = time2scs[time] if len(cur_scs) == 1: - cur_trajs = [traj + cur_scs[0] for traj in cur_trajs] + cur_trajs = [traj + cur_scs for traj in cur_trajs] continue else: # Simply match scs according to distance diff --git a/notebooks/ViT_scripts/analyze_eval_results.ipynb b/notebooks/ViT_scripts/analyze_eval_results.ipynb new file mode 100644 index 0000000..6881ed2 --- /dev/null +++ b/notebooks/ViT_scripts/analyze_eval_results.ipynb @@ -0,0 +1,546 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 78315 entries, 0 to 78314\n", + "Data columns (total 14 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 path 78315 non-null object\n", + " 1 label_index 78315 non-null int64 \n", + " 2 padding_pixels 78315 non-null int64 \n", + " 3 frame_type 78315 non-null object\n", + " 4 src_dir 78315 non-null object\n", + " 5 track_id 78315 non-null int64 \n", + " 6 start_time 78315 non-null int64 \n", + " 7 end_time 78315 non-null int64 \n", + " 8 first_sc_id 78315 non-null object\n", + " 9 mitosis_traj_type 78315 non-null object\n", + " 10 split 78315 non-null object\n", + " 11 img_path 78315 non-null object\n", + " 12 frame_idx 78315 non-null int64 \n", + " 13 predictions 78315 non-null int64 \n", + "dtypes: int64(7), object(7)\n", + "memory usage: 8.4+ MB\n" + ] + }, + { + "data": { + "text/plain": [ + "(None,\n", + " path label_index padding_pixels \\\n", + " 0 test_mitosis_0_combined_padding-1.mp4 0 1 \n", + " 1 test_mitosis_0_combined_padding-1.mp4 0 1 \n", + " 2 test_mitosis_0_combined_padding-1.mp4 0 1 \n", + " 3 test_mitosis_0_combined_padding-1.mp4 0 1 \n", + " 4 test_mitosis_0_combined_padding-1.mp4 0 1 \n", + " \n", + " frame_type src_dir track_id \\\n", + " 0 combined ../datasets/mitosis-annotations-2023/Gaohan_ti... -1 \n", + " 1 combined ../datasets/mitosis-annotations-2023/Gaohan_ti... -1 \n", + " 2 combined ../datasets/mitosis-annotations-2023/Gaohan_ti... -1 \n", + " 3 combined ../datasets/mitosis-annotations-2023/Gaohan_ti... -1 \n", + " 4 combined ../datasets/mitosis-annotations-2023/Gaohan_ti... -1 \n", + " \n", + " start_time end_time first_sc_id \\\n", + " 0 126 138 92f5e333-1cee-4ea6-9956-e176b3dac89f \n", + " 1 126 138 92f5e333-1cee-4ea6-9956-e176b3dac89f \n", + " 2 126 138 92f5e333-1cee-4ea6-9956-e176b3dac89f \n", + " 3 126 138 92f5e333-1cee-4ea6-9956-e176b3dac89f \n", + " 4 126 138 92f5e333-1cee-4ea6-9956-e176b3dac89f \n", + " \n", + " mitosis_traj_type split img_path \\\n", + " 0 full test imgs/test_mitosis_0_combined_padding-1_0.png \n", + " 1 full test imgs/test_mitosis_0_combined_padding-1_1.png \n", + " 2 full test imgs/test_mitosis_0_combined_padding-1_2.png \n", + " 3 full test imgs/test_mitosis_0_combined_padding-1_3.png \n", + " 4 full test imgs/test_mitosis_0_combined_padding-1_4.png \n", + " \n", + " frame_idx predictions \n", + " 0 0 2 \n", + " 1 1 2 \n", + " 2 2 0 \n", + " 3 3 0 \n", + " 4 4 0 )" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "# Load the prediction results CSV file\n", + "# file_path = '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/eval_results/4090-frame_1-5-combined-batchsize-128/test_predictions.csv'\n", + "# file_path = '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/eval_results/4090-frame_1-5-combined-batchsize-128-affine-aug-batchsize-128/test_predictions.csv'\n", + "file_path = '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/eval_results/resnet50-frame_all-combined/test_predictions.csv'\n", + "# file_path = '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/eval_results/resnet50-frame_all-mask/test_predictions.csv'\n", + "df_predictions = pd.read_csv(file_path)\n", + "\n", + "# Display basic information and the first few rows of the DataFrame\n", + "df_info = df_predictions.info()\n", + "df_head = df_predictions.head()\n", + "\n", + "df_info, df_head" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(0.9748579454766009,\n", + " array([[27311, 1732],\n", + " [ 237, 49035]]))" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.metrics import accuracy_score, confusion_matrix\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Calculate the overall accuracy\n", + "accuracy = accuracy_score(df_predictions['label_index'], df_predictions['predictions'])\n", + "\n", + "# Calculate the confusion matrix\n", + "conf_matrix = confusion_matrix(df_predictions['label_index'], df_predictions['predictions'])\n", + "\n", + "# Plotting the confusion matrix\n", + "plt.figure(figsize=(10, 7))\n", + "sns.heatmap(conf_matrix, annot=True, fmt='g')\n", + "plt.title('Confusion Matrix')\n", + "plt.xlabel('Predicted Labels')\n", + "plt.ylabel('True Labels')\n", + "plt.show()\n", + "\n", + "accuracy, conf_matrix\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "({0: 0.940364287435871, 2: 0.9951899659035558},\n", + " 0.9677771266697134,\n", + " padding_pixels\n", + " 1 0.963043\n", + " 20 0.973548\n", + " 40 0.985165\n", + " 50 0.983021\n", + " 100 0.980608\n", + " 200 0.966935\n", + " 400 0.971671\n", + " dtype: float64)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "# Function to calculate per-class accuracy\n", + "def per_class_accuracy(df, class_label):\n", + " correct_predictions = df[df['label_index'] == class_label]['predictions'] == class_label\n", + " total = df[df['label_index'] == class_label].shape[0]\n", + " accuracy = np.sum(correct_predictions) / total\n", + " return accuracy\n", + "\n", + "# Calculating per-class accuracies\n", + "classes = df_predictions['label_index'].unique()\n", + "class_accuracies = {class_label: per_class_accuracy(df_predictions, class_label) for class_label in classes}\n", + "\n", + "# Calculating overall accuracy again for confirmation\n", + "overall_accuracy = np.mean(list(class_accuracies.values()))\n", + "\n", + "# Analyzing accuracies based on padding pixels\n", + "padding_accuracies = df_predictions.groupby('padding_pixels').apply(lambda x: accuracy_score(x['label_index'], x['predictions']))\n", + "\n", + "# Visualizing the accuracy per padding pixel type\n", + "plt.figure(figsize=(10, 6))\n", + "padding_accuracies.plot(kind='bar')\n", + "plt.title('Accuracy for Each Padding Pixel Type')\n", + "plt.xlabel('Padding Pixels')\n", + "plt.ylabel('Accuracy')\n", + "plt.ylim(0.85, 1)\n", + "plt.xticks(rotation=0)\n", + "plt.show()\n", + "\n", + "class_accuracies, overall_accuracy, padding_accuracies" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "src_dir\n", + "datasets/test_scs_EBSS_starvation/XY16/annotations 1.000000\n", + "../datasets/mitosis-annotations-2023/shiman_CXA_high_density/C10^4 1.000000\n", + "datasets/test_scs_EBSS_starvation/XY1/annotations 1.000000\n", + "../datasets/mitosis-annotations-2023/shiman_CXA_normal/C10^3 1.000000\n", + "./datasets/test_scs_EBSS_starvation/XY16/single_cells.json 0.999006\n", + "./datasets/test_scs_EBSS_starvation/XY1/single_cells.json 0.997040\n", + "../datasets/mitosis-annotations-2023/Gaohan_tifs_CFP_A549-VIM_lessThan24hr_NoTreat_NA_YL_Ti2e_2022-10-19/XY13/annotations 0.992674\n", + "../datasets/mitosis-annotations-2023/shiman_CXA_normal/0.25^4 0.989796\n", + "../datasets/mitosis-annotations-2023/Gaohan_tifs_CFP_A549-VIM_lessThan24hr_NoTreat_NA_YL_Ti2e_2022-10-19/XY12/annotations 0.974247\n", + "../datasets/mitosis-annotations-2023/Gaohan_tifs_CFP_A549-VIM_lessThan24hr_NoTreat_NA_YL_Ti2e_2022-10-19/XY11/annotations 0.972549\n", + "../datasets/mitosis-annotations-2023/Gaohan_tifs_CFP_A549-VIM_lessThan24hr_NoTreat_NA_YL_Ti2e_2022-10-19/XY10/annotations 0.957255\n", + "../datasets/mitosis-annotations-2023/Gaohan_tifs_CFP_A549-VIM_lessThan24hr_NoTreat_NA_YL_Ti2e_2022-10-19/XY8/annotations 0.934605\n", + "../datasets/mitosis-annotations-2023/Gaohan_tifs_CFP_A549-VIM_lessThan24hr_NoTreat_NA_YL_Ti2e_2022-10-19/XY7/annotations 0.908689\n", + "../datasets/mitosis-annotations-2023/shiman_CXA_high_density/C0.75^4 0.897081\n", + "../datasets/mitosis-annotations-2023/Gaohan_tifs_CFP_A549-VIM_lessThan24hr_NoTreat_NA_YL_Ti2e_2022-10-19/XY4/annotations 0.878852\n", + "../datasets/mitosis-annotations-2023/Gaohan_tifs_CFP_A549-VIM_lessThan24hr_NoTreat_NA_YL_Ti2e_2022-10-19/XY9/annotations 0.865019\n", + "../datasets/mitosis-annotations-2023/shiman_CXA_high_density/C0.5^4 0.847619\n", + "../datasets/mitosis-annotations-2023/shiman_CXA_normal/C0.5^4 0.469388\n", + "dtype: float64" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Group by 'src_dir' to calculate accuracy for each source directory\n", + "src_dir_accuracies = df_predictions.groupby('src_dir').apply(\n", + " lambda x: accuracy_score(x['label_index'], x['predictions'])\n", + ")\n", + "\n", + "# Sorting the accuracies for better visualization\n", + "src_dir_accuracies_sorted = src_dir_accuracies.sort_values(ascending=False)\n", + "\n", + "# Visualizing the accuracy per source directory\n", + "plt.figure(figsize=(12, 8))\n", + "src_dir_accuracies_sorted.plot(kind='barh')\n", + "plt.title('Accuracy by Source Directory')\n", + "plt.xlabel('Accuracy')\n", + "plt.ylabel('Source Directory')\n", + "plt.show()\n", + "\n", + "src_dir_accuracies_sorted\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "frame_idx\n", + "0 0.926631\n", + "1 0.952246\n", + "2 0.977953\n", + "3 0.988239\n", + "4 0.989956\n", + "5 0.988906\n", + "6 0.992499\n", + "7 0.991597\n", + "8 0.997073\n", + "9 1.000000\n", + "10 0.999316\n", + "11 1.000000\n", + "12 0.984694\n", + "13 1.000000\n", + "14 0.936877\n", + "15 1.000000\n", + "16 0.989011\n", + "dtype: float64" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# No need to sort as groupby will maintain the order\n", + "frame_idx_accuracies = df_predictions.groupby('frame_idx').apply(\n", + " lambda x: accuracy_score(x['label_index'], x['predictions'])\n", + ")\n", + "\n", + "# Visualizing the accuracy per frame index\n", + "plt.figure(figsize=(14, 10))\n", + "frame_idx_accuracies.plot(kind='bar')\n", + "plt.title('Accuracy by Frame Index')\n", + "plt.xlabel('Frame Index')\n", + "plt.ylabel('Accuracy')\n", + "plt.ylim(0.85, 1)\n", + "plt.xticks(rotation=0) # To display all x-tick labels correctly\n", + "plt.show()\n", + "\n", + "frame_idx_accuracies\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "frame_idx\n", + "0 10931\n", + "1 10931\n", + "2 10931\n", + "3 9608\n", + "4 8264\n", + "5 7301\n", + "6 5999\n", + "7 4522\n", + "8 3416\n", + "9 1995\n", + "10 1463\n", + "11 1197\n", + "12 784\n", + "13 308\n", + "14 301\n", + "15 182\n", + "16 182\n", + "Name: count, dtype: int64\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Check frame_idx distribution\n", + "print(df_predictions['frame_idx'].value_counts())\n", + "\n", + "# Draw distribution of frame_idx\n", + "plt.figure(figsize=(8, 6))\n", + "df_predictions['frame_idx'].value_counts().plot(kind='bar', color='green', alpha=0.8)\n", + "# df_predictions['frame_idx'].hist(bins=50, rwidth=0.8, color='green', alpha=0.8)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "frame_idx_clipped\n", + "0 0.926631\n", + "1 0.952246\n", + "2 0.977953\n", + "3 0.988239\n", + "4 0.989956\n", + "5 0.988906\n", + "6 0.992499\n", + "7 0.991597\n", + "8 0.997073\n", + "9 1.000000\n", + "10 0.999316\n", + "11 1.000000\n", + "12 0.981218\n", + "dtype: float64" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# No need to sort as groupby will maintain the order\n", + "\n", + "clip_max = 12\n", + "df_predictions['frame_idx_clipped'] = df_predictions['frame_idx'].apply(lambda x: x if x < clip_max else clip_max)\n", + "\n", + "frame_idx_accuracies = df_predictions.groupby('frame_idx_clipped').apply(\n", + " lambda x: accuracy_score(x['label_index'], x['predictions'])\n", + ")\n", + "\n", + "# Visualizing the accuracy per frame index\n", + "plt.figure(figsize=(14, 10))\n", + "frame_idx_accuracies.plot(kind='bar')\n", + "plt.title('Accuracy by Frame Index')\n", + "plt.xlabel('Frame Index')\n", + "plt.ylabel('Accuracy')\n", + "plt.xticks(rotation=0) # To display all x-tick labels correctly\n", + "\n", + "# y range 0.8 to 1.0\n", + "plt.ylim(0.75, 1.02)\n", + "\n", + "plt.show()\n", + "\n", + "frame_idx_accuracies\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "accuracy on [0, 8]: 0.9730887445586415\n", + "accuracy on [1, 8]: 0.9814176999278357\n", + "accuracy on [2, 8]: 0.9877900121900042\n", + "accuracy on [3, 8]: 0.9905395039631808\n", + "accuracy on [4, 8]: 0.9912887261880551\n" + ] + } + ], + "source": [ + "from sklearn.metrics import accuracy_score, confusion_matrix\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def calc_acc(df_predictions):\n", + " # Calculate the overall accuracy\n", + " accuracy = accuracy_score(df_predictions['label_index'], df_predictions['predictions'])\n", + "\n", + " # Calculate the confusion matrix\n", + " conf_matrix = confusion_matrix(df_predictions['label_index'], df_predictions['predictions'])\n", + "\n", + " # # Plotting the confusion matrix\n", + " # plt.figure(figsize=(10, 7))\n", + " # sns.heatmap(conf_matrix, annot=True, fmt='g')\n", + " # plt.title('Confusion Matrix')\n", + " # plt.xlabel('Predicted Labels')\n", + " # plt.ylabel('True Labels')\n", + " # plt.show()\n", + "\n", + " return accuracy\n", + "\n", + "end = 8\n", + "for start in range(0 ,5):\n", + " indexer = df_predictions['frame_idx'] >= start\n", + " indexer &= df_predictions['frame_idx'] <= end\n", + "\n", + " print(\"accuracy on [{}, {}]:\".format(start, end), calc_acc(df_predictions[indexer]))\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "livecellx", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/ViT_scripts/eval.py b/notebooks/ViT_scripts/eval.py index b6de70c..52a816b 100644 --- a/notebooks/ViT_scripts/eval.py +++ b/notebooks/ViT_scripts/eval.py @@ -16,14 +16,37 @@ # parser.add_argument("--model_dir", type=str, required=False) parser.add_argument("--data_dir", type=str, default="../notebook_results/mmaction_train_data_v14-inclusive-imgs") parser.add_argument("--ckpt", type=str, default=None) +parser.add_argument("--model_dir", type=str, required=True) parser.add_argument("--out_dir", type=str, default="ViT_workdirs/eval_results/") parser.add_argument("--frame-type", type=str, default="all") +parser.add_argument("--affine-aug", action="store_true") +parser.add_argument("--save_dir_suffix", type=str, default="") +parser.add_argument("--batch_size", type=int, default=32) +parser.add_argument( + "--model", type=str, default="vit_b_16", help="vit_b_16 or resnet50", choices=["vit_b_16", "resnet50"] +) args = parser.parse_args() +print("=" * 40) +print("args:") +for k, v in vars(args).items(): + print(f"{k}: {v}") +print("=" * 40) # Load the best model checkpoint model_checkpoint_path = args.ckpt -model = LcaImageClassificationModel.load_from_checkpoint(model_checkpoint_path) + +# If model_checkpoint_path is None, then load the best checkpoint automatically +# The checkouts are in {args.data_dir}/{args.model_dir}/checkpoints/* with format epoch={epoch}-step={step}.ckpt load the best checkpoint automatically + +import glob + +if model_checkpoint_path is None: + model_checkpoint_path = sorted(glob.glob(f"{args.model_dir}/checkpoints/*.ckpt"))[-1] + print("loading checkpoint automatically:", model_checkpoint_path) + + +model = LcaImageClassificationModel.load_from_checkpoint(model_checkpoint_path, model=args.model) model.eval() device = torch.device("cuda" if torch.cuda.is_available() else "cpu") @@ -39,18 +62,19 @@ test_df = test_df[test_df["frame_type"] == args.frame_type] # Assuming you have the same Transform from your training script -transform = transforms.Compose( - [ - transforms.Resize((224, 224)), - transforms.ToTensor(), - transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), - # transforms.RandomAffine(degrees=30, translate=(0.3, 0.3), scale=(0.5, 1.5)), - ] -) +augs = [ + transforms.Resize((224, 224)), + transforms.ToTensor(), + transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), +] + +if args.affine_aug: + augs += [transforms.RandomAffine(degrees=30, translate=(0.3, 0.3), scale=(0.5, 1.5))] +transform = transforms.Compose(augs) # Create a DataLoader for the test set test_dataset = CustomDataset(test_df, transform=transform, data_dir=Path(args.data_dir)) -test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False, num_workers=32) +test_loader = DataLoader(test_dataset, batch_size=args.batch_size, shuffle=False, num_workers=32) # Evaluate the model import tqdm @@ -69,7 +93,33 @@ # Optionally, if you want to save this DataFrame Path(args.out_dir).mkdir(exist_ok=True, parents=True) -test_df.to_csv(Path(args.out_dir) / "test_predictions.csv", index=False) + +model_name = Path(args.model_dir).name + +if args.affine_aug: + model_name += "-affine-aug" + +model_out_dir = Path(args.out_dir) / (str(model_name) + args.save_dir_suffix) +model_out_dir.mkdir(exist_ok=True, parents=True) +test_df.to_csv(model_out_dir / "test_predictions.csv", index=False) # Display the DataFrame print(test_df.head()) + + +# Save all the wrong predictions separately +wrong_predictions_df = test_df[test_df["label_index"] != test_df["predictions"]] +wrong_predictions_df.to_csv(model_out_dir / "wrong_predictions.csv", index=False) + +# Calculate accuracy, precision, recall, and F1 score and store them in a df +from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score + +metrics_df = pd.DataFrame( + { + "accuracy": [accuracy_score(test_df["label_index"], test_df["predictions"])], + "precision": [precision_score(test_df["label_index"], test_df["predictions"], average="macro")], + "recall": [recall_score(test_df["label_index"], test_df["predictions"], average="macro")], + "f1": [f1_score(test_df["label_index"], test_df["predictions"], average="macro")], + } +) +metrics_df.to_csv(model_out_dir / "metrics.csv", index=False) diff --git a/notebooks/ViT_scripts/figure_extract_tensorboard_data.ipynb b/notebooks/ViT_scripts/figure_extract_tensorboard_data.ipynb new file mode 100644 index 0000000..1b34933 --- /dev/null +++ b/notebooks/ViT_scripts/figure_extract_tensorboard_data.ipynb @@ -0,0 +1,732 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: tensorflow in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (2.15.0.post1)\n", + "Requirement already satisfied: absl-py>=1.0.0 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (2.0.0)\n", + "Requirement already satisfied: astunparse>=1.6.0 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (1.6.3)\n", + "Requirement already satisfied: flatbuffers>=23.5.26 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (23.5.26)\n", + "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (0.5.4)\n", + "Requirement already satisfied: google-pasta>=0.1.1 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (0.2.0)\n", + "Requirement already satisfied: h5py>=2.9.0 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (3.10.0)\n", + "Requirement already satisfied: libclang>=13.0.0 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (16.0.6)\n", + "Requirement already satisfied: ml-dtypes~=0.2.0 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (0.2.0)\n", + "Requirement already satisfied: numpy<2.0.0,>=1.23.5 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (1.26.1)\n", + "Requirement already satisfied: opt-einsum>=2.3.2 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (3.3.0)\n", + "Requirement already satisfied: packaging in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (23.2)\n", + "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (4.23.4)\n", + "Requirement already satisfied: setuptools in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (60.2.0)\n", + "Requirement already satisfied: six>=1.12.0 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (1.16.0)\n", + "Requirement already satisfied: termcolor>=1.1.0 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (2.3.0)\n", + "Requirement already satisfied: typing-extensions>=3.6.6 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (4.8.0)\n", + "Requirement already satisfied: wrapt<1.15,>=1.11.0 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (1.14.1)\n", + "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (0.35.0)\n", + "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (1.59.0)\n", + "Requirement already satisfied: tensorboard<2.16,>=2.15 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (2.15.1)\n", + "Requirement already satisfied: tensorflow-estimator<2.16,>=2.15.0 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (2.15.0)\n", + "Requirement already satisfied: keras<2.16,>=2.15.0 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorflow) (2.15.0)\n", + "Requirement already satisfied: wheel<1.0,>=0.23.0 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from astunparse>=1.6.0->tensorflow) (0.41.2)\n", + "Requirement already satisfied: google-auth<3,>=1.6.3 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorboard<2.16,>=2.15->tensorflow) (2.23.3)\n", + "Requirement already satisfied: google-auth-oauthlib<2,>=0.5 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorboard<2.16,>=2.15->tensorflow) (1.0.0)\n", + "Requirement already satisfied: markdown>=2.6.8 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorboard<2.16,>=2.15->tensorflow) (3.5)\n", + "Requirement already satisfied: requests<3,>=2.21.0 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorboard<2.16,>=2.15->tensorflow) (2.28.2)\n", + "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorboard<2.16,>=2.15->tensorflow) (0.7.1)\n", + "Requirement already satisfied: werkzeug>=1.0.1 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from tensorboard<2.16,>=2.15->tensorflow) (3.0.0)\n", + "Requirement already satisfied: cachetools<6.0,>=2.0.0 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from google-auth<3,>=1.6.3->tensorboard<2.16,>=2.15->tensorflow) (5.3.1)\n", + "Requirement already satisfied: pyasn1-modules>=0.2.1 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from google-auth<3,>=1.6.3->tensorboard<2.16,>=2.15->tensorflow) (0.3.0)\n", + "Requirement already satisfied: rsa<5,>=3.1.4 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from google-auth<3,>=1.6.3->tensorboard<2.16,>=2.15->tensorflow) (4.9)\n", + "Requirement already satisfied: requests-oauthlib>=0.7.0 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from google-auth-oauthlib<2,>=0.5->tensorboard<2.16,>=2.15->tensorflow) (1.3.1)\n", + "Requirement already satisfied: importlib-metadata>=4.4 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from markdown>=2.6.8->tensorboard<2.16,>=2.15->tensorflow) (6.8.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from requests<3,>=2.21.0->tensorboard<2.16,>=2.15->tensorflow) (3.3.0)\n", + "Requirement already satisfied: idna<4,>=2.5 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from requests<3,>=2.21.0->tensorboard<2.16,>=2.15->tensorflow) (3.4)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from requests<3,>=2.21.0->tensorboard<2.16,>=2.15->tensorflow) (1.26.18)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from requests<3,>=2.21.0->tensorboard<2.16,>=2.15->tensorflow) (2023.7.22)\n", + "Requirement already satisfied: MarkupSafe>=2.1.1 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from werkzeug>=1.0.1->tensorboard<2.16,>=2.15->tensorflow) (2.1.3)\n", + "Requirement already satisfied: zipp>=0.5 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from importlib-metadata>=4.4->markdown>=2.6.8->tensorboard<2.16,>=2.15->tensorflow) (3.17.0)\n", + "Requirement already satisfied: pyasn1<0.6.0,>=0.4.6 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard<2.16,>=2.15->tensorflow) (0.5.0)\n", + "Requirement already satisfied: oauthlib>=3.0.0 in /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<2,>=0.5->tensorboard<2.16,>=2.15->tensorflow) (3.2.2)\n", + "\u001b[33mDEPRECATION: pytorch-lightning 1.5.6 has a non-standard dependency specifier torch>=1.7.*. pip 24.0 will enforce this behaviour change. A possible replacement is to upgrade to a newer version of pytorch-lightning or contact the author to suggest that they release a version with a conforming dependency specifiers. Discussion can be found at https://github.com/pypa/pip/issues/12063\u001b[0m\u001b[33m\n", + "\u001b[0m" + ] + } + ], + "source": [ + "!pip install tensorflow" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-01-31 07:12:21.351229: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-01-31 07:12:21.351257: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-01-31 07:12:21.352412: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-01-31 07:12:21.358375: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-01-31 07:12:21.851856: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + "from tensorflow.python.summary.summary_iterator import summary_iterator\n", + "\n", + "def extract_data_from_event_file(event_file):\n", + " data = {}\n", + " for e in summary_iterator(event_file):\n", + " for v in e.summary.value:\n", + " if v.tag not in data:\n", + " data[v.tag] = []\n", + " data[v.tag].append((e.step, v.simple_value))\n", + " return data\n", + "\n", + "# event_file_path = '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_0-5-mask /events.out.tfevents.1705092098.xing-lab-5.592897.0' # replace with your file path\n", + "# event_file_path = \"/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_1-5-combined/events.out.tfevents.1705043460.xing-lab-5.154198.0\"\n", + "# extracted_data = extract_data_from_event_file(event_file_path)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import os \n", + "model_out_dir = '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/'\n", + "# all subfolder in model_out_dir\n", + "model_dirs = [f.path for f in os.scandir(model_out_dir) if f.is_dir() ]\n", + "\n", + "# all event files in each subfolder\n", + "event_files = []\n", + "for model_dir in model_dirs:\n", + " _model_events = [f.path for f in os.scandir(model_dir) if f.is_file() and f.name.startswith('events.out.tfevents')]\n", + " assert len(_model_events) == 1, _model_events\n", + " event_files.append(_model_events[0])\n", + "\n", + "event_files = sorted(event_files)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /home/ken67/anaconda3/envs/livecellx/lib/python3.9/site-packages/tensorflow/python/summary/summary_iterator.py:27: tf_record_iterator (from tensorflow.python.lib.io.tf_record) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use eager execution and: \n", + "`tf.data.TFRecordDataset(path)`\n" + ] + } + ], + "source": [ + "all_extracted_data = []\n", + "for event in event_files:\n", + " extracted_data = extract_data_from_event_file(event)\n", + " all_extracted_data.append(extracted_data)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "dict_keys(['hp_metric', '_hparams_/experiment', '_hparams_/session_start_info', '_hparams_/session_end_info'])\n", + "1\n", + "dict_keys(['hp_metric', '_hparams_/experiment', '_hparams_/session_start_info', '_hparams_/session_end_info', 'train_loss_step', 'train_acc_step', 'epoch', 'val_loss_step', 'val_acc_step', 'val_loss_epoch', 'val_acc_epoch', 'train_loss_epoch', 'train_acc_epoch'])\n", + "2\n", + "dict_keys(['hp_metric', '_hparams_/experiment', '_hparams_/session_start_info', '_hparams_/session_end_info', 'train_loss_step', 'train_acc_step', 'epoch', 'val_loss_step', 'val_acc_step', 'val_loss_epoch', 'val_acc_epoch', 'train_loss_epoch', 'train_acc_epoch'])\n", + "3\n", + "dict_keys(['hp_metric', '_hparams_/experiment', '_hparams_/session_start_info', '_hparams_/session_end_info', 'train_loss_step', 'train_acc_step', 'epoch', 'val_loss_step', 'val_acc_step', 'val_loss_epoch', 'val_acc_epoch', 'train_loss_epoch', 'train_acc_epoch'])\n", + "4\n", + "dict_keys(['train_loss_step', 'train_acc_step', 'epoch', 'val_loss_step', 'val_acc_step', 'val_loss_epoch', 'val_acc_epoch', 'train_loss_epoch', 'train_acc_epoch'])\n", + "5\n", + "dict_keys(['train_loss_step', 'train_acc_step', 'epoch', 'val_loss_step', 'val_acc_step', 'val_loss_epoch', 'val_acc_epoch', 'train_loss_epoch', 'train_acc_epoch'])\n", + "6\n", + "dict_keys(['hp_metric', '_hparams_/experiment', '_hparams_/session_start_info', '_hparams_/session_end_info', 'train_loss_step', 'train_acc_step', 'epoch', 'val_loss_step', 'val_acc_step', 'val_loss_epoch', 'val_acc_epoch', 'train_loss_epoch', 'train_acc_epoch'])\n", + "7\n", + "dict_keys(['hp_metric', '_hparams_/experiment', '_hparams_/session_start_info', '_hparams_/session_end_info', 'train_loss_step', 'train_acc_step', 'epoch', 'val_loss_step', 'val_acc_step', 'val_loss_epoch', 'val_acc_epoch', 'train_loss_epoch', 'train_acc_epoch'])\n", + "8\n", + "dict_keys(['train_loss_step', 'train_acc_step', 'epoch', 'val_loss_step', 'val_acc_step', 'val_loss_epoch', 'val_acc_epoch', 'train_loss_epoch', 'train_acc_epoch'])\n", + "9\n", + "dict_keys(['train_loss_step', 'train_acc_step', 'epoch', 'val_loss_step', 'val_acc_step', 'val_loss_epoch', 'val_acc_epoch', 'train_loss_epoch', 'train_acc_epoch'])\n", + "10\n", + "dict_keys(['train_loss_step', 'train_acc_step', 'epoch', 'val_loss_step', 'val_acc_step', 'val_loss_epoch', 'val_acc_epoch', 'train_loss_epoch', 'train_acc_epoch'])\n", + "11\n", + "dict_keys(['train_loss_step', 'train_acc_step', 'epoch', 'val_loss_step', 'val_acc_step', 'val_loss_epoch', 'val_acc_epoch', 'train_loss_epoch', 'train_acc_epoch'])\n", + "12\n", + "dict_keys(['train_loss_step', 'train_acc_step', 'epoch', 'val_loss_step', 'val_acc_step', 'val_loss_epoch', 'val_acc_epoch', 'train_loss_epoch', 'train_acc_epoch'])\n", + "13\n", + "dict_keys(['train_loss_step', 'train_acc_step', 'epoch', 'val_loss_step', 'val_acc_step', 'val_loss_epoch', 'val_acc_epoch', 'train_loss_epoch', 'train_acc_epoch'])\n", + "14\n", + "dict_keys(['train_loss_step', 'train_acc_step', 'epoch', 'val_loss_step', 'val_acc_step', 'val_loss_epoch', 'val_acc_epoch', 'train_loss_epoch', 'train_acc_epoch'])\n", + "15\n", + "dict_keys(['train_loss_step', 'train_acc_step', 'epoch', 'val_loss_step', 'val_acc_step', 'val_loss_epoch', 'val_acc_epoch', 'train_loss_epoch', 'train_acc_epoch'])\n", + "16\n", + "dict_keys(['train_loss_step', 'train_acc_step', 'epoch', 'val_loss_step', 'val_acc_step', 'val_loss_epoch', 'val_acc_epoch', 'train_loss_epoch', 'train_acc_epoch'])\n" + ] + } + ], + "source": [ + "# Visualize data\n", + "\n", + "for i, data in enumerate(all_extracted_data):\n", + " print(i)\n", + " print(data.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/4090-frame_0-5-combined-batchsize-128/events.out.tfevents.1705425774.xing-lab-5.2040635.0',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/4090-frame_1-5-combined-batchsize-128/events.out.tfevents.1705233907.xing-lab-5.1250328.0',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/4090-frame_1-5-combined-batchsize-32/events.out.tfevents.1705231759.xing-lab-5.1236165.0',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/4090-frame_1-5-combined-batchsize-64/events.out.tfevents.1705231976.xing-lab-5.1241306.0',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/cluster-frame_1-5-combined/events.out.tfevents.1705211693.g008',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_0-5-combined/events.out.tfevents.1705145869.g002',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_0-5-mask /events.out.tfevents.1705092098.xing-lab-5.592897.0',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_1-5-combined/events.out.tfevents.1705043460.xing-lab-5.154198.0',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_1-5-mask/events.out.tfevents.1705145868.g006',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_1-end-combined/events.out.tfevents.1705145869.g004',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_all_combined-lr=0.00001/events.out.tfevents.1705211205.g002',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_all_combined/events.out.tfevents.1705145864.g005',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_all_mask/events.out.tfevents.1705145868.g007',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/resnet50-frame_1-5-combined/events.out.tfevents.1705146297.g004',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/resnet50-frame_1-5-mask/events.out.tfevents.1705146296.g005',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/resnet50-frame_all-combined/events.out.tfevents.1705146356.g007',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/resnet50-frame_all-mask/events.out.tfevents.1705146297.g006']" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "event_files" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/4090-frame_0-5-combined-batchsize-128/events.out.tfevents.1705425774.xing-lab-5.2040635.0',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/4090-frame_1-5-combined-batchsize-128/events.out.tfevents.1705233907.xing-lab-5.1250328.0',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/4090-frame_1-5-combined-batchsize-32/events.out.tfevents.1705231759.xing-lab-5.1236165.0',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/4090-frame_1-5-combined-batchsize-64/events.out.tfevents.1705231976.xing-lab-5.1241306.0',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/cluster-frame_1-5-combined/events.out.tfevents.1705211693.g008',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_0-5-combined/events.out.tfevents.1705145869.g002',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_0-5-mask /events.out.tfevents.1705092098.xing-lab-5.592897.0',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_1-5-combined/events.out.tfevents.1705043460.xing-lab-5.154198.0',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_1-5-mask/events.out.tfevents.1705145868.g006',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_1-end-combined/events.out.tfevents.1705145869.g004',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_all_combined-lr=0.00001/events.out.tfevents.1705211205.g002',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_all_combined/events.out.tfevents.1705145864.g005',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_all_mask/events.out.tfevents.1705145868.g007',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/resnet50-frame_1-5-combined/events.out.tfevents.1705146297.g004',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/resnet50-frame_1-5-mask/events.out.tfevents.1705146296.g005',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/resnet50-frame_all-combined/events.out.tfevents.1705146356.g007',\n", + " '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/resnet50-frame_all-mask/events.out.tfevents.1705146297.g006']" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "event_files" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pathlib import Path\n", + "import matplotlib.pyplot as plt\n", + "key = 'val_acc_epoch'\n", + "\n", + "\n", + "# Create a figure and a set of subplots\n", + "fig, axs = plt.subplots(2, 1, figsize=(8, 6), dpi=300)\n", + "markers = ['v', '^', '<', '>', '1', 'o', 's', 'p', '*', 'h', 'H', 'D', 'd', 'P', 'X']\n", + "\n", + "chosen_event_file_indices = [1 , 2 ,3, 4, 7]\n", + "chosen_event_files = [event_files[i] for i in chosen_event_file_indices]\n", + "chosen_all_extracted_data = [all_extracted_data[i] for i in chosen_event_file_indices]\n", + "\n", + "STEP = 10\n", + "for i, data in enumerate(chosen_all_extracted_data):\n", + " if key not in data:\n", + " print(\">>> warning: key {} not in data from {}\".format(key, chosen_event_files[i]))\n", + " continue\n", + " _avg_accs = [y for x, y in data[key]]\n", + " # plt.plot(xs, ys, label=str(i))\n", + " _marker = markers[i % len(markers)]\n", + " if i !=0 and i!= len(chosen_all_extracted_data)-1:\n", + " _marker = 'x'\n", + " _color = 'blue'\n", + " else:\n", + " _marker = 'o'\n", + " _color = 'red'\n", + " # Plot the training data\n", + " _label = Path(chosen_event_files[i]).parent.name\n", + " axs[0].plot(range(1, len(_avg_accs) + 1, STEP), _avg_accs[::STEP], marker=_marker, \n", + " color=_color, \n", + " label=_label)\n", + "\n", + "plt.legend()\n", + "\n", + "# Add legends to the subplots\n", + "for ax in axs:\n", + " ax.legend(loc=\"upper left\", bbox_to_anchor=(1,1))\n", + "axs[0].title.set_text('Testing accuracy')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + ">>> warning: key val_acc_epoch not in data from /home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/4090-frame_0-5-combined-batchsize-128/events.out.tfevents.1705425774.xing-lab-5.2040635.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pathlib import Path\n", + "import matplotlib.pyplot as plt\n", + "key = 'val_acc_epoch'\n", + "\n", + "\n", + "# Create a figure and a set of subplots\n", + "fig, axs = plt.subplots(2, 1, figsize=(8, 8), dpi=300)\n", + "markers = ['v', '^', '<', '>', '1', 'o', 's', 'p', '*', 'h', 'H', 'D', 'd', 'P', 'X']\n", + "\n", + "chosen_event_file_indices = range(len(event_files))\n", + "chosen_event_files = [event_files[i] for i in chosen_event_file_indices]\n", + "chosen_all_extracted_data = [all_extracted_data[i] for i in chosen_event_file_indices]\n", + "\n", + "STEP = 5\n", + "for i, data in enumerate(chosen_all_extracted_data):\n", + " if key not in data:\n", + " print(\">>> warning: key {} not in data from {}\".format(key, chosen_event_files[i]))\n", + " continue\n", + " _avg_accs = [y for x, y in data[key]]\n", + " print(\">>> \", chosen_event_files[i])\n", + " print(\">>> max acc: \", max(_avg_accs))\n", + " _label = Path(chosen_event_files[i]).parent.name\n", + " _marker = markers[i % len(markers)]\n", + " if _label.find('combined') == -1:\n", + " continue \n", + " elif _label.find('resnet') != -1:\n", + " _marker = 'o'\n", + " _color = 'blue'\n", + " else:\n", + " _marker = 'x'\n", + " _color = 'red'\n", + " # _color = 'red'\n", + " # Plot the training data\n", + " \n", + " axs[0].plot(range(1, len(_avg_accs) + 1, STEP), _avg_accs[::STEP], marker=_marker, \n", + " color=_color, \n", + " label=_label)\n", + "\n", + "plt.legend()\n", + "\n", + "# Add legends to the subplots\n", + "for ax in axs:\n", + " ax.legend(loc=\"upper left\", bbox_to_anchor=(1.1,1))\n", + "\n", + "# Set the x-axis and y-axis labels of the subplots\n", + "for ax in axs:\n", + " ax.set_xlabel('Epoch', fontsize=16)\n", + " ax.set_ylabel('Accuracy', fontsize=16)\n", + "\n", + "# Set the y-axis range for all subplots\n", + "# for ax in axs:\n", + "# ax.set_ylim([0.86, 1])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ">>> warning: key val_acc_epoch not in data from /home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/4090-frame_0-5-combined-batchsize-128/events.out.tfevents.1705425774.xing-lab-5.2040635.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pathlib import Path\n", + "import matplotlib.pyplot as plt\n", + "# key = 'train_acc_epoch'\n", + "\n", + "key = 'val_acc_epoch'\n", + "\n", + "# Create a figure and a set of subplots\n", + "fig, axs = plt.subplots(1, 1, figsize=(8, 4), dpi=300)\n", + "axs = [axs]\n", + "\n", + "markers = ['v', '^', '<', '>', '1', 'o', 's', 'p', '*', 'h', 'H', 'D', 'd', 'P', 'X']\n", + "\n", + "chosen_event_file_indices = range(len(event_files))\n", + "chosen_event_files = [event_files[i] for i in chosen_event_file_indices]\n", + "chosen_all_extracted_data = [all_extracted_data[i] for i in chosen_event_file_indices]\n", + "\n", + "STEP = 5\n", + "for i, data in enumerate(chosen_all_extracted_data):\n", + " if key not in data:\n", + " print(\">>> warning: key {} not in data from {}\".format(key, chosen_event_files[i]))\n", + " continue\n", + " _avg_accs = [y for x, y in data[key]]\n", + "\n", + " _label = Path(chosen_event_files[i]).parent.name\n", + " _marker = markers[i % len(markers)]\n", + " if max(_avg_accs) < 0.95 or _label.find(\"resnet\") != -1:\n", + " continue \n", + " if _label.find(\"resnet\") == -1:\n", + " _marker = 'x'\n", + " else:\n", + " _marker = 'o'\n", + " if _label.find('combined') == -1:\n", + " _color = 'blue'\n", + " else:\n", + " _color = 'red'\n", + " # _color = 'red'\n", + " # Plot the training data\n", + " \n", + " axs[0].plot(range(1, len(_avg_accs) + 1, STEP), _avg_accs[::STEP], marker=_marker, \n", + " color=_color, \n", + " label=_label)\n", + "\n", + "plt.legend()\n", + "\n", + "# Add legends to the subplots\n", + "for ax in axs:\n", + " ax.legend(loc=\"upper left\", bbox_to_anchor=(1.1,1))\n", + "\n", + "# Set the x-axis and y-axis labels of the subplots\n", + "for ax in axs:\n", + " ax.set_xlabel('Epoch', fontsize=16)\n", + " ax.set_ylabel('Accuracy', fontsize=16)\n", + "\n", + "# Set the y-axis range for all subplots\n", + "# for ax in axs:\n", + "# ax.set_ylim([0.86, 1])\n", + "axs[0].title.set_text('Testing accuracy: ViT')\n", + "# axs[0].title.set_text('Training accuracy: ResNet50')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ">>> warning: key val_acc_epoch not in data from /home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/4090-frame_0-5-combined-batchsize-128/events.out.tfevents.1705425774.xing-lab-5.2040635.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pathlib import Path\n", + "import matplotlib.pyplot as plt\n", + "# key = 'train_acc_epoch'\n", + "\n", + "key = 'val_acc_epoch'\n", + "\n", + "# Create a figure and a set of subplots\n", + "fig, axs = plt.subplots(1, 1, figsize=(8, 4), dpi=300)\n", + "axs = [axs]\n", + "\n", + "markers = ['v', '^', '<', '>', '1', 'o', 's', 'p', '*', 'h', 'H', 'D', 'd', 'P', 'X']\n", + "\n", + "chosen_event_file_indices = range(len(event_files))\n", + "chosen_event_files = [event_files[i] for i in chosen_event_file_indices]\n", + "chosen_all_extracted_data = [all_extracted_data[i] for i in chosen_event_file_indices]\n", + "\n", + "STEP = 5\n", + "for i, data in enumerate(chosen_all_extracted_data):\n", + " if key not in data:\n", + " print(\">>> warning: key {} not in data from {}\".format(key, chosen_event_files[i]))\n", + " continue\n", + " _avg_accs = [y for x, y in data[key]]\n", + "\n", + " _label = Path(chosen_event_files[i]).parent.name\n", + " _marker = markers[i % len(markers)]\n", + " if max(_avg_accs) < 0.95 or _label.find(\"resnet\") != -1:\n", + " continue \n", + " if _label.find(\"resnet\") == -1:\n", + " _marker = 'x'\n", + " else:\n", + " _marker = 'o'\n", + " if _label.find('combined') == -1:\n", + " _color = 'blue'\n", + " else:\n", + " _color = 'red'\n", + " # _color = 'red'\n", + " # Plot the training data\n", + " \n", + " axs[0].plot(range(1, len(_avg_accs) + 1, STEP), _avg_accs[::STEP], marker=_marker, \n", + " color=_color, \n", + " label=_label)\n", + "\n", + "plt.legend()\n", + "\n", + "# Add legends to the subplots\n", + "for ax in axs:\n", + " ax.legend(loc=\"upper left\", bbox_to_anchor=(1.1,1))\n", + "\n", + "# Set the x-axis and y-axis labels of the subplots\n", + "for ax in axs:\n", + " ax.set_xlabel('Epoch', fontsize=16)\n", + " ax.set_ylabel('Accuracy', fontsize=16)\n", + "\n", + "# Set the y-axis range for all subplots\n", + "# for ax in axs:\n", + "# ax.set_ylim([0.86, 1])\n", + "axs[0].title.set_text('Testing accuracy: ViT')\n", + "# axs[0].title.set_text('Training accuracy: ResNet50')" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(17, 17)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(event_files), len(all_extracted_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "chosen event file indices: [6, 8, 12, 14, 16]\n", + "chosen event files: ['/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_0-5-mask /events.out.tfevents.1705092098.xing-lab-5.592897.0', '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_1-5-mask/events.out.tfevents.1705145868.g006', '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_all_mask/events.out.tfevents.1705145868.g007', '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/resnet50-frame_1-5-mask/events.out.tfevents.1705146296.g005', '/home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/resnet50-frame_all-mask/events.out.tfevents.1705146297.g006']\n", + ">>> /home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_0-5-mask /events.out.tfevents.1705092098.xing-lab-5.592897.0\n", + ">>> max acc: 0.7355346083641052\n", + ">>> /home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_1-5-mask/events.out.tfevents.1705145868.g006\n", + ">>> max acc: 0.7284787893295288\n", + ">>> /home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/frame_all_mask/events.out.tfevents.1705145868.g007\n", + ">>> max acc: 0.6297516226768494\n", + ">>> /home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/resnet50-frame_1-5-mask/events.out.tfevents.1705146296.g005\n", + ">>> max acc: 0.8454767465591431\n", + ">>> /home/ken67/livecellx/notebooks/ViT_scripts/ViT_workdirs/ViT_lightning_logs/resnet50-frame_all-mask/events.out.tfevents.1705146297.g006\n", + ">>> max acc: 0.8639213442802429\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pathlib import Path\n", + "import matplotlib.pyplot as plt\n", + "# key = 'train_acc_epoch'\n", + "\n", + "key = 'val_acc_epoch'\n", + "\n", + "# Create a figure and a set of subplots\n", + "fig, axs = plt.subplots(1, 1, figsize=(8, 4), dpi=300)\n", + "axs = [axs]\n", + "\n", + "markers = ['v', '^', '<', '>', '1', 'o', 's', 'p', '*', 'h', 'H', 'D', 'd', 'P', 'X']\n", + "\n", + "# chosen_event_file_indices = range(len(event_files))\n", + "chosen_event_file_indices = [i for i in range(len(event_files)) if event_files[i].find('mask') != -1]\n", + "chosen_event_files = [event_file for event_file in event_files if event_file.find('mask') != -1]\n", + "chosen_all_extracted_data = [all_extracted_data[i] for i in chosen_event_file_indices]\n", + "print(\"chosen event file indices: \", chosen_event_file_indices)\n", + "print(\"chosen event files: \", chosen_event_files)\n", + "\n", + "\n", + "STEP = 5\n", + "for i, data in enumerate(chosen_all_extracted_data):\n", + " if key not in data:\n", + " print(\">>> warning: key {} not in data from {}\".format(key, chosen_event_files[i]))\n", + " continue\n", + " _avg_accs = [y for x, y in data[key]]\n", + " print(\">>> \", chosen_event_files[i])\n", + " print(\">>> max acc: \", max(_avg_accs))\n", + " _label = Path(chosen_event_files[i]).parent.name\n", + " _marker = markers[i % len(markers)]\n", + " # if max(_avg_accs) < 0.95 or _label.find(\"resnet\") != -1:\n", + " # continue \n", + " if _label.find(\"resnet\") == -1:\n", + " _marker = 'x'\n", + " else:\n", + " _marker = 'o'\n", + " if _label.find('combined') == -1:\n", + " _color = 'blue'\n", + " else:\n", + " _color = 'red'\n", + " # _color = 'red'\n", + " # Plot the training data\n", + " \n", + " axs[0].plot(range(1, len(_avg_accs) + 1, STEP), _avg_accs[::STEP], marker=_marker, \n", + " color=_color, \n", + " label=_label)\n", + "\n", + "plt.legend()\n", + "\n", + "# Add legends to the subplots\n", + "for ax in axs:\n", + " ax.legend(loc=\"upper left\", bbox_to_anchor=(1.1,1))\n", + "\n", + "# Set the x-axis and y-axis labels of the subplots\n", + "for ax in axs:\n", + " ax.set_xlabel('Epoch', fontsize=16)\n", + " ax.set_ylabel('Accuracy', fontsize=16)\n", + "\n", + "# Set the y-axis range for all subplots\n", + "# for ax in axs:\n", + "# ax.set_ylim([0.86, 1])\n", + "axs[0].title.set_text('Testing accuracy: ViT')\n", + "# axs[0].title.set_text('Training accuracy: ResNet50')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "livecellx", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/ViT_scripts/scripts/eval.sh b/notebooks/ViT_scripts/scripts/eval.sh new file mode 100644 index 0000000..1c05359 --- /dev/null +++ b/notebooks/ViT_scripts/scripts/eval.sh @@ -0,0 +1,64 @@ +python eval.py\ + --model_dir ./ViT_workdirs/ViT_lightning_logs/4090-frame_1-5-combined-batchsize-32\ + --frame-type combined\ + # --ckpt ./ViT_workdirs/ViT_lightning_logs/frame_1-5-combined/checkpoints/epoch=39-step=60319.ckpt\ + + +python eval.py\ + --model_dir ./ViT_workdirs/ViT_lightning_logs/4090-frame_1-5-combined-batchsize-64\ + --frame-type combined + +python eval.py\ + --model_dir ./ViT_workdirs/ViT_lightning_logs/4090-frame_1-5-combined-batchsize-128\ + --frame-type combined + +python eval.py\ + --model_dir ./ViT_workdirs/ViT_lightning_logs/4090-frame_1-5-combined-batchsize-32\ + --frame-type combined\ + --affine-aug\ + # --ckpt ./ViT_workdirs/ViT_lightning_logs/frame_1-5-combined/checkpoints/epoch=39-step=60319.ckpt\ + + +python eval.py\ + --model_dir ./ViT_workdirs/ViT_lightning_logs/4090-frame_1-5-combined-batchsize-64\ + --frame-type combined\ + --affine-aug\ + +python eval.py\ + --model_dir ./ViT_workdirs/ViT_lightning_logs/4090-frame_1-5-combined-batchsize-128\ + --frame-type combined\ + --affine-aug\ + +python eval.py\ + --model_dir ./ViT_workdirs/ViT_lightning_logs/4090-frame_1-5-combined-batchsize-128\ + --frame-type combined\ + --affine-aug\ + --save_dir_suffix="-batchsize-128"\ + --batch_size=128\ + +python eval.py\ + --model_dir ./ViT_workdirs/ViT_lightning_logs/resnet50-frame_1-5-combined\ + --frame-type combined\ + --batch_size=128\ + --model=resnet50\ + + +python eval.py\ + --model_dir ./ViT_workdirs/ViT_lightning_logs/resnet50-frame_1-5-mask\ + --frame-type mask\ + --batch_size=128\ + --model=resnet50\ + + +python eval.py\ + --model_dir ./ViT_workdirs/ViT_lightning_logs/resnet50-frame_all-combined\ + --frame-type combined\ + --batch_size=128\ + --model=resnet50\ + + +python eval.py\ + --model_dir ./ViT_workdirs/ViT_lightning_logs/resnet50-frame_all-mask\ + --frame-type mask\ + --batch_size=128\ + --model=resnet50\ diff --git a/notebooks/ViT_scripts/scripts/local_gpu/train_combined_range_0-5-batchsize=128.sh b/notebooks/ViT_scripts/scripts/local_gpu/train_combined_range_0-5-batchsize=128.sh new file mode 100644 index 0000000..a6cf3bb --- /dev/null +++ b/notebooks/ViT_scripts/scripts/local_gpu/train_combined_range_0-5-batchsize=128.sh @@ -0,0 +1,51 @@ +#!/bin/bash + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# Slurm Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +# job name +#SBATCH --job-name=train_csn + +#SBATCH --gres=gpu:1 +#SBATCH --exclude=g019,g102,g104,g122,g012,g013,g131,g011 +#SBAATCH --nodelist=g104 +#SBATCH --cpus-per-task=8 + +#SBATCH --mem=40G + +# partition (queue) declaration +#SBATCH --partition=dept_gpu + +# number of requested nodes +#SBATCH --nodes=1 + +# number of tasks +#SBATCH --ntasks=1 + +# standard output & error + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# User Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + + +# node +echo +echo $SLURM_JOB_NODELIST +echo + +# check GPU +nvidia-smi -L +PYTHON=python + +export CUDA_VISIBLE_DEVICES=1 +nohup $PYTHON train_classify_ViT_classifier_v14_lightning.py\ + --batch_size=128\ + --start_frame_idx=0\ + --end_frame_idx=5\ + --frame-type combined\ + --model_version "4090-frame_0-5-combined-batchsize-128"\ + --max-epochs 100\ + 1> outs/4090-frame_0-5-combined-batchsize-128.out 2>&1&\ + \ No newline at end of file diff --git a/notebooks/ViT_scripts/scripts/local_gpu/train_combined_range_1-5-batchsize=128.sh b/notebooks/ViT_scripts/scripts/local_gpu/train_combined_range_1-5-batchsize=128.sh new file mode 100644 index 0000000..e49dbf3 --- /dev/null +++ b/notebooks/ViT_scripts/scripts/local_gpu/train_combined_range_1-5-batchsize=128.sh @@ -0,0 +1,51 @@ +#!/bin/bash + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# Slurm Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +# job name +#SBATCH --job-name=train_csn + +#SBATCH --gres=gpu:1 +#SBATCH --exclude=g019,g102,g104,g122,g012,g013,g131,g011 +#SBAATCH --nodelist=g104 +#SBATCH --cpus-per-task=8 + +#SBATCH --mem=40G + +# partition (queue) declaration +#SBATCH --partition=dept_gpu + +# number of requested nodes +#SBATCH --nodes=1 + +# number of tasks +#SBATCH --ntasks=1 + +# standard output & error + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# User Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + + +# node +echo +echo $SLURM_JOB_NODELIST +echo + +# check GPU +nvidia-smi -L +PYTHON=python + +export CUDA_VISIBLE_DEVICES=1 +nohup $PYTHON train_classify_ViT_classifier_v14_lightning.py\ + --batch_size=128\ + --start_frame_idx=1\ + --end_frame_idx=5\ + --frame-type combined\ + --model_version "4090-frame_1-5-combined-batchsize-128"\ + --max-epochs 100\ + 1> outs/4090-frame_1-5-combined-batchsize-128.out 2>&1&\ + \ No newline at end of file diff --git a/notebooks/ViT_scripts/scripts/local_gpu/train_combined_range_1-5-batchsize=32.sh b/notebooks/ViT_scripts/scripts/local_gpu/train_combined_range_1-5-batchsize=32.sh new file mode 100644 index 0000000..8669e3b --- /dev/null +++ b/notebooks/ViT_scripts/scripts/local_gpu/train_combined_range_1-5-batchsize=32.sh @@ -0,0 +1,50 @@ +#!/bin/bash + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# Slurm Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +# job name +#SBATCH --job-name=train_csn + +#SBATCH --gres=gpu:1 +#SBATCH --exclude=g019,g102,g104,g122,g012,g013,g131,g011 +#SBAATCH --nodelist=g104 +#SBATCH --cpus-per-task=8 + +#SBATCH --mem=40G + +# partition (queue) declaration +#SBATCH --partition=dept_gpu + +# number of requested nodes +#SBATCH --nodes=1 + +# number of tasks +#SBATCH --ntasks=1 + +# standard output & error + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# User Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + + +# node +echo +echo $SLURM_JOB_NODELIST +echo + +# check GPU +nvidia-smi -L +PYTHON=python + +nohup $PYTHON train_classify_ViT_classifier_v14_lightning.py\ + --batch_size=32\ + --start_frame_idx=1\ + --end_frame_idx=5\ + --frame-type combined\ + --model_version "4090-frame_1-5-combined-batchsize-32"\ + --max-epochs 100\ + 1> outs/4090-frame_1-5-combined-batchsize-32.out 2>&1&\ + \ No newline at end of file diff --git a/notebooks/ViT_scripts/scripts/local_gpu/train_combined_range_1-5-batchsize=64.sh b/notebooks/ViT_scripts/scripts/local_gpu/train_combined_range_1-5-batchsize=64.sh new file mode 100644 index 0000000..b2dae34 --- /dev/null +++ b/notebooks/ViT_scripts/scripts/local_gpu/train_combined_range_1-5-batchsize=64.sh @@ -0,0 +1,51 @@ +#!/bin/bash + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# Slurm Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +# job name +#SBATCH --job-name=train_csn + +#SBATCH --gres=gpu:1 +#SBATCH --exclude=g019,g102,g104,g122,g012,g013,g131,g011 +#SBAATCH --nodelist=g104 +#SBATCH --cpus-per-task=8 + +#SBATCH --mem=40G + +# partition (queue) declaration +#SBATCH --partition=dept_gpu + +# number of requested nodes +#SBATCH --nodes=1 + +# number of tasks +#SBATCH --ntasks=1 + +# standard output & error + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# User Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + + +# node +echo +echo $SLURM_JOB_NODELIST +echo + +# check GPU +nvidia-smi -L +PYTHON=python + +CUDA_VISIBLE_DEVICES=1 +nohup $PYTHON train_classify_ViT_classifier_v14_lightning.py\ + --batch_size=64\ + --start_frame_idx=1\ + --end_frame_idx=5\ + --frame-type combined\ + --model_version "4090-frame_1-5-combined-batchsize-64"\ + --max-epochs 100\ + 1> outs/4090-frame_1-5-combined-batchsize-64.out 2>&1&\ + \ No newline at end of file diff --git a/notebooks/ViT_scripts/scripts/train.sh b/notebooks/ViT_scripts/scripts/train.sh index e9a20bd..b7c8027 100644 --- a/notebooks/ViT_scripts/scripts/train.sh +++ b/notebooks/ViT_scripts/scripts/train.sh @@ -11,4 +11,11 @@ python train_classify_ViT_classifier_v14_lightning.py\ --start_frame_idx=1 --end_frame_idx=5\ --frame-type mask\ --model_version "frame_1-5-mask"\ - \ No newline at end of file + + +export CUDA_VISIBLE_DEVICES=1 +python train_classify_ViT_classifier_v14_lightning.py\ + --batch_size=128\ + --start_frame_idx=0 --end_frame_idx=5\ + --frame-type mask\ + --model_version "frame_0-5-mask"\ \ No newline at end of file diff --git a/notebooks/classify_mitosis_data_prep-v15-inclusive-CMU.ipynb b/notebooks/classify_mitosis_data_prep-v15-inclusive-CMU.ipynb new file mode 100644 index 0000000..5a6576f --- /dev/null +++ b/notebooks/classify_mitosis_data_prep-v15-inclusive-CMU.ipynb @@ -0,0 +1,1020 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Prepare mitosis time series data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from cellpose import models\n", + "from cellpose.io import imread\n", + "import glob\n", + "from pathlib import Path\n", + "from PIL import Image, ImageSequence\n", + "from tqdm import tqdm\n", + "import os\n", + "import os.path\n", + "# from livecellx import segment\n", + "from livecellx import core\n", + "from livecellx.core import datasets\n", + "from livecellx.core.datasets import LiveCellImageDataset, SingleImageDataset\n", + "from skimage import measure\n", + "from livecellx.core import SingleCellTrajectory, SingleCellStatic" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from livecellx.track.classify_utils import load_class2samples_from_json_dir, load_all_json_dirs\n", + "# sample_json_dir = Path(\"./EBSS_starvation_24h_xy16_annotation\")\n", + "\n", + "sample_json_dirs_v0 = [Path(r\"./datasets/test_scs_EBSS_starvation/XY1/annotations\"), Path(r\"./datasets/test_scs_EBSS_starvation/XY16/annotations\")]\n", + "\n", + "round1_json_dirs = sample_json_dirs_v0 + [\n", + " Path(r\"../datasets/mitosis-annotations-2023/shiman_XY01/XY01\"),\n", + "Path(r\"../datasets/mitosis-annotations-2023/shiman_XY09/XY09\"),\n", + "Path(r\"../datasets/mitosis-annotations-2023/shiman_XY10/XY10\"),\n", + "Path(r\"../datasets/mitosis-annotations-2023/Yajushi/tifs_CFP_A549-VIM_lessThan24hr_NoTreat_NA_YL_Ti2e_2022-10-19/XY1/annotations\"),\n", + "]\n", + "\n", + "round2_json_dirs = [\n", + "Path(r\"../datasets/mitosis-annotations-2023/shiman_CXA_high_density/C0.5^4/\"),\n", + "Path(r\"../datasets/mitosis-annotations-2023/shiman_CXA_high_density/C0.75^4/\"),\n", + "Path(r\"../datasets/mitosis-annotations-2023/shiman_CXA_high_density/C10^3/\"),\n", + "Path(r\"../datasets/mitosis-annotations-2023/shiman_CXA_high_density/C10^4/\"),\n", + "\n", + "] + [\n", + " Path(f\"../datasets/mitosis-annotations-2023/Gaohan_tifs_CFP_A549-VIM_lessThan24hr_NoTreat_NA_YL_Ti2e_2022-10-19/XY{pos}/annotations\") for pos in range(4, 14)\n", + "]\n", + "\n", + "round3_json_dirs = [\n", + " Path(r\"../datasets/mitosis-annotations-2023/shiman_CXA_normal/0.25^4/\"),\n", + " Path(r\"../datasets/mitosis-annotations-2023/shiman_CXA_normal/C0.5^4/\"),\n", + " Path(r\"../datasets/mitosis-annotations-2023/shiman_CXA_normal/C10^3/\")\n", + "]\n", + "\n", + "CMU_C2C12 = glob.glob(\"/home/ken67/livecellx/notebooks/scripts/mmdetection_classify/tmp/CMU_C2C12/090303-C2C12P15-FGF2/Human exp1*\")\n", + "CMU_C2C12 = [Path(p) for p in CMU_C2C12]\n", + "sample_json_dirs = sample_json_dirs_v0 + round1_json_dirs + round2_json_dirs + round3_json_dirs # + CMU_C2C12\n", + "all_class2samples, all_class2sample_extra_info = load_all_json_dirs(sample_json_dirs)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "len(all_class2samples[\"mitosis\"]), len(all_class2samples[\"apoptosis\"]), len(all_class2samples[\"normal\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "num_zero_len_samples = 0\n", + "for key in all_class2samples.keys():\n", + " for sample in all_class2samples[key]:\n", + " if len(sample) == 0:\n", + " num_zero_len_samples += 1\n", + "print(\"num_zero_len_samples: \", num_zero_len_samples)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Automatically prepare normal samples from segmented normal cells\n", + "WEe asd \n", + "Note: require tracking done" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Exclude other classes" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# get all scs from class_samples not in normal class\n", + "exclude_scs = []\n", + "total_non_normal_samples = 0\n", + "for class_name, samples in all_class2samples.items():\n", + " if class_name != \"normal\":\n", + " for sample in samples:\n", + " exclude_scs.extend(sample)\n", + " total_non_normal_samples += 1\n", + "\n", + "exclude_scs = set(exclude_scs)\n", + "exclude_scs_ids = {str(sc.id) for sc in exclude_scs}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# from livecellx.core.sct_operator import create_scs_edit_viewer\n", + "# sct_operator = create_scs_edit_viewer(exclude_scs, img_dataset = list(exclude_scs)[0].img_dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "load all single cells, including mitosis and normal ones, for further generating normal samples automatically" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "from livecellx.core.single_cell import SingleCellTrajectoryCollection\n", + "from livecellx.track.sort_tracker_utils import (\n", + " track_SORT_bbox_from_scs\n", + ")\n", + "\n", + "all_scs_json_path = [\"./datasets/test_scs_EBSS_starvation/XY1/single_cells.json\", \"./datasets/test_scs_EBSS_starvation/XY16/single_cells.json\"]\n", + "# all_scs_json_path = \"./datasets/test_scs_EBSS_starvation/XY16/tmp_corrected_scs.json\"\n", + "sctc = SingleCellTrajectoryCollection()\n", + "for json_path in all_scs_json_path:\n", + " print(\"json path:\", json_path)\n", + " _scs = SingleCellStatic.load_single_cells_json(json_path)\n", + " tmp_sctc = track_SORT_bbox_from_scs(_scs, raw_imgs=_scs[0].img_dataset, min_hits=3, max_age=3)\n", + " tids = set(sctc.get_all_tids())\n", + " if len(tids) != 0:\n", + " max_tid = max(tids)\n", + " else:\n", + " max_tid = 0\n", + " for tid, traj in tmp_sctc:\n", + " traj.meta[\"src_dir\"] = json_path\n", + " traj.track_id = tid + max_tid + 1\n", + " sctc.add_trajectory(traj)\n", + " traj_scs = traj.get_all_scs()\n", + " for sc in traj_scs:\n", + " sc.meta[\"src_dir\"] = json_path\n", + " del tmp_sctc\n", + "\n", + "all_scs = SingleCellStatic.load_single_cells_jsons(all_scs_json_path)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# with open(\"./EBSS_starvation_24h_xy16_annotation/single_cell_trajectory_collection.json\", \"r\") as file:\n", + "# json_dict = json.load(file)\n", + "# sctc = SingleCellTrajectoryCollection().load_from_json_dict(json_dict)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# set numpy seed\n", + "seed = 0\n", + "np.random.seed(seed)\n", + "\n", + "objective_sample_num = total_non_normal_samples * 10\n", + "\n", + "normal_frame_len_range = (3, 10)\n", + "counter = 0\n", + "normal_samples = []\n", + "normal_samples_extra_info = []\n", + "max_trial_counter = 100000\n", + "while counter < objective_sample_num and max_trial_counter > 0:\n", + " # randomly select a sct from sctc\n", + " # generate a list of scs\n", + " track_id = np.random.choice(list(sctc.track_id_to_trajectory.keys())) \n", + " sct = sctc.get_trajectory(track_id)\n", + " # randomly select a length\n", + " frame_len = np.random.randint(*normal_frame_len_range)\n", + " # generate a sample\n", + " times = list(sct.timeframe_to_single_cell.keys())\n", + " times = sorted(times)\n", + " if len(times) <= frame_len:\n", + " continue\n", + " start_idx = np.random.randint(0, len(times) - frame_len)\n", + " start_time = times[start_idx]\n", + " end_time = times[start_idx + frame_len - 1]\n", + "\n", + " sub_sct = sct.subsct(start_time, end_time)\n", + "\n", + " is_some_sc_in_exclude_scs = False\n", + " for time, sc in sub_sct.timeframe_to_single_cell.items():\n", + " # print(\"sc.id:\", sc.id, type(sc.id))\n", + " if str(sc.id) in exclude_scs_ids:\n", + " is_some_sc_in_exclude_scs = True\n", + " break\n", + " if is_some_sc_in_exclude_scs:\n", + " print(\"some sc in the exclude scs list\")\n", + " continue\n", + " \n", + " new_sample = []\n", + " for time, sc in sub_sct.timeframe_to_single_cell.items():\n", + " new_sample.append(sc)\n", + " normal_samples.append(new_sample)\n", + " normal_samples_extra_info.append({\"src_dir\": sub_sct.get_all_scs()[0].meta[\"src_dir\"]})\n", + " counter += 1\n", + " max_trial_counter -= 1\n", + "\n", + "print(\"# of normal samples:\", len(normal_samples))\n", + "print(\"# of normal samples extra info:\", len(normal_samples_extra_info))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_class2samples[\"normal\"].extend(normal_samples)\n", + "all_class2sample_extra_info[\"normal\"].extend(normal_samples_extra_info)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "len(all_class2samples[\"normal\"]), len(all_class2sample_extra_info[\"normal\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Add start and end time to all_class2sample_extra_info" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for class_name, samples in all_class2samples.items():\n", + " print(class_name, len(samples))\n", + " class_extra_infos = all_class2sample_extra_info[class_name]\n", + " for sample_idx, sample in enumerate(samples):\n", + " if len(sample) == 0:\n", + " continue\n", + " sample_extra_info = class_extra_infos[sample_idx]\n", + " min_time = None\n", + " max_time = None\n", + " for sc in sample:\n", + " if min_time is None or sc.timeframe < min_time:\n", + " min_time = sc.timeframe\n", + " if max_time is None or sc.timeframe > max_time:\n", + " max_time = sc.timeframe\n", + " sample_extra_info[\"start_time\"] = min_time\n", + " sample_extra_info[\"end_time\"] = max_time\n", + " sample_extra_info[\"first_sc_id\"] = sample[0].id\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "[len(all_class2sample_extra_info[cls]) for cls in all_class2sample_extra_info.keys()]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Prepare videos and annotations for MMDetection" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "classes = all_class2samples.keys()\n", + "classes" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from livecellx.core.utils import gray_img_to_rgb, rgb_img_to_gray\n", + "from livecellx.preprocess.utils import normalize_img_to_uint8" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from livecellx.track.classify_utils import video_frames_and_masks_from_sample, combine_video_frames_and_masks" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import List\n", + "import cv2\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "from livecellx.core.sc_video_utils import gen_mp4_from_frames, gen_class2sample_samples, gen_samples_mp4s\n", + "\n", + "# ver = \"10-st\" # single trajectory ver\n", + "# ver = \"test\" # single trajectory ver\n", + "# ver = \"11-st-run0\"\n", + "# MAKE_SINGLE_CELL_TRAJ_SAMPLES = True\n", + "# DROP_MITOSIS_DIV = False\n", + "\n", + "# ver = \"10-drop-div\"\n", + "# DROP_MITOSIS_DIV = True\n", + "# ver = \"-test\"\n", + "\n", + "# ver = \"11-drop-div\"\n", + "# MAKE_SINGLE_CELL_TRAJ_SAMPLES = False\n", + "# DROP_MITOSIS_DIV = True\n", + "\n", + "# ver = \"12-st\"\n", + "# MAKE_SINGLE_CELL_TRAJ_SAMPLES = True\n", + "# DROP_MITOSIS_DIV = False\n", + "\n", + "# ver = \"12-drop-div\"\n", + "# MAKE_SINGLE_CELL_TRAJ_SAMPLES = False\n", + "# DROP_MITOSIS_DIV = True\n", + "\n", + "# ver = \"12-all\"\n", + "# MAKE_SINGLE_CELL_TRAJ_SAMPLES = False\n", + "# DROP_MITOSIS_DIV = False\n", + "\n", + "# ver = \"test-all\"\n", + "\n", + "# ver = \"13-inclusive-with-mitosis-type\"\n", + "ver = \"15-inclusive\"\n", + "MAKE_SINGLE_CELL_TRAJ_SAMPLES = False\n", + "DROP_MITOSIS_DIV = False\n", + "INCLUDE_ALL = True\n", + "\n", + "DEBUG = False" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data_dir = Path(f'notebook_results/mmaction_train_data_v{ver}')\n", + "class_labels = ['mitosis', 'apoptosis', 'normal']\n", + "class_label = \"mitosis\"\n", + "frame_types = [\"video\", \"mask\", \"combined\"]\n", + "fps = 3\n", + "\n", + "# 1 instead of 0 to prevent the decord (used by mmdetection) python package error\n", + "padding_pixels = [1, 20, 40, 50, 100, 200, 400]\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "\n", + "# split train and test data\n", + "\n", + "# get #samples from all_class2samples\n", + "_split = 0.8\n", + "\n", + "train_class2samples = {}\n", + "test_class2samples = {}\n", + "train_class2sample_extra_info = {}\n", + "test_class2sample_extra_info = {}\n", + "\n", + "# randomize train and test data\n", + "for key in all_class2samples.keys():\n", + " randomized_indices = np.random.permutation(len(all_class2samples[key])).astype(int)\n", + " split_idx = int(len(all_class2samples[key]) * _split)\n", + " _train_indices = randomized_indices[:split_idx]\n", + " _test_indices = randomized_indices[split_idx:]\n", + " train_class2samples[key] = np.array(all_class2samples[key], dtype=object)[_train_indices]\n", + " test_class2samples[key] = np.array(all_class2samples[key], dtype=object)[_test_indices]\n", + "\n", + " train_class2samples[key] = list(train_class2samples[key])\n", + " test_class2samples[key] = list(test_class2samples[key])\n", + "\n", + " train_class2sample_extra_info[key] = np.array(all_class2sample_extra_info[key], dtype=object)[_train_indices]\n", + " test_class2sample_extra_info[key] = np.array(all_class2sample_extra_info[key], dtype=object)[_test_indices]\n", + " train_class2sample_extra_info[key] = list(train_class2sample_extra_info[key])\n", + " test_class2sample_extra_info[key] = list(test_class2sample_extra_info[key])\n", + "\n", + "\n", + "# # for debug\n", + "if DEBUG:\n", + " test_sample_num = 3\n", + " padding_pixels = [1, 20]\n", + " train_class2samples = {key: value[:test_sample_num] for key, value in all_class2samples.items()}\n", + " test_class2samples = {key: value[:test_sample_num] for key, value in all_class2samples.items()}\n", + " train_class2sample_extra_info = {key: value[:test_sample_num] for key, value in all_class2sample_extra_info.items()}\n", + " test_class2sample_extra_info = {key: value[:test_sample_num] for key, value in all_class2sample_extra_info.items()}\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "len(train_class2samples[\"normal\"]), len(test_class2samples[\"normal\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "len(train_class2samples[\"mitosis\"]), len(test_class2samples[\"mitosis\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "video_frames_and_masks_from_sample(train_class2samples[\"normal\"][0])[0][0].shape\n", + "# train_class2samples[\"normal\"][6][1].show_panel()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import importlib\n", + "import livecellx\n", + "importlib.reload(livecellx.track.classify_utils)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check some sample generation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "idx_to_check = 0\n", + "video_frames, video_frame_masks = video_frames_and_masks_from_sample(train_class2samples[\"normal\"][idx_to_check], padding_pixels=0)\n", + "print(\"video frames dtype:\", video_frames[0].dtype)\n", + "print(\"video frames shape:\", video_frames[0].shape)\n", + "print(\"video frame masks dtype:\", video_frame_masks[0].dtype)\n", + "print(\"video frame masks shape:\", video_frame_masks[0].shape)\n", + "combined_frames = livecellx.track.classify_utils.combine_video_frames_and_masks(video_frames, video_frame_masks, edt_transform=True)\n", + "combined_frames = np.array(combined_frames).astype(np.uint8)\n", + "# combined_frames = np.maximum(combined_frames - 1, 0).astype(np.uint8)\n", + "print(\"combined_frames shape: \", combined_frames[0].shape)\n", + "gen_mp4_from_frames(combined_frames, \"./test_video_output.mp4\", fps=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visually check the generated frames' values" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# channel = 2\n", + "# plt.imshow(combined_frames[0][..., channel])\n", + "# combined_frames[1][..., channel].max(), combined_frames[1][..., 0].shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "np.array(combined_frames).flatten().min()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Make single cell trajectories only (ONE cell per time frame)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Dict\n", + "from livecellx.track.data_prep_utils import is_one_sc_each_time\n", + "from livecellx.track.data_prep_utils import make_one_cell_per_timeframe_for_class2samples, make_one_cell_per_timeframe_helper, make_one_cell_per_timeframe_samples\n", + "\n", + "\n", + "\n", + "sample = train_class2samples[\"mitosis\"][0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "[sc.timeframe for sc in sample]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "len(make_one_cell_per_timeframe_samples(sample))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "if MAKE_SINGLE_CELL_TRAJ_SAMPLES:\n", + " train_class2samples, train_class2sample_extra_info = make_one_cell_per_timeframe_for_class2samples(train_class2samples, train_class2sample_extra_info)\n", + " test_class2samples, test_class2sample_extra_info = make_one_cell_per_timeframe_for_class2samples(test_class2samples, test_class2sample_extra_info)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Drop the cell divison part for easier inference durign testing" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from livecellx.track.data_prep_utils import drop_multiple_cell_frames_in_samples\n", + "\n", + "if DROP_MITOSIS_DIV:\n", + " train_class2samples = drop_multiple_cell_frames_in_samples(train_class2samples)\n", + " test_class2samples = drop_multiple_cell_frames_in_samples(test_class2samples)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Include original, drop-div and st" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "train_class2sample_extra_info" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import copy\n", + "from copy import deepcopy\n", + "\n", + "def modify_class2sample_extra_info(class2sample_extra_info: Dict[str, List[Dict]], mitosis_traj_type, copy=True):\n", + " for cls in class2sample_extra_info:\n", + " for i, _info in enumerate(class2sample_extra_info[cls]):\n", + " if copy:\n", + " _info = dict(_info)\n", + " _info[\"mitosis_traj_type\"] = mitosis_traj_type\n", + " class2sample_extra_info[cls][i] = _info\n", + " \n", + "\n", + "modify_class2sample_extra_info(train_class2sample_extra_info, \"full\")\n", + "modify_class2sample_extra_info(test_class2sample_extra_info, \"full\")\n", + "\n", + "if INCLUDE_ALL:\n", + " # Extra caution: be careful drop_div related copy by refernce syntax stuff...\n", + " train_drop_div_class2samples = drop_multiple_cell_frames_in_samples(train_class2samples)\n", + " train_drop_div_class2extra_info = {cls: list(train_class2sample_extra_info[cls]) for cls in train_class2sample_extra_info.keys()}\n", + " modify_class2sample_extra_info(train_drop_div_class2extra_info, \"drop_div\")\n", + "\n", + " test_drop_div_class2samples = drop_multiple_cell_frames_in_samples(test_class2samples)\n", + " test_drop_div_class2extra_info = {cls: list(test_class2sample_extra_info[cls]) for cls in test_class2sample_extra_info.keys()}\n", + " modify_class2sample_extra_info(test_drop_div_class2extra_info, \"drop_div\")\n", + "\n", + " train_st_class2samples, train_st_class2sample_extra_info = make_one_cell_per_timeframe_for_class2samples(train_class2samples, train_class2sample_extra_info)\n", + " test_st_class2samples, test_st_class2sample_extra_info = make_one_cell_per_timeframe_for_class2samples(test_class2samples, test_class2sample_extra_info)\n", + " modify_class2sample_extra_info(train_st_class2sample_extra_info, \"st\")\n", + " modify_class2sample_extra_info(test_st_class2sample_extra_info, \"st\")\n", + "\n", + " # check st info and sample length are the same\n", + " assert len(train_st_class2samples[\"mitosis\"]) == len(train_st_class2sample_extra_info[\"mitosis\"])\n", + " assert len(train_st_class2samples[\"normal\"]) == len(train_st_class2sample_extra_info[\"normal\"])\n", + "\n", + " # check drop-div info and sample length are the same\n", + " assert len(train_drop_div_class2samples[\"mitosis\"]) == len(train_drop_div_class2extra_info[\"mitosis\"])\n", + " assert len(train_drop_div_class2samples[\"normal\"]) == len(train_drop_div_class2extra_info[\"normal\"])\n", + "\n", + " for cls in train_drop_div_class2samples:\n", + " assert len(train_drop_div_class2extra_info[cls]) == len(train_drop_div_class2samples[cls])\n", + " \n", + " for cls in train_class2samples:\n", + " print(\"cls:\", cls, \"len(train_class2samples[cls]):\", len(train_class2samples[cls]), \"len(train_class2sample_extra_info[cls]):\", len(train_class2sample_extra_info[cls]))\n", + " assert len(train_class2samples[cls]) == len(train_class2sample_extra_info[cls]), \\\n", + " f\"length of train_class2samples[{cls}] != length of train_class2sample_extra_info[{cls}], {len(train_class2samples[cls])} != {len(train_class2sample_extra_info[cls])}\"\n", + " \n", + " assert len(train_st_class2sample_extra_info[cls]) == len(train_st_class2samples[cls]), f\"flag1: {cls}\"\n", + " train_class2samples[cls].extend(train_st_class2samples[cls])\n", + " train_class2sample_extra_info[cls].extend(train_st_class2sample_extra_info[cls])\n", + " assert len(train_class2samples[cls]) == len(train_class2sample_extra_info[cls]), \\\n", + " f\"length of train_class2samples[{cls}] != length of train_class2sample_extra_info[{cls}], {len(train_class2samples[cls])} != {len(train_class2sample_extra_info[cls])}\"\n", + " \n", + " assert len(train_drop_div_class2extra_info[cls]) == len(train_drop_div_class2samples[cls]), f\"flag2: {cls}, {len(train_drop_div_class2extra_info[cls])} != {len(train_drop_div_class2samples[cls])}\"\n", + " train_class2samples[cls].extend(train_drop_div_class2samples[cls])\n", + " train_class2sample_extra_info[cls].extend(train_drop_div_class2extra_info[cls])\n", + " # print(\"cls:\", cls, \"len(train_class2samples[cls]):\", len(train_class2samples[cls]), \"len(train_class2sample_extra_info[cls]):\", len(train_class2sample_extra_info[cls]))\n", + "\n", + " test_class2samples[cls].extend(test_st_class2samples[cls])\n", + " test_class2sample_extra_info[cls].extend(test_st_class2sample_extra_info[cls])\n", + "\n", + " test_class2samples[cls].extend(test_drop_div_class2samples[cls])\n", + " test_class2sample_extra_info[cls].extend(test_drop_div_class2extra_info[cls])\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for key, val in train_class2samples.items():\n", + " assert len(train_class2samples[key]) == len(train_class2sample_extra_info[key]), f\"key: {key}, len(val): {len(val)}, len(train_class2sample_extra_info[key]): {len(train_class2sample_extra_info[key])}\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "train_class2sample_extra_info[\"mitosis\"]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import importlib\n", + "import livecellx\n", + "import livecellx.core.sc_video_utils\n", + "importlib.reload(livecellx.core.sc_video_utils)\n", + "\n", + "# padding_pixels = [20]\n", + "\n", + "train_sample_info_df = livecellx.core.sc_video_utils.gen_class2sample_samples(\n", + " train_class2samples,\n", + " train_class2sample_extra_info,\n", + " data_dir,\n", + " class_labels,\n", + " padding_pixels=padding_pixels,\n", + " frame_types=frame_types,\n", + " fps=fps,\n", + " prefix=\"train\",\n", + ")\n", + "test_sample_info_df = livecellx.core.sc_video_utils.gen_class2sample_samples(\n", + " test_class2samples,\n", + " test_class2sample_extra_info,\n", + " data_dir,\n", + " class_labels,\n", + " padding_pixels=padding_pixels,\n", + " frame_types=frame_types,\n", + " fps=fps,\n", + " prefix=\"test\",\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "train_sample_info_df[:2]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "train_sample_info_df.to_csv(\n", + " data_dir / f\"train_data.txt\",\n", + " index=False,\n", + " header=True,\n", + " sep=\" \",\n", + ")\n", + "test_sample_info_df.to_csv(\n", + " data_dir / f\"test_data.txt\",\n", + " index=False,\n", + " header=True,\n", + " sep=\" \",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "train_sample_info_df = pd.read_csv(data_dir / f\"train_data.txt\", sep=\" \")\n", + "test_sample_info_df = pd.read_csv(data_dir / f\"test_data.txt\", sep=\" \")\n", + "\n", + "mmaction_df_paths = []\n", + "for selected_frame_type in frame_types + [\"all\"]:\n", + " train_df_path = data_dir / f\"mmaction_train_data_{selected_frame_type}.txt\"\n", + " if selected_frame_type == \"all\":\n", + " train_selected_frame_type_df = train_sample_info_df\n", + " else:\n", + " train_selected_frame_type_df = train_sample_info_df[train_sample_info_df[\"frame_type\"] == selected_frame_type]\n", + " train_selected_frame_type_df = train_selected_frame_type_df.reset_index(drop=True)\n", + " train_selected_frame_type_df = train_selected_frame_type_df[[\"path\", \"label_index\"]]\n", + " train_selected_frame_type_df.to_csv(train_df_path, index=False, header=False, sep=\" \")\n", + "\n", + " test_df_path = data_dir / f\"mmaction_test_data_{selected_frame_type}.txt\"\n", + "\n", + " if selected_frame_type == \"all\":\n", + " test_selected_frame_type_df = test_sample_info_df\n", + " else:\n", + " test_selected_frame_type_df = test_sample_info_df[test_sample_info_df[\"frame_type\"] == selected_frame_type]\n", + " test_selected_frame_type_df = test_selected_frame_type_df[[\"path\", \"label_index\"]]\n", + " test_selected_frame_type_df = test_selected_frame_type_df.reset_index(drop=True)\n", + " test_selected_frame_type_df.to_csv(test_df_path, index=False, header=False, sep=\" \")\n", + "\n", + " mmaction_df_paths.append(train_df_path)\n", + " mmaction_df_paths.append(test_df_path)\n", + "\n", + "mmaction_df_paths\n", + "# # The follwing code generates v1-v7 test data. The issue is that some of test data shows up in train data, through different padding values.\n", + "# data_df_path = data_dir/'all_data.txt'\n", + "# sample_df = gen_samples_df(data_dir, class_labels, padding_pixels, frame_types, fps)\n", + "# sample_df.to_csv(data_df_path, index=False, header=False, sep=' ')\n", + "# for selected_frame_type in frame_types:\n", + "# selected_frame_type_df = sample_df[sample_df[\"frame_type\"] == selected_frame_type]\n", + "# selected_frame_type_df = selected_frame_type_df.reset_index(drop=True)\n", + "# train_df_path = data_dir/f'train_data_{selected_frame_type}.txt'\n", + "# test_df_path = data_dir/f'test_data_{selected_frame_type}.txt'\n", + "# train_df = selected_frame_type_df.sample(frac=0.8, random_state=0, replace=False)\n", + "# test_df = selected_frame_type_df.drop(train_df.index, inplace=False)\n", + "\n", + "# # only keep the path and label_index columns\n", + "# train_df = train_df[[\"path\", \"label_index\"]]\n", + "# test_df = test_df[[\"path\", \"label_index\"]]\n", + "\n", + "# train_df.to_csv(train_df_path, index=False, header=False, sep=' ')\n", + "# test_df.to_csv(test_df_path, index=False, header=False, sep=' ')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check the videos" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "video_paths = list(Path(data_dir/'videos').glob('*.mp4'))\n", + "print(\"len(video_paths):\", len(video_paths))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Due to a `decord` package [issue](https://github.com/dmlc/decord/issues/150), to use mmaction2 we must check if the videos can be loaded by `decord` correctly." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import decord\n", + "decord.__version__" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import decord\n", + "invalid_decord_paths = []\n", + "for path in tqdm(video_paths):\n", + "# for path in [\"./notebook_results/train_normal_6_raw_padding-0.mp4\"]:\n", + "# for path in [\"./test_video_output.mp4\"]:\n", + " reader = decord.VideoReader(str(path))\n", + " reader.seek(0)\n", + " imgs = list()\n", + " frame_inds = range(0, len(reader))\n", + " for idx in frame_inds:\n", + " reader.seek(idx)\n", + " frame = reader.next()\n", + " imgs.append(frame.asnumpy())\n", + " frame = frame.asnumpy()\n", + "\n", + " num_channels = frame.shape[-1]\n", + " if num_channels != 3:\n", + " print(\"invalid video for decord (https://github.com/dmlc/decord/issues/150): \", path)\n", + " invalid_decord_paths.append(path)\n", + " break\n", + " # fig, axes = plt.subplots(1, num_channels, figsize=(20, 10))\n", + " # for i in range(num_channels):\n", + " # axes[i].imshow(frame[:, :, i])\n", + " # plt.show()\n", + " del reader" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Remove \"invalid\" videos (cannot be read by decord) from mmdetection " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# extract file names from invalid decord paths\n", + "invalid_decord_filenames = set([os.path.basename(path) for path in invalid_decord_paths])\n", + "\n", + "for df_path in mmaction_df_paths:\n", + " _df = pd.read_csv(df_path, sep=\" \", header=None)\n", + " # remove all the rows with column \"path\" in invalid_decord_filenames\n", + " filtered_df = _df[~_df[0].isin(invalid_decord_filenames)]\n", + "\n", + " df_filename = os.path.basename(df_path)\n", + " # summarize the number of samples for the file\n", + " print(f\"df_path: {df_filename}, #filtered: {_df.shape[0] - filtered_df.shape[0]}, original df shape: {_df.shape}, filtered df shape: {filtered_df.shape}\")\n", + "\n", + " # save to the disk\n", + " filtered_df.to_csv(df_path, index=False, header=False, sep=\" \")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "check if videos can be loaded by cv2 correctly" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import cv2\n", + "\n", + "cap = cv2.VideoCapture(\"./test_video_output.mp4\")\n", + "\n", + "while True:\n", + " ret, frame = cap.read()\n", + " if not ret:\n", + " break\n", + " assert frame.shape[-1] == 3, \"frame should be in RGB format\"\n", + "\n", + "cap.release()\n", + "cv2.destroyAllWindows()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# from sklearn.model_selection import train_test_split\n", + "\n", + "# train_df_path = data_dir/'train_data.csv'\n", + "# test_df_path = data_dir/'test_data.csv'\n", + "\n", + "# # split train and test from df\n", + "# train_df, test_df = train_test_split(df, test_size=0.2, random_state=42)\n", + "# train_df.to_csv(train_df_path, index=False, header=False, sep=' ')\n", + "# test_df.to_csv(test_df_path, index=False, header=False, sep=' ')\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "livecell", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.18" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/scripts/csn_scripts/train_data_real_v11_01_aux.sh b/notebooks/scripts/csn_scripts/train_data_real_v11_01_aux.sh index d0f86ef..98d3313 100644 --- a/notebooks/scripts/csn_scripts/train_data_real_v11_01_aux.sh +++ b/notebooks/scripts/csn_scripts/train_data_real_v11_01_aux.sh @@ -5,5 +5,5 @@ # model 901 # model 88 resume # model 75 aug -model=v11_01_aux +model=v11_01_aux-test nohup python ../livecellx/model_zoo/segmentation/train_csn.py --train_dir="./notebook_results/a549_ccp_vim/train_data_v11" --test_dir="./notebook_results/a549_ccp_vim/test_data_v11" --source=all --model_version=version_$model --epochs=5000 --kernel_size=1 --batch_size=2 --batch_size=2 --degrees=30 --translation=0.3 --aug_scale="0.5,2" --input_type=raw_aug_duplicate --loss=BCE --ou_aux> train_out_model"$model"_resume.out 2>&1 & \ No newline at end of file diff --git a/notebooks/scripts/csn_scripts/train_data_real_v12_01_aux.sh b/notebooks/scripts/csn_scripts/train_data_real_v12_01_aux.sh new file mode 100644 index 0000000..926eb52 --- /dev/null +++ b/notebooks/scripts/csn_scripts/train_data_real_v12_01_aux.sh @@ -0,0 +1,9 @@ +############################################################################################################ +# syn underseg training 5300 series) with mild augmentation +############################################################################################################ + +# model 901 +# model 88 resume +# model 75 aug +model=v12_01_aux +nohup python ../livecellx/model_zoo/segmentation/train_csn.py --train_dir="./notebook_results/a549_ccp_vim/train_data_v12" --test_dir="./notebook_results/a549_ccp_vim/test_data_v12" --source=all --model_version=version_$model --epochs=5000 --kernel_size=1 --batch_size=2 --batch_size=6 --degrees=30 --translation=0.3 --aug_scale="0.5,2" --input_type=raw_aug_duplicate --loss=BCE --ou_aux> train_out_model"$model"_resume.out 2>&1 & \ No newline at end of file diff --git a/notebooks/scripts/mmdetection_classify/centroid_aug.py b/notebooks/scripts/mmdetection_classify/centroid_aug.py new file mode 100644 index 0000000..a129e7a --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/centroid_aug.py @@ -0,0 +1,95 @@ +import random +from matplotlib import pyplot as plt +from mmcv.transforms import BaseTransform + +# from mmdet.registry import TRANSFORMS +# from mmaction.datasets.builder import TRANSFORMS +from mmaction.registry import TRANSFORMS +import numpy as np +from skimage.measure import regionprops + +from livecellx.preprocess.utils import dilate_or_erode_mask + + +@TRANSFORMS.register_module() +class RandomMaskCentroid: + """LivecellAction customized augmentation + For channel blue and green in a video, randomly mask out all values by thesholds lb and ub. + Purpose: we would like to control the amount of prior segmentation information fed to the models. + """ + + def __init__(self, lb=2, ub=50, fix_centroid_size=None): + self.lb = lb + self.ub = ub + self.fix_centroid_size = fix_centroid_size + + def check_channels(self, img): + """blue and green channel should have the same values""" + print("sum of red channel: ", img[:, :, 0].sum(), "nonzero: ", (img[:, :, 0] != 0).sum()) + print("sum of green channel: ", img[:, :, 1].sum(), "nonzero: ", (img[:, :, 1] != 0).sum()) + print("sum of blue channel: ", img[:, :, 2].sum(), "nonzero: ", (img[:, :, 2] != 0).sum()) + # plt.imshow(img[:,:,0]) + # plt.savefig("tmp/debug_red.png") + # plt.imshow(img[:,:,1]) + # plt.savefig("tmp/debug_green.png") + # plt.imshow(img[:,:,2]) + # plt.savefig("tmp/debug_blue.png") + assert (img[:, :, 0] == img[:, :, 1]).all(), "blue and green channel should have the same values" + + def __call__(self, results, exact_match_rg_channel=False): + imgs = results["imgs"] + img_h, img_w = imgs[0].shape[:2] + + # Because of lossy compression, some masks can have random dots... + scale_factor = -0.01 + + # Randomly [self.lb, self.ub) mask out the blue and green channels] + lb = max(1, self.lb) + if self.ub is None: + ub = img_w + else: + ub = min(img_w, self.ub) + + centroid_box_width = np.random.randint(lb, ub) + if self.fix_centroid_size is not None: + centroid_box_width = self.fix_centroid_size + + for i, img in enumerate(imgs): + new_img = img.copy() + corrected_mask = dilate_or_erode_mask(img[:, :, 0], scale_factor=scale_factor) + properties = regionprops(corrected_mask.astype(int)) + # Sort by area + properties.sort(key=lambda x: x.area, reverse=True) + props = properties[0] + centroid = props.centroid + centroid_box = np.array( + [ + centroid[0] - centroid_box_width / 2, + centroid[1] - centroid_box_width / 2, + centroid[0] + centroid_box_width / 2, + centroid[1] + centroid_box_width / 2, + ] + ) + # Clip to image size + centroid_box[0] = max(0, centroid_box[0]) + centroid_box[1] = max(0, centroid_box[1]) + centroid_box[2] = min(img_w, centroid_box[2]) + centroid_box[3] = min(img_h, centroid_box[3]) + + # Draw centroid box via corrected_mask mass weight + new_mask = np.zeros(corrected_mask.shape) + new_mask[int(centroid_box[1]) : int(centroid_box[3]), int(centroid_box[0]) : int(centroid_box[2])] = 1 + new_mask = new_mask.astype(int) + + new_img[:, :, 0] = new_mask + new_img[:, :, 1] = new_mask + + # imgs[i] = dilate_or_erode_mask(img, scale_factor=0.99) + imgs[i] = new_img.astype(np.uint8) + + # If require exact match for mask channels + if exact_match_rg_channel: + for img in imgs: + self.check_channels(img) + + return results diff --git a/notebooks/scripts/mmdetection_classify/classify_mmdetection_mitosis_eval.py b/notebooks/scripts/mmdetection_classify/classify_mmdetection_mitosis_eval.py index bbeda3c..394b1a5 100644 --- a/notebooks/scripts/mmdetection_classify/classify_mmdetection_mitosis_eval.py +++ b/notebooks/scripts/mmdetection_classify/classify_mmdetection_mitosis_eval.py @@ -61,7 +61,7 @@ parser = argparse.ArgumentParser(description="Evaluate mitosis detection using mmdetection") parser.add_argument("--model_dir", type=str, help="Path to the directory containing the model", required=True) parser.add_argument("--out_dir", type=str, help="Path to the output directory", required=True) -parser.add_argument("--config", type=str, help="Path to the configuration file", required=True) +parser.add_argument("--config", type=str, help="Path to the configuration file", required=False, default=None) parser.add_argument("--checkpoint", type=str, help="Path to the checkpoint file", required=True) parser.add_argument( "--video_dir", @@ -94,10 +94,12 @@ parser.add_argument( "--no-wrong-video", action="store_true", - help="In combined ver, raw videos input labels should be all WRONG", + help="whether to store wrong videos", default=False, ) +parser.add_argument("--frame-type", type=str, help="frame type to use", default="all") + args = parser.parse_args() @@ -120,6 +122,16 @@ checkpoint_file = args.checkpoint config_file = args.config +if config_file is None: + # a python file starting with 'config' and ends with '.py' + _files = glob.glob(os.path.join(model_dir, "config*.py")) + if len(_files) == 0: + raise ValueError("config file not found") + elif len(_files) > 1: + print("WARNING: multiple config files found, using the first one: ", _files) + config_file = _files[0] + print("config_file:", config_file) + assert config_file is not None cfg = Config.fromfile(config_file) DEVICE = args.device model = init_recognizer(config_file, checkpoint_file, device=DEVICE) @@ -138,6 +150,21 @@ print("test data frame:", test_data_df.columns[:2]) + +# Filtering by frame type +print(">>> Using frame type:", args.frame_type) +if args.frame_type == "all": + pass +elif args.frame_type == "video": + test_data_df = test_data_df[test_data_df["frame_type"] == "video"] +elif args.frame_type == "mask": + test_data_df = test_data_df[test_data_df["frame_type"] == "mask"] +elif args.frame_type == "combined": + test_data_df = test_data_df[test_data_df["frame_type"] == "combined"] +else: + raise ValueError("frame_type not recognized") + + if args.add_random_crop and args.is_tsn: model.cfg.test_pipeline = [ dict(io_backend="disk", type="DecordInit"), @@ -270,8 +297,11 @@ if predicted_label != test_gt_label: print("wrong prediction:", video_path, "predicted_label:", predicted_label, "gt_label:", test_gt_label) wrong_predictions.append(row_series) + + # Do not save wrong videos if specified if args.no_wrong_video: continue + data_input = data["inputs"][0] # 3 x 3 x 8 x 224 x 224 if not args.is_tsn: # timeSformer @@ -281,18 +311,21 @@ masks = list(masks) imgs = [normalize_img_to_uint8(img) for img in imgs] masks = [normalize_img_to_uint8(mask) for mask in masks] - + # Extract video filename from video_path without extension + video_filename = Path(video_path).name + _save_path = out_wrong_video_dir / video_filename # already edt transformed, so set to false frames = combine_video_frames_and_masks(imgs, masks, is_gray=True, edt_transform=False) - gen_mp4_from_frames( - frames, out_wrong_video_dir / f"wrong_{idx}-{input_frame_type}-padding_{padding_pixels}.mp4", fps=3 - ) + gen_mp4_from_frames(frames, _save_path, fps=3) else: # tsn imgs = data_input.detach().cpu().numpy() # 90 x 3 x h x w imgs = list(imgs) imgs = [normalize_img_to_uint8(img) for img in imgs] - tmp_out_sample_dir = out_wrong_video_dir / f"wrong_{idx}-{input_frame_type}-padding_{padding_pixels}" + + # extract video filename from video_path without extension + video_filename = Path(video_path).stem + tmp_out_sample_dir = out_wrong_video_dir / video_filename tmp_out_sample_dir.mkdir(parents=True, exist_ok=True) for i, img in enumerate(imgs): save_png(tmp_out_sample_dir / f"sample_dim0-{i}.png", img.swapaxes(0, 2), mode="RGB") @@ -338,22 +371,6 @@ def report_classification_metrics(true_labels, predicted_labels): return accuracy, precision, f1, report -# %% -report_classification_metrics( - all_predictions_df[all_predictions_df["frame_type"] == "combined"]["true_label"], - all_predictions_df[all_predictions_df["frame_type"] == "combined"]["predicted_label"], -) - -# %% -frame_types = all_predictions_df["frame_type"].unique() - -for frame_type in frame_types: - indexer = all_predictions_df["frame_type"] == frame_type - print("#" * 40, "frame_type:", frame_type, "#" * 40) - report_classification_metrics( - all_predictions_df[indexer]["true_label"], all_predictions_df[indexer]["predicted_label"] - ) - # %% all_predictions_df.to_csv(out_dir / "all_predictions.csv", index=False) wrong_predictions_df.to_csv(out_dir / "wrong_predictions.csv", index=False) @@ -368,3 +385,13 @@ def report_classification_metrics(true_labels, predicted_labels): wrong_predictions_df["short_src_dir"] = ( wrong_predictions_df["src_dir"].str.split(r"\\|/").apply(lambda x: "/".join(x[-3:])) ) + + +# %% +frame_types = all_predictions_df["frame_type"].unique() +for frame_type in frame_types: + indexer = all_predictions_df["frame_type"] == frame_type + print("#" * 40, "frame_type:", frame_type, "#" * 40) + report_classification_metrics( + all_predictions_df[indexer]["true_label"], all_predictions_df[indexer]["predicted_label"] + ) diff --git a/notebooks/scripts/mmdetection_classify/classify_mmdetection_mitosis_eval_centroid.py b/notebooks/scripts/mmdetection_classify/classify_mmdetection_mitosis_eval_centroid.py new file mode 100644 index 0000000..58f96ed --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/classify_mmdetection_mitosis_eval_centroid.py @@ -0,0 +1,407 @@ +# %% +import numpy as np +import matplotlib.pyplot as plt + +# from cellpose import models +from cellpose.io import imread +import glob +from pathlib import Path +from PIL import Image, ImageSequence +from tqdm import tqdm +import os +import os.path + +from sklearn.metrics import classification_report, accuracy_score, precision_score, f1_score + +# from livecellx import segment +from livecellx import core +from livecellx.core import datasets +from livecellx.core.datasets import LiveCellImageDataset, SingleImageDataset +from skimage import measure +from livecellx.core import SingleCellTrajectory, SingleCellStatic +from livecellx.core.sc_video_utils import gen_mp4_from_frames, combine_video_frames_and_masks +from livecellx.preprocess.utils import normalize_img_to_uint8 +from livecellx.core.io_utils import save_png +from centroid_aug import RandomMaskCentroid + +# import detectron2 +# from detectron2.utils.logger import setup_logger + +# setup_logger() + +# import some common libraries +import numpy as np +import os, json, cv2, random +import cv2 + +# %% [markdown] +# ## Load model + +# %% +import torch +from pathlib import Path +import pandas as pd + +# %% +from mmengine.config import Config, DictAction +from mmaction.registry import MODELS +import livecellx.track.timesformer_inference +import mmcv +from mmaction.apis import init_recognizer, inference_recognizer + +import matplotlib.pyplot as plt +import seaborn as sns +import pandas as pd + +# %% +import livecellx.track.timesformer_inference + + +import argparse + +parser = argparse.ArgumentParser(description="Evaluate mitosis detection using mmdetection") +parser.add_argument("--model_dir", type=str, help="Path to the directory containing the model", required=True) +parser.add_argument("--out_dir", type=str, help="Path to the output directory", required=True) +parser.add_argument("--config", type=str, help="Path to the configuration file", required=False, default=None) +parser.add_argument("--checkpoint", type=str, help="Path to the checkpoint file", required=True) +parser.add_argument("--frame-type", type=str, help="Frame type", required=True) +parser.add_argument( + "--video_dir", + type=str, + help="Path to the video directory", + default=r"./notebook_results/mmaction_train_data_v13-inclusive-corrected/videos", +) +parser.add_argument( + "--mmaction_data_tsv", + type=str, + help="[Deprecated] Path to the mmaction data tsv file", + default=r"./notebook_results/mmaction_train_data_v13-inclusive-corrected/mmaction_test_data_all.txt", +) +parser.add_argument( + "--test_data_meta_path", + type=str, + help="Path to the test data meta file", + default=r"./notebook_results/mmaction_train_data_v13-inclusive-corrected/test_data.txt", +) +parser.add_argument("--device", type=str, help="Device to use", default="cuda:0") +parser.add_argument("--add-random-crop", action="store_true", help="Add random crop to the pipeline") +parser.add_argument("--is-tsn", action="store_true", help="if it is tsn model") +parser.add_argument( + "--raw-video-treat-as-negative", + action="store_true", + help="In combined ver, raw videos input labels should be all WRONG", + default=False, +) + +parser.add_argument( + "--no-wrong-video", + action="store_true", + help="whether to store wrong videos", + default=False, +) + + +args = parser.parse_args() + +out_wrong_video_dir = Path(args.out_dir) / "wrong_videos" +out_wrong_video_dir.mkdir(parents=True, exist_ok=True) + +print( + "#" * 40, + "args", + "#" * 40, +) +# print each arg on each line +for arg in vars(args): + print(arg, ":", getattr(args, arg)) + +model_dir = args.model_dir +out_dir = Path(args.out_dir) +print("creating out_dir:", out_dir) +out_dir.mkdir(parents=True, exist_ok=True) + +checkpoint_file = args.checkpoint +config_file = args.config +if config_file is None: + # a python file starting with 'config' and ends with '.py' + _files = glob.glob(os.path.join(model_dir, "config*.py")) + if len(_files) == 0: + raise ValueError("config file not found") + elif len(_files) > 1: + print("WARNING: multiple config files found, using the first one: ", _files) + config_file = _files[0] + print("config_file:", config_file) + assert config_file is not None +cfg = Config.fromfile(config_file) +DEVICE = args.device +model = init_recognizer(config_file, checkpoint_file, device=DEVICE) +test_data_meta_path = args.test_data_meta_path +mmaction_data_tsv = args.mmaction_data_tsv +video_dir = args.video_dir + +# %% +# test dataframe +test_data_df = pd.read_csv(test_data_meta_path, sep=" ") +test_data_df = test_data_df.rename(columns={"label_index": "label"}) +print(test_data_df.shape) +test_data_df[:2] + +if args.frame_type == "all": + pass +else: + print("before filtering by frame_type:", test_data_df.shape) + test_data_df = test_data_df[test_data_df["frame_type"] == args.frame_type] + print("frame_type:", args.frame_type, "test_data_df.shape:", test_data_df.shape) + + +from tqdm import tqdm + +print("test data frame:", test_data_df.columns[:2]) + +centroid_sizes = [5, 10, 20, 30, 40, 50] + +if args.add_random_crop and args.is_tsn: + model.cfg.test_pipeline = [ + dict(io_backend="disk", type="DecordInit"), + dict(clip_len=3, frame_interval=1, num_clips=3, test_mode=True, type="SampleFrames"), + dict(type="DecordDecode"), + dict( + scale_range=( + 224, + 300, + ), + type="RandomRescale", + ), + dict(size=224, type="RandomCrop"), + dict( + scale=( + -1, + 224, + ), + type="Resize", + ), + dict( + scale=( + -1, + 256, + ), + type="Resize", + ), + dict(crop_size=224, type="TenCrop"), + dict(input_format="NCHW", type="FormatShape"), + dict(type="PackActionInputs"), + ] +elif args.add_random_crop: + model.cfg.test_pipeline = [ + dict(io_backend="disk", type="DecordInit"), + dict(clip_len=8, frame_interval=1, num_clips=1, test_mode=True, type="SampleFrames"), + dict(type="DecordDecode"), + dict( + scale_range=( + 224, + 300, + ), + type="RandomRescale", + ), + dict(size=224, type="RandomCrop"), + dict( + scale=( + -1, + 224, + ), + type="Resize", + ), + dict(crop_size=224, type="ThreeCrop"), + dict(input_format="NCTHW", type="FormatShape"), + dict(type="PackActionInputs"), + ] +else: + pass + # model.cfg.test_pipeline = [ + # dict(io_backend='disk', type='DecordInit'), + # dict( + # clip_len=8, + # frame_interval=1, + # num_clips=1, + # test_mode=True, + # type='SampleFrames'), + # dict(type='DecordDecode'), + # # dict(scale_range=( + # # 224, + # # 300, + # # ), type='RandomRescale'), + # # dict(scale_range=( + # # 224, + # # 300, + # # ), type='RandomRescale'), + # # dict(size=224, type='RandomCrop'), + # dict(scale=( + # -1, + # 224, + # ), type='Resize'), + # dict(crop_size=224, type='ThreeCrop'), + # dict(input_format='NCTHW', type='FormatShape'), + # dict(type='PackActionInputs'), + # ] + +centroid_aug_indx = 3 + +centroid_test_pipelines = [] +for centroid_size in centroid_sizes: + _aug = RandomMaskCentroid(fix_centroid_size=centroid_size) + pipeline = model.cfg.test_pipeline[:3] + [_aug] + model.cfg.test_pipeline[3:] + centroid_test_pipelines.append(pipeline) + +nclasses = 3 +gt2total = {class_idx: 0 for class_idx in range(nclasses)} +gt2correct = {class_idx: 0 for class_idx in range(nclasses)} +wrong_predictions = [] +all_predictions = [] +video_dir = Path(video_dir) +print("total #rows:", len(test_data_df)) + +all_rows = [_row for _row in test_data_df.iterrows()] +for centroid_size, centroid_test_pipeline in zip(centroid_sizes, centroid_test_pipelines): + model.cfg.test_pipeline = centroid_test_pipeline + for row_ in tqdm(all_rows): + idx, row_series = row_ + video_path = str(video_dir / row_series["path"]) + input_frame_type = row_series["frame_type"] + padding_pixels = row_series["padding_pixels"] + try: + model.zero_grad() + results, data, grad = livecellx.track.timesformer_inference.inference_recognizer( + model, video_path, require_grad=True, return_data_and_grad=True + ) + except Exception as e: + print("exception during prediction:", e) + # print backtrace + import traceback + + traceback.print_exc() + print("video_path:", video_path) + continue + # predicted_label = results.pred_labels.item.cpu().numpy()[0] + + predicted_label = results.pred_label.item() + if args.raw_video_treat_as_negative: + test_gt_label = 2 # no focus! + else: + test_gt_label = row_series["label"] + if test_gt_label not in gt2total: + gt2total[test_gt_label] = 0 + gt2correct[test_gt_label] = 0 + gt2total[test_gt_label] += 1 + row_series = row_series.copy() + row_series["predicted_label"] = predicted_label + row_series["true_label"] = test_gt_label + row_series["correct"] = predicted_label == test_gt_label + row_series["centroid_size"] = centroid_size + all_predictions.append(row_series) + + if predicted_label != test_gt_label: + print("wrong prediction:", video_path, "predicted_label:", predicted_label, "gt_label:", test_gt_label) + wrong_predictions.append(row_series) + + # Do not save wrong videos if specified + if args.no_wrong_video: + continue + + # Save videos with wrong predictions + data_input = data["inputs"][0] # 3 x 3 x 8 x 224 x 224 + if not args.is_tsn: + # timeSformer + imgs = data_input[1][2].detach().cpu().numpy() # 8 x 224 x 224 + masks = data_input[1][0].detach().cpu().numpy() # 8 x 224 x 224 + imgs = list(imgs) + masks = list(masks) + imgs = [normalize_img_to_uint8(img) for img in imgs] + masks = [normalize_img_to_uint8(mask) for mask in masks] + # Extract video filename from video_path without extension + video_filename = Path(video_path).name + _save_path = out_wrong_video_dir / video_filename + # already edt transformed, so set to false + frames = combine_video_frames_and_masks(imgs, masks, is_gray=True, edt_transform=False) + gen_mp4_from_frames(frames, _save_path, fps=3) + else: + # tsn + imgs = data_input.detach().cpu().numpy() # 90 x 3 x h x w + imgs = list(imgs) + imgs = [normalize_img_to_uint8(img) for img in imgs] + + # extract video filename from video_path without extension + video_filename = Path(video_path).stem + tmp_out_sample_dir = out_wrong_video_dir / video_filename + tmp_out_sample_dir.mkdir(parents=True, exist_ok=True) + for i, img in enumerate(imgs): + save_png(tmp_out_sample_dir / f"sample_dim0-{i}.png", img.swapaxes(0, 2), mode="RGB") + else: + gt2correct[test_gt_label] += 1 + + +for test_gt_label, total in gt2total.items(): + correct = gt2correct[test_gt_label] + if total == 0: + print("no video for label:", test_gt_label) + continue + print("gt_label:", test_gt_label, "total:", total, "correct:", correct, "acc:", correct / total) + + +# convert all series in wrong_predictions to dataframe +all_predictions_df = pd.DataFrame(all_predictions) +wrong_predictions_df = pd.DataFrame(wrong_predictions) +wrong_predictions_df[:2] + + +def report_classification_metrics(true_labels, predicted_labels): + # calculate the accuracy + accuracy = accuracy_score(true_labels, predicted_labels) + + # calculate the precision + precision = precision_score(true_labels, predicted_labels, average="weighted") + + # calculate the F1 score + f1 = f1_score(true_labels, predicted_labels, average="weighted") + + # generate a classification report + report = classification_report(true_labels, predicted_labels, digits=4) + + # print the metrics and classification report + print(f"Accuracy: {accuracy:.2f}") + print(f"Precision: {precision:.2f}") + print(f"F1 Score: {f1:.2f}") + print("Classification Report:") + print(report) + return accuracy, precision, f1, report + + +# %% +report_classification_metrics( + all_predictions_df[all_predictions_df["frame_type"] == "combined"]["true_label"], + all_predictions_df[all_predictions_df["frame_type"] == "combined"]["predicted_label"], +) + +# %% +frame_types = all_predictions_df["frame_type"].unique() + +for frame_type in frame_types: + indexer = all_predictions_df["frame_type"] == frame_type + print("#" * 40, "frame_type:", frame_type, "#" * 40) + report_classification_metrics( + all_predictions_df[indexer]["true_label"], all_predictions_df[indexer]["predicted_label"] + ) + +# %% +all_predictions_df.to_csv(out_dir / "all_predictions.csv", index=False) +wrong_predictions_df.to_csv(out_dir / "wrong_predictions.csv", index=False) +wrong_predictions_df = pd.read_csv(out_dir / "wrong_predictions.csv") + + +# %% [markdown] +# ### Visualize wrong predictions according to three frame types: combined, raw and mask + +# %% +# Extract the last three levels of the src_dir path +wrong_predictions_df["short_src_dir"] = ( + wrong_predictions_df["src_dir"].str.split(r"\\|/").apply(lambda x: "/".join(x[-3:])) +) diff --git a/notebooks/scripts/mmdetection_classify/configs/config_train_timesformer_divst_v14-inclusive-all-random-crop.py b/notebooks/scripts/mmdetection_classify/configs/config_train_timesformer_divst_v14-inclusive-all-random-crop.py new file mode 100644 index 0000000..f476e49 --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/configs/config_train_timesformer_divst_v14-inclusive-all-random-crop.py @@ -0,0 +1,147 @@ +_base_ = ["./default_runtime.py"] + +# model settings +model = dict( + type="Recognizer3D", + backbone=dict( + type="TimeSformer", + pretrained="https://download.openmmlab.com/mmaction/recognition/timesformer/vit_base_patch16_224.pth", # noqa: E251 # noqa: E501 + num_frames=8, + img_size=224, + patch_size=16, + embed_dims=768, + in_channels=3, + dropout_ratio=0.0, + transformer_layers=None, + attention_type="divided_space_time", + norm_cfg=dict(type="LN", eps=1e-6), + ), + cls_head=dict(type="TimeSformerHead", num_classes=400, in_channels=768, average_clips="prob"), + data_preprocessor=dict( + type="ActionDataPreprocessor", mean=[127.5, 127.5, 127.5], std=[127.5, 127.5, 127.5], format_shape="NCTHW" + ), +) + +# dataset settings + +# kinetics 400 +# dataset_type = 'VideoDataset' +# data_root = 'data/kinetics400/videos_train' +# data_root_val = 'data/kinetics400/videos_val' +# ann_file_train = 'data/kinetics400/kinetics400_train_list_videos.txt' +# ann_file_val = 'data/kinetics400/kinetics400_val_list_videos.txt' +# ann_file_test = 'data/kinetics400/kinetics400_val_list_videos.txt' + +ver = "14-inclusive" +frame_type = "all" +# frame_type = "combined" +# frame_type = "video" + +data_dir = "../../notebook_results/mmaction_train_data_v" + str(ver) + "/" +dataset_type = "VideoDataset" +data_root = data_dir + "videos" +data_root_val = data_dir + "videos" + +# for v8 onward +ann_file_train = data_dir + "mmaction_train_data_" + frame_type + ".txt" +ann_file_val = data_dir + "mmaction_test_data_" + frame_type + ".txt" +ann_file_test = data_dir + "mmaction_test_data_" + frame_type + ".txt" + +work_dir = f"./work_dirs/timesformer-default-divst-v{ver}-{frame_type}-random-crop" + +file_client_args = dict(io_backend="disk") + +train_pipeline = [ + dict(type="DecordInit", **file_client_args), + dict(type="SampleFrames", clip_len=8, frame_interval=32, num_clips=1), + dict(type="DecordDecode"), + dict(type="RandomRescale", scale_range=(400, 600)), + dict(type="RandomCrop", size=224), + dict(type="Flip", flip_ratio=0.5), + dict(type="FormatShape", input_format="NCTHW"), + dict(type="PackActionInputs"), +] +val_pipeline = [ + dict(type="DecordInit", **file_client_args), + dict(type="SampleFrames", clip_len=8, frame_interval=32, num_clips=1, test_mode=True), + dict(type="DecordDecode"), + dict(type="RandomRescale", scale_range=(400, 600)), + dict(type="RandomCrop", size=224), + dict(type="Resize", scale=(-1, 256)), + dict(type="CenterCrop", crop_size=224), + dict(type="FormatShape", input_format="NCTHW"), + dict(type="PackActionInputs"), +] +test_pipeline = [ + dict(type="DecordInit", **file_client_args), + dict(type="SampleFrames", clip_len=8, frame_interval=32, num_clips=1, test_mode=True), + dict(type="DecordDecode"), + dict(type="Resize", scale=(-1, 224)), + dict(type="ThreeCrop", crop_size=224), + dict(type="FormatShape", input_format="NCTHW"), + dict(type="PackActionInputs"), +] +train_dataloader = dict( + batch_size=8, + num_workers=8, + persistent_workers=True, + sampler=dict(type="DefaultSampler", shuffle=True), + dataset=dict( + type=dataset_type, ann_file=ann_file_train, data_prefix=dict(video=data_root), pipeline=train_pipeline + ), +) +val_dataloader = dict( + batch_size=8, + num_workers=8, + persistent_workers=True, + sampler=dict(type="DefaultSampler", shuffle=False), + dataset=dict( + type=dataset_type, + ann_file=ann_file_val, + data_prefix=dict(video=data_root_val), + pipeline=val_pipeline, + test_mode=True, + ), +) +test_dataloader = dict( + batch_size=1, + num_workers=8, + persistent_workers=True, + sampler=dict(type="DefaultSampler", shuffle=False), + dataset=dict( + type=dataset_type, + ann_file=ann_file_test, + data_prefix=dict(video=data_root_val), + pipeline=test_pipeline, + test_mode=True, + ), +) + +val_evaluator = dict(type="AccMetric") +test_evaluator = val_evaluator + +train_cfg = dict(type="EpochBasedTrainLoop", max_epochs=30, val_begin=1, val_interval=1) +val_cfg = dict(type="ValLoop") +test_cfg = dict(type="TestLoop") + +optim_wrapper = dict( + optimizer=dict(type="SGD", lr=0.005, momentum=0.9, weight_decay=1e-4, nesterov=True), + paramwise_cfg=dict( + custom_keys={ + ".backbone.cls_token": dict(decay_mult=0.0), + ".backbone.pos_embed": dict(decay_mult=0.0), + ".backbone.time_embed": dict(decay_mult=0.0), + } + ), + clip_grad=dict(max_norm=40, norm_type=2), +) + +param_scheduler = [dict(type="MultiStepLR", begin=0, end=15, by_epoch=True, milestones=[5, 10], gamma=0.1)] + +default_hooks = dict(checkpoint=dict(interval=5)) + +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (8 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=64) diff --git a/notebooks/scripts/mmdetection_classify/configs/config_train_timesformer_divst_v14-inclusive-combined-MC.py b/notebooks/scripts/mmdetection_classify/configs/config_train_timesformer_divst_v14-inclusive-combined-MC.py new file mode 100644 index 0000000..c0bb9cb --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/configs/config_train_timesformer_divst_v14-inclusive-combined-MC.py @@ -0,0 +1,151 @@ +_base_ = ["./default_runtime.py"] + +# model settings +model = dict( + type="Recognizer3D", + backbone=dict( + type="TimeSformer", + pretrained="https://download.openmmlab.com/mmaction/recognition/timesformer/vit_base_patch16_224.pth", # noqa: E251 # noqa: E501 + num_frames=8, + img_size=224, + patch_size=16, + embed_dims=768, + in_channels=3, + dropout_ratio=0.0, + transformer_layers=None, + attention_type="divided_space_time", + norm_cfg=dict(type="LN", eps=1e-6), + ), + cls_head=dict(type="TimeSformerHead", num_classes=400, in_channels=768, average_clips="prob"), + data_preprocessor=dict( + type="ActionDataPreprocessor", mean=[127.5, 127.5, 127.5], std=[127.5, 127.5, 127.5], format_shape="NCTHW" + ), +) + +# dataset settings + +# kinetics 400 +# dataset_type = 'VideoDataset' +# data_root = 'data/kinetics400/videos_train' +# data_root_val = 'data/kinetics400/videos_val' +# ann_file_train = 'data/kinetics400/kinetics400_train_list_videos.txt' +# ann_file_val = 'data/kinetics400/kinetics400_val_list_videos.txt' +# ann_file_test = 'data/kinetics400/kinetics400_val_list_videos.txt' +custom_imports = dict(imports=["centroid_aug"], allow_failed_imports=False) +ver = "14-inclusive" +# frame_type = "all" +frame_type = "combined" +# frame_type = "video" + +mask_centroid = True + +data_dir = "../../notebook_results/mmaction_train_data_v" + str(ver) + "/" +dataset_type = "VideoDataset" +data_root = data_dir + "videos" +data_root_val = data_dir + "videos" + +# for v8 onward +ann_file_train = data_dir + "mmaction_train_data_" + frame_type + ".txt" +ann_file_val = data_dir + "mmaction_test_data_" + frame_type + ".txt" +ann_file_test = data_dir + "mmaction_test_data_" + frame_type + ".txt" + +work_dir = f"./work_dirs/timesformer-default-divst-v{ver}-{frame_type}-random-crop-MC" + +file_client_args = dict(io_backend="disk") + +train_pipeline = [ + dict(type="DecordInit", **file_client_args), + dict(type="SampleFrames", clip_len=8, frame_interval=32, num_clips=1), + dict(type="DecordDecode"), + dict(type="RandomMaskCentroid", lb=2, ub=50), + dict(type="RandomRescale", scale_range=(400, 600)), + dict(type="RandomCrop", size=224), + dict(type="Flip", flip_ratio=0.5), + dict(type="FormatShape", input_format="NCTHW"), + dict(type="PackActionInputs"), +] +val_pipeline = [ + dict(type="DecordInit", **file_client_args), + dict(type="SampleFrames", clip_len=8, frame_interval=32, num_clips=1, test_mode=True), + dict(type="DecordDecode"), + dict(type="RandomMaskCentroid", lb=2, ub=50), + dict(type="RandomRescale", scale_range=(400, 600)), + dict(type="RandomCrop", size=224), + dict(type="Resize", scale=(-1, 256)), + dict(type="CenterCrop", crop_size=224), + dict(type="FormatShape", input_format="NCTHW"), + dict(type="PackActionInputs"), +] +test_pipeline = [ + dict(type="DecordInit", **file_client_args), + dict(type="SampleFrames", clip_len=8, frame_interval=32, num_clips=1, test_mode=True), + dict(type="DecordDecode"), + dict(type="Resize", scale=(-1, 224)), + dict(type="ThreeCrop", crop_size=224), + dict(type="FormatShape", input_format="NCTHW"), + dict(type="PackActionInputs"), +] +train_dataloader = dict( + batch_size=8, + num_workers=16, + persistent_workers=True, + sampler=dict(type="DefaultSampler", shuffle=True), + dataset=dict( + type=dataset_type, ann_file=ann_file_train, data_prefix=dict(video=data_root), pipeline=train_pipeline + ), +) +val_dataloader = dict( + batch_size=8, + num_workers=8, + persistent_workers=True, + sampler=dict(type="DefaultSampler", shuffle=False), + dataset=dict( + type=dataset_type, + ann_file=ann_file_val, + data_prefix=dict(video=data_root_val), + pipeline=val_pipeline, + test_mode=True, + ), +) +test_dataloader = dict( + batch_size=1, + num_workers=8, + persistent_workers=True, + sampler=dict(type="DefaultSampler", shuffle=False), + dataset=dict( + type=dataset_type, + ann_file=ann_file_test, + data_prefix=dict(video=data_root_val), + pipeline=test_pipeline, + test_mode=True, + ), +) + +val_evaluator = dict(type="AccMetric") +test_evaluator = val_evaluator + +train_cfg = dict(type="EpochBasedTrainLoop", max_epochs=60, val_begin=1, val_interval=1) +val_cfg = dict(type="ValLoop") +test_cfg = dict(type="TestLoop") + +optim_wrapper = dict( + optimizer=dict(type="SGD", lr=0.005, momentum=0.9, weight_decay=1e-4, nesterov=True), + paramwise_cfg=dict( + custom_keys={ + ".backbone.cls_token": dict(decay_mult=0.0), + ".backbone.pos_embed": dict(decay_mult=0.0), + ".backbone.time_embed": dict(decay_mult=0.0), + } + ), + clip_grad=dict(max_norm=40, norm_type=2), +) + +param_scheduler = [dict(type="MultiStepLR", begin=0, end=15, by_epoch=True, milestones=[5, 10], gamma=0.1)] + +default_hooks = dict(checkpoint=dict(interval=5)) + +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (8 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=64) diff --git a/notebooks/scripts/mmdetection_classify/configs/config_train_timesformer_divst_v14-inclusive-combined-aug-test.py b/notebooks/scripts/mmdetection_classify/configs/config_train_timesformer_divst_v14-inclusive-combined-aug-test.py new file mode 100644 index 0000000..71623a3 --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/configs/config_train_timesformer_divst_v14-inclusive-combined-aug-test.py @@ -0,0 +1,151 @@ +_base_ = ["./default_runtime.py"] + +# model settings +model = dict( + type="Recognizer3D", + backbone=dict( + type="TimeSformer", + pretrained="https://download.openmmlab.com/mmaction/recognition/timesformer/vit_base_patch16_224.pth", # noqa: E251 # noqa: E501 + num_frames=8, + img_size=224, + patch_size=16, + embed_dims=768, + in_channels=3, + dropout_ratio=0.0, + transformer_layers=None, + attention_type="divided_space_time", + norm_cfg=dict(type="LN", eps=1e-6), + ), + cls_head=dict(type="TimeSformerHead", num_classes=400, in_channels=768, average_clips="prob"), + data_preprocessor=dict( + type="ActionDataPreprocessor", mean=[127.5, 127.5, 127.5], std=[127.5, 127.5, 127.5], format_shape="NCTHW" + ), +) + +# dataset settings + +# kinetics 400 +# dataset_type = 'VideoDataset' +# data_root = 'data/kinetics400/videos_train' +# data_root_val = 'data/kinetics400/videos_val' +# ann_file_train = 'data/kinetics400/kinetics400_train_list_videos.txt' +# ann_file_val = 'data/kinetics400/kinetics400_val_list_videos.txt' +# ann_file_test = 'data/kinetics400/kinetics400_val_list_videos.txt' +custom_imports = dict(imports=["centroid_aug"], allow_failed_imports=False) +ver = "14-inclusive" +# frame_type = "all" +frame_type = "combined" +# frame_type = "video" + +mask_centroid = True + +data_dir = "../../notebook_results/mmaction_train_data_v" + str(ver) + "/" +dataset_type = "VideoDataset" +data_root = data_dir + "videos" +data_root_val = data_dir + "videos" + +# for v8 onward +ann_file_train = data_dir + "mmaction_train_data_" + frame_type + ".txt" +ann_file_val = data_dir + "mmaction_test_data_" + frame_type + ".txt" +ann_file_test = data_dir + "mmaction_test_data_" + frame_type + ".txt" + +work_dir = f"./work_dirs/timesformer-default-divst-MC-test" + +file_client_args = dict(io_backend="disk") + +train_pipeline = [ + dict(type="DecordInit", **file_client_args), + dict(type="SampleFrames", clip_len=8, frame_interval=32, num_clips=1), + dict(type="DecordDecode"), + dict(type="RandomMaskCentroid", lb=2, ub=50), + dict(type="RandomRescale", scale_range=(400, 600)), + dict(type="RandomCrop", size=224), + dict(type="Flip", flip_ratio=0.5), + dict(type="FormatShape", input_format="NCTHW"), + dict(type="PackActionInputs"), +] +val_pipeline = [ + dict(type="DecordInit", **file_client_args), + dict(type="SampleFrames", clip_len=8, frame_interval=32, num_clips=1, test_mode=True), + dict(type="DecordDecode"), + dict(type="RandomMaskCentroid", lb=2, ub=50), + dict(type="RandomRescale", scale_range=(400, 600)), + dict(type="RandomCrop", size=224), + dict(type="Resize", scale=(-1, 256)), + dict(type="CenterCrop", crop_size=224), + dict(type="FormatShape", input_format="NCTHW"), + dict(type="PackActionInputs"), +] +test_pipeline = [ + dict(type="DecordInit", **file_client_args), + dict(type="SampleFrames", clip_len=8, frame_interval=32, num_clips=1, test_mode=True), + dict(type="DecordDecode"), + dict(type="Resize", scale=(-1, 224)), + dict(type="ThreeCrop", crop_size=224), + dict(type="FormatShape", input_format="NCTHW"), + dict(type="PackActionInputs"), +] +train_dataloader = dict( + batch_size=4, + num_workers=1, + persistent_workers=True, + sampler=dict(type="DefaultSampler", shuffle=True), + dataset=dict( + type=dataset_type, ann_file=ann_file_train, data_prefix=dict(video=data_root), pipeline=train_pipeline + ), +) +val_dataloader = dict( + batch_size=8, + num_workers=8, + persistent_workers=True, + sampler=dict(type="DefaultSampler", shuffle=False), + dataset=dict( + type=dataset_type, + ann_file=ann_file_val, + data_prefix=dict(video=data_root_val), + pipeline=val_pipeline, + test_mode=True, + ), +) +test_dataloader = dict( + batch_size=1, + num_workers=8, + persistent_workers=True, + sampler=dict(type="DefaultSampler", shuffle=False), + dataset=dict( + type=dataset_type, + ann_file=ann_file_test, + data_prefix=dict(video=data_root_val), + pipeline=test_pipeline, + test_mode=True, + ), +) + +val_evaluator = dict(type="AccMetric") +test_evaluator = val_evaluator + +train_cfg = dict(type="EpochBasedTrainLoop", max_epochs=60, val_begin=1, val_interval=1) +val_cfg = dict(type="ValLoop") +test_cfg = dict(type="TestLoop") + +optim_wrapper = dict( + optimizer=dict(type="SGD", lr=0.005, momentum=0.9, weight_decay=1e-4, nesterov=True), + paramwise_cfg=dict( + custom_keys={ + ".backbone.cls_token": dict(decay_mult=0.0), + ".backbone.pos_embed": dict(decay_mult=0.0), + ".backbone.time_embed": dict(decay_mult=0.0), + } + ), + clip_grad=dict(max_norm=40, norm_type=2), +) + +param_scheduler = [dict(type="MultiStepLR", begin=0, end=15, by_epoch=True, milestones=[5, 10], gamma=0.1)] + +default_hooks = dict(checkpoint=dict(interval=5)) + +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (8 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=64) diff --git a/notebooks/scripts/mmdetection_classify/configs/config_train_timesformer_divst_v14-inclusive-combined-random-crop-resume-from-v13.py b/notebooks/scripts/mmdetection_classify/configs/config_train_timesformer_divst_v14-inclusive-combined-random-crop-resume-from-v13.py new file mode 100644 index 0000000..6ef24d0 --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/configs/config_train_timesformer_divst_v14-inclusive-combined-random-crop-resume-from-v13.py @@ -0,0 +1,147 @@ +_base_ = ["./default_runtime.py"] + +# model settings +model = dict( + type="Recognizer3D", + backbone=dict( + type="TimeSformer", + pretrained="https://download.openmmlab.com/mmaction/recognition/timesformer/vit_base_patch16_224.pth", # noqa: E251 # noqa: E501 + num_frames=8, + img_size=224, + patch_size=16, + embed_dims=768, + in_channels=3, + dropout_ratio=0.0, + transformer_layers=None, + attention_type="divided_space_time", + norm_cfg=dict(type="LN", eps=1e-6), + ), + cls_head=dict(type="TimeSformerHead", num_classes=400, in_channels=768, average_clips="prob"), + data_preprocessor=dict( + type="ActionDataPreprocessor", mean=[127.5, 127.5, 127.5], std=[127.5, 127.5, 127.5], format_shape="NCTHW" + ), +) + +# dataset settings + +# kinetics 400 +# dataset_type = 'VideoDataset' +# data_root = 'data/kinetics400/videos_train' +# data_root_val = 'data/kinetics400/videos_val' +# ann_file_train = 'data/kinetics400/kinetics400_train_list_videos.txt' +# ann_file_val = 'data/kinetics400/kinetics400_val_list_videos.txt' +# ann_file_test = 'data/kinetics400/kinetics400_val_list_videos.txt' + +ver = "14-inclusive" +# frame_type = "all" +frame_type = "combined" +# frame_type = "video" + +data_dir = "../../notebook_results/mmaction_train_data_v" + str(ver) + "/" +dataset_type = "VideoDataset" +data_root = data_dir + "videos" +data_root_val = data_dir + "videos" + +# for v8 onward +ann_file_train = data_dir + "mmaction_train_data_" + frame_type + ".txt" +ann_file_val = data_dir + "mmaction_test_data_" + frame_type + ".txt" +ann_file_test = data_dir + "mmaction_test_data_" + frame_type + ".txt" + +work_dir = f"./work_dirs/timesformer-default-divst-v{ver}-{frame_type}-random-crop" + +file_client_args = dict(io_backend="disk") + +train_pipeline = [ + dict(type="DecordInit", **file_client_args), + dict(type="SampleFrames", clip_len=8, frame_interval=32, num_clips=1), + dict(type="DecordDecode"), + dict(type="RandomRescale", scale_range=(400, 600)), + dict(type="RandomCrop", size=224), + dict(type="Flip", flip_ratio=0.5), + dict(type="FormatShape", input_format="NCTHW"), + dict(type="PackActionInputs"), +] +val_pipeline = [ + dict(type="DecordInit", **file_client_args), + dict(type="SampleFrames", clip_len=8, frame_interval=32, num_clips=1, test_mode=True), + dict(type="DecordDecode"), + dict(type="RandomRescale", scale_range=(400, 600)), + dict(type="RandomCrop", size=224), + dict(type="Resize", scale=(-1, 256)), + dict(type="CenterCrop", crop_size=224), + dict(type="FormatShape", input_format="NCTHW"), + dict(type="PackActionInputs"), +] +test_pipeline = [ + dict(type="DecordInit", **file_client_args), + dict(type="SampleFrames", clip_len=8, frame_interval=32, num_clips=1, test_mode=True), + dict(type="DecordDecode"), + dict(type="Resize", scale=(-1, 224)), + dict(type="ThreeCrop", crop_size=224), + dict(type="FormatShape", input_format="NCTHW"), + dict(type="PackActionInputs"), +] +train_dataloader = dict( + batch_size=8, + num_workers=8, + persistent_workers=True, + sampler=dict(type="DefaultSampler", shuffle=True), + dataset=dict( + type=dataset_type, ann_file=ann_file_train, data_prefix=dict(video=data_root), pipeline=train_pipeline + ), +) +val_dataloader = dict( + batch_size=8, + num_workers=8, + persistent_workers=True, + sampler=dict(type="DefaultSampler", shuffle=False), + dataset=dict( + type=dataset_type, + ann_file=ann_file_val, + data_prefix=dict(video=data_root_val), + pipeline=val_pipeline, + test_mode=True, + ), +) +test_dataloader = dict( + batch_size=1, + num_workers=8, + persistent_workers=True, + sampler=dict(type="DefaultSampler", shuffle=False), + dataset=dict( + type=dataset_type, + ann_file=ann_file_test, + data_prefix=dict(video=data_root_val), + pipeline=test_pipeline, + test_mode=True, + ), +) + +val_evaluator = dict(type="AccMetric") +test_evaluator = val_evaluator + +train_cfg = dict(type="EpochBasedTrainLoop", max_epochs=60, val_begin=1, val_interval=1) +val_cfg = dict(type="ValLoop") +test_cfg = dict(type="TestLoop") + +optim_wrapper = dict( + optimizer=dict(type="SGD", lr=0.005, momentum=0.9, weight_decay=1e-4, nesterov=True), + paramwise_cfg=dict( + custom_keys={ + ".backbone.cls_token": dict(decay_mult=0.0), + ".backbone.pos_embed": dict(decay_mult=0.0), + ".backbone.time_embed": dict(decay_mult=0.0), + } + ), + clip_grad=dict(max_norm=40, norm_type=2), +) + +param_scheduler = [dict(type="MultiStepLR", begin=0, end=15, by_epoch=True, milestones=[5, 10], gamma=0.1)] + +default_hooks = dict(checkpoint=dict(interval=5)) + +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (8 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=64) diff --git a/notebooks/scripts/mmdetection_classify/data_scripts/gen_CMU_C2C12_data.sh b/notebooks/scripts/mmdetection_classify/data_scripts/gen_CMU_C2C12_data.sh new file mode 100644 index 0000000..83c21cd --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/data_scripts/gen_CMU_C2C12_data.sh @@ -0,0 +1,27 @@ +#!/bin/bash + +# Set the environment variables +export EXP_DIR="090303-C2C12P15-FGF2" +export ANNOTATION_DIR="/home/ken67/LiveCellTracker-dev/datasets/CMU_C2C12/$EXP_DIR/Annotation_Human" + +# Create output directory if it doesn't exist +mkdir -p "../datasets/mitosis-annotations-2023/CMU_C2C12_v16/$EXP_DIR/" + +# Loop through the files F0001 to F0018 +for i in {1..18}; do + # Adjust the file number format based on the value of i + if [ $i -lt 10 ]; then + FILE_NUM="F000${i}" # For numbers 1-9, use three leading zeros + else + FILE_NUM="F00${i}" # For numbers 10-18, use two leading zeros + fi + + XML_PATH="${ANNOTATION_DIR}/Human exp1_${FILE_NUM} Data.xml" + IMG_DIR="/home/ken67/LiveCellTracker-dev/datasets/CMU_C2C12/$EXP_DIR/exp1_${FILE_NUM}" + + # Run the python script for the current file + python ../livecellx/track/process_annotation_CMU_C2C12.py \ + --xml_path="$XML_PATH" \ + --out_dir="/home/ken67/LiveCellTracker-dev/datasets/mitosis-annotations-2023/CMU_C2C12_v16/$EXP_DIR/" \ + --img_dir="$IMG_DIR" +done diff --git a/notebooks/scripts/mmdetection_classify/local_eval_scripts/v14/eval_timesformer-default-divst-v14-inclusive-combined-random-crop.sh b/notebooks/scripts/mmdetection_classify/local_eval_scripts/v14/eval_timesformer-default-divst-v14-inclusive-combined-random-crop.sh new file mode 100644 index 0000000..ed6d91f --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/local_eval_scripts/v14/eval_timesformer-default-divst-v14-inclusive-combined-random-crop.sh @@ -0,0 +1,20 @@ + +model="timesformer-default-divst-v14-inclusive-combined-random-crop" +model_dir="./work_dirs/"$model +video_dir="../../notebook_results/mmaction_train_data_v14-inclusive/videos" + +test_data_meta_path="../../notebook_results/mmaction_train_data_v14-inclusive/CXA_normal_train_test_data_meta.txt" +# test_data_meta_path="../../notebook_results/mmaction_train_data_v14-inclusive/test_data.txt" + + +python classify_mmdetection_mitosis_eval.py \ + --model_dir=$model_dir \ + --out_dir="./work_dirs/eval_results/v14/cxa_normal_only/"$model \ + --checkpoint=$model_dir/"epoch_35.pth" \ + --video_dir=$video_dir \ + --mmaction_data_tsv=$mmaction_data_tsv \ + --test_data_meta_path=$test_data_meta_path \ + --add-random-crop \ + --device="cuda:1" + + diff --git a/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_space_only_v13_inclusive-combined.sh b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_space_only_v13_inclusive-combined.sh new file mode 100644 index 0000000..c25cea6 --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_space_only_v13_inclusive-combined.sh @@ -0,0 +1,38 @@ +#!/bin/bash + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# Slurm Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +# job name +#SBATCH --job-name=train_mmaction + +#SBATCH --gres=gpu:1 +#SBATCH --exclude=g019,g102,g104,g122,g012,g013,g131 +# #SBAATCH --nodelist=g004 +#SBATCH --cpus-per-task=8 + +#SBATCH --mem=40G + +# partition (queue) declaration +#SBATCH --partition=dept_gpu + +# number of requested nodes +#SBATCH --nodes=1 + +# number of tasks +#SBATCH --ntasks=1 + +# standard output & error + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# User Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +nvidia-smi -L +PYTHON=python +OUT_DIR=local_outs + +export CUDA_VISIBLE_DEVICES=0 +model="timesformer-space_only_v13_inclusive-combined" +nohup $PYTHON train.py "configs/config_train_timesformer_spaceonly_v13-inclusive-with-mitosis-type-combined-random-crop.py" --resume auto > $OUT_DIR/train_out_model"$model".out 2>&1& \ No newline at end of file diff --git a/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_drop-div-combined-random-crop-sequential.sh b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_drop-div-combined-random-crop-sequential.sh new file mode 100644 index 0000000..c7b3c5e --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_drop-div-combined-random-crop-sequential.sh @@ -0,0 +1,38 @@ +#!/bin/bash + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# Slurm Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +# job name +#SBATCH --job-name=train_mmaction + +#SBATCH --gres=gpu:1 +#SBATCH --exclude=g019,g102,g104,g122,g012,g013,g131 +# #SBAATCH --nodelist=g004 +#SBATCH --cpus-per-task=8 + +#SBATCH --mem=40G + +# partition (queue) declaration +#SBATCH --partition=dept_gpu + +# number of requested nodes +#SBATCH --nodes=1 + +# number of tasks +#SBATCH --ntasks=1 + +# standard output & error + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# User Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +nvidia-smi -L +PYTHON=python +OUT_DIR=local_outs + +export CUDA_VISIBLE_DEVICES=1 +model="timesformer-divst_v13_drop_div-combined-random-crop-sequential" +nohup $PYTHON train.py "configs/config_train_timesformer_divst_v13-drop-div-combined-random-crop-sequential.py" --resume auto > $OUT_DIR/train_out_model"$model".out 2>&1& \ No newline at end of file diff --git a/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-all-random-crop-sequential.sh b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-all-random-crop-sequential.sh new file mode 100644 index 0000000..f158ab2 --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-all-random-crop-sequential.sh @@ -0,0 +1,38 @@ +#!/bin/bash + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# Slurm Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +# job name +#SBATCH --job-name=train_mmaction + +#SBATCH --gres=gpu:1 +#SBATCH --exclude=g019,g102,g104,g122,g012,g013,g131 +# #SBAATCH --nodelist=g004 +#SBATCH --cpus-per-task=8 + +#SBATCH --mem=40G + +# partition (queue) declaration +#SBATCH --partition=dept_gpu + +# number of requested nodes +#SBATCH --nodes=1 + +# number of tasks +#SBATCH --ntasks=1 + +# standard output & error + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# User Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +nvidia-smi -L +PYTHON=python +OUT_DIR=local_outs + +export CUDA_VISIBLE_DEVICES=0 +model="timesformer-divst_v13_inclusive-all-random-crop-sequential" +nohup $PYTHON train.py "configs/config_train_timesformer_divst_v13-inclusive-all-random-crop-sequential.py" --resume auto > $OUT_DIR/train_out_model"$model".out 2>&1& \ No newline at end of file diff --git a/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-all-random-crop.sh b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-all-random-crop.sh new file mode 100644 index 0000000..61f7537 --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-all-random-crop.sh @@ -0,0 +1,38 @@ +#!/bin/bash + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# Slurm Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +# job name +#SBATCH --job-name=train_mmaction + +#SBATCH --gres=gpu:1 +#SBATCH --exclude=g019,g102,g104,g122,g012,g013,g131 +# #SBAATCH --nodelist=g004 +#SBATCH --cpus-per-task=8 + +#SBATCH --mem=40G + +# partition (queue) declaration +#SBATCH --partition=dept_gpu + +# number of requested nodes +#SBATCH --nodes=1 + +# number of tasks +#SBATCH --ntasks=1 + +# standard output & error + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# User Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +nvidia-smi -L +PYTHON=python +OUT_DIR=local_outs + +export CUDA_VISIBLE_DEVICES=0 +model="timesformer-divst_v13_inclusive-all-random-crop" +nohup $PYTHON train.py "configs/config_train_timesformer_divst_v13-inclusive-all-random-crop.py" --resume auto > $OUT_DIR/train_out_model"$model".out 2>&1& \ No newline at end of file diff --git a/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-corrected-combined-random-crop-sampling-sequential.sh b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-corrected-combined-random-crop-sampling-sequential.sh new file mode 100644 index 0000000..4a0e7fe --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-corrected-combined-random-crop-sampling-sequential.sh @@ -0,0 +1,38 @@ +#!/bin/bash + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# Slurm Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +# job name +#SBATCH --job-name=train_mmaction + +#SBATCH --gres=gpu:1 +#SBATCH --exclude=g019,g102,g104,g122,g012,g013,g131 +# #SBAATCH --nodelist=g004 +#SBATCH --cpus-per-task=8 + +#SBATCH --mem=40G + +# partition (queue) declaration +#SBATCH --partition=dept_gpu + +# number of requested nodes +#SBATCH --nodes=1 + +# number of tasks +#SBATCH --ntasks=1 + +# standard output & error + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# User Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +nvidia-smi -L +PYTHON=python +OUT_DIR=local_outs + +export CUDA_VISIBLE_DEVICES=0 +model="timesformer-divst_v13_inclusive-corrected-combined-random-crop-sampling-sequential" +nohup $PYTHON train.py "configs/config_train_timesformer_divst_v13-inclusive-corrected-combined-random-crop-sampling-sequantial.py" --resume auto > $OUT_DIR/train_out_model"$model".out 2>&1& diff --git a/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-corrected-combined-with-negative-random-crop-sampling-sequential.sh b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-corrected-combined-with-negative-random-crop-sampling-sequential.sh new file mode 100644 index 0000000..f902aa8 --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-corrected-combined-with-negative-random-crop-sampling-sequential.sh @@ -0,0 +1,38 @@ +#!/bin/bash + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# Slurm Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +# job name +#SBATCH --job-name=train_mmaction + +#SBATCH --gres=gpu:1 +#SBATCH --exclude=g019,g102,g104,g122,g012,g013,g131 +# #SBAATCH --nodelist=g004 +#SBATCH --cpus-per-task=8 + +#SBATCH --mem=40G + +# partition (queue) declaration +#SBATCH --partition=dept_gpu + +# number of requested nodes +#SBATCH --nodes=1 + +# number of tasks +#SBATCH --ntasks=1 + +# standard output & error + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# User Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +nvidia-smi -L +PYTHON=python +OUT_DIR=local_outs + +export CUDA_VISIBLE_DEVICES=1 +model="timesformer_v13_inclusive-corrected-combined-with-negative-random-crop-sampling-sequential" +nohup $PYTHON train.py "configs/config_train_timesformer_divst_v13-inclusive-corrected-combined-with-negative-random-crop-sampling-sequantial.py" --resume auto > $OUT_DIR/train_out_model"$model".out 2>&1& diff --git a/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-video-random-crop-sequential.sh b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-video-random-crop-sequential.sh new file mode 100644 index 0000000..6f17697 --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-video-random-crop-sequential.sh @@ -0,0 +1,38 @@ +#!/bin/bash + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# Slurm Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +# job name +#SBATCH --job-name=train_mmaction + +#SBATCH --gres=gpu:1 +#SBATCH --exclude=g019,g102,g104,g122,g012,g013,g131 +# #SBAATCH --nodelist=g004 +#SBATCH --cpus-per-task=8 + +#SBATCH --mem=40G + +# partition (queue) declaration +#SBATCH --partition=dept_gpu + +# number of requested nodes +#SBATCH --nodes=1 + +# number of tasks +#SBATCH --ntasks=1 + +# standard output & error + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# User Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +nvidia-smi -L +PYTHON=python +OUT_DIR=local_outs + +export CUDA_VISIBLE_DEVICES=1 +model="timesformer-divst_v13_inclusive-all-random-crop-sequential" +nohup $PYTHON train.py "configs/config_train_timesformer_divst_v13-inclusive-video-random-crop-sequential.py" --resume auto > $OUT_DIR/train_out_model"$model".out 2>&1& \ No newline at end of file diff --git a/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-with-mitosis-type-all-random-crop.sh b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-with-mitosis-type-all-random-crop.sh new file mode 100644 index 0000000..b44bfb8 --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-with-mitosis-type-all-random-crop.sh @@ -0,0 +1,38 @@ +#!/bin/bash + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# Slurm Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +# job name +#SBATCH --job-name=train_mmaction + +#SBATCH --gres=gpu:1 +#SBATCH --exclude=g019,g102,g104,g122,g012,g013,g131 +# #SBAATCH --nodelist=g004 +#SBATCH --cpus-per-task=8 + +#SBATCH --mem=40G + +# partition (queue) declaration +#SBATCH --partition=dept_gpu + +# number of requested nodes +#SBATCH --nodes=1 + +# number of tasks +#SBATCH --ntasks=1 + +# standard output & error + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# User Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +nvidia-smi -L +PYTHON=python +OUT_DIR=local_outs + +export CUDA_VISIBLE_DEVICES=0 +model="timesformer-divst_v13_inclusive-with-mitosis-type-all-random-crop" +nohup $PYTHON train.py "configs/config_train_timesformer_divst_v13-inclusive-with-mitosis-type-all-random-crop.py" --resume auto > $OUT_DIR/train_out_model"$model".out 2>&1& \ No newline at end of file diff --git a/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-with-mitosis-type-combined-random-crop-sampling-sequential.sh b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-with-mitosis-type-combined-random-crop-sampling-sequential.sh new file mode 100644 index 0000000..8eacf43 --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-with-mitosis-type-combined-random-crop-sampling-sequential.sh @@ -0,0 +1,38 @@ +#!/bin/bash + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# Slurm Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +# job name +#SBATCH --job-name=train_mmaction + +#SBATCH --gres=gpu:1 +#SBATCH --exclude=g019,g102,g104,g122,g012,g013,g131 +# #SBAATCH --nodelist=g004 +#SBATCH --cpus-per-task=8 + +#SBATCH --mem=40G + +# partition (queue) declaration +#SBATCH --partition=dept_gpu + +# number of requested nodes +#SBATCH --nodes=1 + +# number of tasks +#SBATCH --ntasks=1 + +# standard output & error + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# User Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +nvidia-smi -L +PYTHON=python +OUT_DIR=local_outs + +export CUDA_VISIBLE_DEVICES=0 +model="timesformer-divst_v13_inclusive-with-mitosis-type-combined-random-crop-sampling-sequential" +nohup $PYTHON train.py "configs/config_train_timesformer_divst_v13-inclusive-with-mitosis-type-combined-random-crop-sampling-sequantial.py" --resume auto > $OUT_DIR/train_out_model"$model".out 2>&1& diff --git a/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-with-mitosis-type-combined-random-crop.sh b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-with-mitosis-type-combined-random-crop.sh new file mode 100644 index 0000000..6047b45 --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_inclusive-with-mitosis-type-combined-random-crop.sh @@ -0,0 +1,38 @@ +#!/bin/bash + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# Slurm Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +# job name +#SBATCH --job-name=train_mmaction + +#SBATCH --gres=gpu:1 +#SBATCH --exclude=g019,g102,g104,g122,g012,g013,g131 +# #SBAATCH --nodelist=g004 +#SBATCH --cpus-per-task=8 + +#SBATCH --mem=40G + +# partition (queue) declaration +#SBATCH --partition=dept_gpu + +# number of requested nodes +#SBATCH --nodes=1 + +# number of tasks +#SBATCH --ntasks=1 + +# standard output & error + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# User Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +nvidia-smi -L +PYTHON=python +OUT_DIR=local_outs + +export CUDA_VISIBLE_DEVICES=1 +model="timesformer-divst_v13_inclusive-with-mitosis-type-combined-random-crop" +nohup $PYTHON train.py "configs/config_train_timesformer_divst_v13-inclusive-with-mitosis-type-combined-random-crop.py" --resume auto > $OUT_DIR/train_out_model"$model".out 2>&1& \ No newline at end of file diff --git a/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_st-combined-random-crop-sequential.sh b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_st-combined-random-crop-sequential.sh new file mode 100644 index 0000000..decaa35 --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v13_st-combined-random-crop-sequential.sh @@ -0,0 +1,38 @@ +#!/bin/bash + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# Slurm Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +# job name +#SBATCH --job-name=train_mmaction + +#SBATCH --gres=gpu:1 +#SBATCH --exclude=g019,g102,g104,g122,g012,g013,g131 +# #SBAATCH --nodelist=g004 +#SBATCH --cpus-per-task=8 + +#SBATCH --mem=40G + +# partition (queue) declaration +#SBATCH --partition=dept_gpu + +# number of requested nodes +#SBATCH --nodes=1 + +# number of tasks +#SBATCH --ntasks=1 + +# standard output & error + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# User Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +nvidia-smi -L +PYTHON=python +OUT_DIR=local_outs + +export CUDA_VISIBLE_DEVICES=0 +model="timesformer-divst_v13_st-combined-random-crop-sequential" +nohup $PYTHON train.py "configs/config_train_timesformer_divst_v13-st-combined-random-crop-sequential.py" --resume auto > $OUT_DIR/train_out_model"$model".out 2>&1& \ No newline at end of file diff --git a/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v14_centroid-aug-test.sh b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v14_centroid-aug-test.sh new file mode 100644 index 0000000..d4cde89 --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v14_centroid-aug-test.sh @@ -0,0 +1,38 @@ +#!/bin/bash + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# Slurm Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +# job name +#SBATCH --job-name=train_mmaction + +#SBATCH --gres=gpu:1 +#SBATCH --exclude=g019,g102,g104,g122,g012,g013,g131 +# #SBAATCH --nodelist=g004 +#SBATCH --cpus-per-task=8 + +#SBATCH --mem=40G + +# partition (queue) declaration +#SBATCH --partition=dept_gpu + +# number of requested nodes +#SBATCH --nodes=1 + +# number of tasks +#SBATCH --ntasks=1 + +# standard output & error + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# User Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +nvidia-smi -L +PYTHON=python +OUT_DIR=local_outs + +export CUDA_VISIBLE_DEVICES=1 +model="centroid-aug-test" +nohup $PYTHON train.py "configs/config_train_timesformer_divst_v14-inclusive-combined-aug-test.py" --resume auto > $OUT_DIR/train_out_model"$model".out 2>&1& \ No newline at end of file diff --git a/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v14_inclusive-all-random-crop.sh b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v14_inclusive-all-random-crop.sh new file mode 100644 index 0000000..359afa2 --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v14_inclusive-all-random-crop.sh @@ -0,0 +1,38 @@ +#!/bin/bash + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# Slurm Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +# job name +#SBATCH --job-name=train_mmaction + +#SBATCH --gres=gpu:1 +#SBATCH --exclude=g019,g102,g104,g122,g012,g013,g131 +# #SBAATCH --nodelist=g004 +#SBATCH --cpus-per-task=8 + +#SBATCH --mem=40G + +# partition (queue) declaration +#SBATCH --partition=dept_gpu + +# number of requested nodes +#SBATCH --nodes=1 + +# number of tasks +#SBATCH --ntasks=1 + +# standard output & error + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# User Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +nvidia-smi -L +PYTHON=python +OUT_DIR=local_outs + +export CUDA_VISIBLE_DEVICES=1 +model="timesformer-divst_v14_inclusive-all-random-crop" +nohup $PYTHON train.py "configs/config_train_timesformer_divst_v14-inclusive-all-random-crop.py" --resume auto > $OUT_DIR/train_out_model"$model".out 2>&1& \ No newline at end of file diff --git a/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v14_inclusive-combined-MC.sh b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v14_inclusive-combined-MC.sh new file mode 100644 index 0000000..8990bb8 --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v14_inclusive-combined-MC.sh @@ -0,0 +1,38 @@ +#!/bin/bash + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# Slurm Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +# job name +#SBATCH --job-name=train_mmaction + +#SBATCH --gres=gpu:1 +#SBATCH --exclude=g019,g102,g104,g122,g012,g013,g131 +# #SBAATCH --nodelist=g004 +#SBATCH --cpus-per-task=8 + +#SBATCH --mem=40G + +# partition (queue) declaration +#SBATCH --partition=dept_gpu + +# number of requested nodes +#SBATCH --nodes=1 + +# number of tasks +#SBATCH --ntasks=1 + +# standard output & error + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# User Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +nvidia-smi -L +PYTHON=python +OUT_DIR=local_outs + +export CUDA_VISIBLE_DEVICES=1 +model="train_timesformer_divst_v14-inclusive-combined-MC" +nohup $PYTHON train.py "configs/config_train_timesformer_divst_v14-inclusive-combined-MC.py" --resume auto > $OUT_DIR/train_out_model"$model".out 2>&1& \ No newline at end of file diff --git a/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v14_inclusive-combined-random-crop-resume-from-v13.sh b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v14_inclusive-combined-random-crop-resume-from-v13.sh new file mode 100644 index 0000000..7d7852f --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_timesformer_v14_inclusive-combined-random-crop-resume-from-v13.sh @@ -0,0 +1,40 @@ +#!/bin/bash + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# Slurm Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +# job name +#SBATCH --job-name=train_mmaction + +#SBATCH --gres=gpu:1 +#SBATCH --exclude=g019,g102,g104,g122,g012,g013,g131 +# #SBAATCH --nodelist=g004 +#SBATCH --cpus-per-task=8 + +#SBATCH --mem=40G + +# partition (queue) declaration +#SBATCH --partition=dept_gpu + +# number of requested nodes +#SBATCH --nodes=1 + +# number of tasks +#SBATCH --ntasks=1 + +# standard output & error + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# User Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +nvidia-smi -L +PYTHON=python +OUT_DIR=local_outs + +export CUDA_VISIBLE_DEVICES=0 +model="timesformer-divst_v14_inclusive-combined-random-crop-resume-from-v13" +nohup $PYTHON train.py "configs/config_train_timesformer_divst_v14-inclusive-combined-random-crop-resume-from-v13.py" \ + --resume "/home/ken67/livecellx/notebooks/scripts/mmdetection_classify/work_dirs/timesformer-default-divst-v13-inclusive-with-mitosis-type-combined-random-crop/epoch_30.pth" \ + > $OUT_DIR/train_out_model"$model".out 2>&1& \ No newline at end of file diff --git a/notebooks/scripts/mmdetection_classify/local_gpu_train/train_train_timesformer_divst_v10-corrected-combined-random-crop-sampling-sequantial.sh b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_train_timesformer_divst_v10-corrected-combined-random-crop-sampling-sequantial.sh new file mode 100644 index 0000000..c803be8 --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_train_timesformer_divst_v10-corrected-combined-random-crop-sampling-sequantial.sh @@ -0,0 +1,7 @@ +nvidia-smi -L +PYTHON=python +OUT_DIR=local_outs + +export CUDA_VISIBLE_DEVICES=0 +model="train_train_timesformer_divst_v10-corrected-combined-random-crop-sampling-sequantial" +nohup $PYTHON train.py "configs/config_train_timesformer_divst_v10-corrected-combined-random-crop-sampling-sequantial.py" --resume auto > $OUT_DIR/train_out_model"$model".out 2>&1& \ No newline at end of file diff --git a/notebooks/scripts/mmdetection_classify/local_gpu_train/train_v13_div_cliplen=3_clipnum=3-combined.sh b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_v13_div_cliplen=3_clipnum=3-combined.sh index b7022be..ec51bef 100644 --- a/notebooks/scripts/mmdetection_classify/local_gpu_train/train_v13_div_cliplen=3_clipnum=3-combined.sh +++ b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_v13_div_cliplen=3_clipnum=3-combined.sh @@ -32,6 +32,6 @@ nvidia-smi -L PYTHON=python OUT_DIR=local_outs - +export CUDA_VISIBLE_DEVICES=0 model="v13_drop_div_clip=3_clipnum=3-combined" nohup $PYTHON train.py "configs/config_train_v13_div_cliplen=3_clipnum=3-combined.py" --resume auto > $OUT_DIR/train_out_model"$model".out 2>&1& \ No newline at end of file diff --git a/notebooks/scripts/mmdetection_classify/local_gpu_train/train_v13_inclusive-corrected_cliplen=3_clipnum=3-all.sh b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_v13_inclusive-corrected_cliplen=3_clipnum=3-all.sh new file mode 100644 index 0000000..3d6a9dd --- /dev/null +++ b/notebooks/scripts/mmdetection_classify/local_gpu_train/train_v13_inclusive-corrected_cliplen=3_clipnum=3-all.sh @@ -0,0 +1,37 @@ +#!/bin/bash + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# Slurm Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +# job name +#SBATCH --job-name=train_mmaction + +#SBATCH --gres=gpu:1 +#SBATCH --exclude=g019,g102,g104,g122,g012,g013,g131 +# #SBAATCH --nodelist=g004 +#SBATCH --cpus-per-task=8 + +#SBATCH --mem=40G + +# partition (queue) declaration +#SBATCH --partition=dept_gpu + +# number of requested nodes +#SBATCH --nodes=1 + +# number of tasks +#SBATCH --ntasks=1 + +# standard output & error + +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +# User Construction Section +#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +nvidia-smi -L +PYTHON=python +OUT_DIR=local_outs +export CUDA_VISIBLE_DEVICES=0 +model="v13_inclusive_cliplen=3_clipnum=3-all-random-crop" +nohup $PYTHON train.py "configs/config_train_v13_inclusive_cliplen=3_clipnum=3-all-random-crop.py" --resume auto > $OUT_DIR/train_out_model"$model".out 2>&1& \ No newline at end of file diff --git a/notebooks/scripts/mmdetection_classify/print_logs_train_val_info.py b/notebooks/scripts/mmdetection_classify/print_logs_train_val_info.py index 3a3fb56..1562a4b 100644 --- a/notebooks/scripts/mmdetection_classify/print_logs_train_val_info.py +++ b/notebooks/scripts/mmdetection_classify/print_logs_train_val_info.py @@ -8,6 +8,8 @@ def _get_avg_scc(logs, epoch_num): train_logs = re.findall(rf"Epoch\(train\).*\[{epoch_num}\]\[\s*\d+/\d+\].*top1_acc: (\d+\.\d+)", logs) # print("train_logs:", train_logs) + if train_logs == []: + return None, None train_top1_acc = [float(log) for log in train_logs] train_avg_acc = sum(train_top1_acc) / len(train_top1_acc) @@ -39,22 +41,23 @@ def get_avg_acc(log_file_path, epoch_num): print(f"Top1 accuracy of epoch {epoch_num} (val): {val_avg_acc}") -def plot_avg_acc(log_file_path, epoch_num, out_dir: Path = Path("result_plots/")): +def plot_avg_acc(log_file_path, epoch_num, start_epoch=1, out_dir: Path = Path("result_plots/")): with open(log_file_path, "r") as f: logs = f.read() # plot acc curve train_avg_accs = [] val_avg_accs = [] - for epoch in range(1, epoch_num + 1): + end_epoch = start_epoch + epoch_num + for epoch in range(start_epoch, end_epoch + 1): train_avg_acc, val_avg_acc = _get_avg_scc(logs, epoch) train_avg_accs.append(train_avg_acc) val_avg_accs.append(val_avg_acc) # plot and save the fig import matplotlib.pyplot as plt - plt.plot(range(1, epoch_num + 1), train_avg_accs, label="train") - plt.plot(range(1, epoch_num + 1), val_avg_accs, label="test") + plt.plot(range(start_epoch, end_epoch + 1), train_avg_accs, label="train") + plt.plot(range(start_epoch, end_epoch + 1), val_avg_accs, label="test") plt.xlabel("epoch") plt.ylabel("accuracy") plt.legend() @@ -66,11 +69,15 @@ def plot_avg_acc(log_file_path, epoch_num, out_dir: Path = Path("result_plots/") log_file_path = Path(os.path.abspath(log_file_path)).as_posix() log_filename = str(Path(log_file_path).parent.parent.name) out_dir.mkdir(parents=True, exist_ok=True) - plt.savefig(out_dir / str("acc-" + log_filename.replace(".log", ".png"))) + fig_path = out_dir / str("acc-" + log_filename.replace(".log", ".png")) + print("saving fig to:", fig_path) + plt.savefig(fig_path) plt.close() # save the accs to a csv txt file - df = pd.DataFrame({"epoch": range(1, epoch_num + 1), "train_avg_acc": train_avg_accs, "val_avg_acc": val_avg_accs}) + df = pd.DataFrame( + {"epoch": range(start_epoch, end_epoch + 1), "train_avg_acc": train_avg_accs, "val_avg_acc": val_avg_accs} + ) extracted_str = prune_log_filename(log_filename) df.to_csv(out_dir / str("acc-" + extracted_str + ".csv"), index=False) @@ -100,9 +107,10 @@ def show_result_plots(): # r"./work_dirs/tsn_imagenet-pretrained-r50_8xb32-1x1x3-100e_kinetics400-rgb-v13-drop-div-video-clipLen=3-trainClipNum=3-valClipNum=3/20231019_003517/20231019_003517.log", # r"./work_dirs/timesformer-default-divst-v13-st-video-random-crop/20231021_235643/20231021_235643.log", # r"./work_dirs/timesformer-default-divst-v13-st-combined-random-crop/20231021_134335/20231021_134335.log", - r"./work_dirs/tsn_imagenet-pretrained-r50_8xb32-1x1x3-100e_kinetics400-rgb-v13-inclusive-corrected-v1-all-clipLen=3-trainClipNum=3-valClipNum=3/20231029_141110/20231029_141110.log", + # r"./work_dirs/tsn_imagenet-pretrained-r50_8xb32-1x1x3-100e_kinetics400-rgb-v13-inclusive-corrected-v1-all-clipLen=3-trainClipNum=3-valClipNum=3/20231029_141110/20231029_141110.log", + r"./work_dirs/timesformer-default-divst-v14-inclusive-combined-random-crop/20240130_063549/20240130_063549.log" ] - epoch = 13 + epoch = 20 all_df = None for path in paths: print(">>> path:", path) @@ -124,11 +132,12 @@ def show_result_plots(): parser = argparse.ArgumentParser(description="Calculate average accuracy for a given epoch from log file") parser.add_argument("log_file_path", type=str, help="path to the log file") parser.add_argument("epoch_num", type=int, help="epoch number for which to calculate average accuracy", default=-1) + parser.add_argument("--start_epoch", type=int, help="start epoch number for plotting", default=1) args = parser.parse_args() # print args print("log_file_path:", args.log_file_path) print("epoch_num:", args.epoch_num) - get_avg_acc(args.log_file_path, args.epoch_num) - plot_avg_acc(args.log_file_path, args.epoch_num) + get_avg_acc(args.log_file_path, args.start_epoch + args.epoch_num) + plot_avg_acc(args.log_file_path, args.epoch_num, start_epoch=args.start_epoch) diff --git a/tests/test_single_cell.py b/tests/test_single_cell.py new file mode 100644 index 0000000..faff6b9 --- /dev/null +++ b/tests/test_single_cell.py @@ -0,0 +1,44 @@ +import unittest +from unittest.mock import MagicMock + +import numpy as np + +from livecellx.core.single_cell import SingleCellStatic +from livecellx.core.datasets import LiveCellImageDataset, SingleImageDataset + + +class SingleCellStaticTestCase(unittest.TestCase): + def setUp(self): + self.single_cell = SingleCellStatic() + self.single_cell.id = 1 + self.single_cell.timeframe = 0 + # self.single_cell.mask_dataset = MagicMock() + self.mask = np.zeros([5, 5]) + self.mask_dataset = SingleImageDataset(img=self.mask) + self.contour = np.array([[0, 2], [2, 2], [2, 0], [0, 0]]) + self.single_cell.img_dataset = SingleImageDataset(img=np.zeros([5, 5])) + self.single_cell.mask_dataset = self.mask_dataset + self.single_cell.contour = self.contour + + def test_get_mask_with_mask_dataset(self): + mask = self.single_cell.get_mask() + self.assertTrue((mask == self.mask).all()) + self.assertTrue(mask.shape == (5, 5)) + + def test_get_mask_with_contour(self): + self.single_cell.contour = self.contour + _mask_dataset = self.single_cell.mask_dataset + self.single_cell.mask_dataset = None + mask = self.single_cell.get_mask() + self.assertIsNotNone(mask) + self.single_cell.mask_dataset = _mask_dataset + + def test_get_mask_with_no_mask_dataset_and_contour(self): + self.single_cell.mask_dataset = None + self.single_cell.contour = None + with self.assertRaises(ValueError): + self.single_cell.get_mask() + + +if __name__ == "__main__": + unittest.main()