Upload cell_sribd_model.py

cell_sribd_model.py

@@ -0,0 +1,99 @@
+
+import os
+join = os.path.join
+import argparse
+import numpy as np
+import torch
+import torch.nn as nn
+from collections import OrderedDict
+from torchvision import datasets, models, transforms
+from classifiers import resnet10, resnet18
+
+from utils_modify import sliding_window_inference,sliding_window_inference_large,__proc_np_hv
+from PIL import Image
+import torch.nn.functional as F
+from skimage import io, segmentation, morphology, measure, exposure
+import tifffile as tif
+from models.flexible_unet_convnext import FlexibleUNet_star,FlexibleUNet_hv 
+from transformers import PretrainedConfig
+from typing import List
+from transformers import PreTrainedModel
+from huggingface_hub import PyTorchModelHubMixin
+from torch import nn
+class ModelConfig(PretrainedConfig):
+    model_type = "cell_sribd"
+    def __init__(
+        self,
+        version = 1,
+        input_channels: int = 3,
+        roi_size: int = 512,
+        overlap: float = 0.5,
+        device: str = 'cpu',
+        **kwargs,
+    ):
+        
+        self.device = device
+        self.roi_size = (roi_size, roi_size)
+        self.input_channels = input_channels
+        self.overlap = overlap
+        self.np_thres, self.ksize, self.overall_thres, self.obj_size_thres = 0.6, 15, 0.4, 100
+        self.n_rays = 32
+        self.sw_batch_size = 4
+        self.num_classes= 4
+        self.block_size = 2048
+        self.min_overlap = 128
+        self.context = 128
+        super().__init__(**kwargs)
+        
+        
+class MyModel(PreTrainedModel):
+    config_class = ModelConfig
+    #print(config.input_channels)
+    def __init__(self, config):
+        super().__init__(config)
+        #print(config.input_channels)
+        self.cls_model = resnet18()
+        self.model0 = FlexibleUNet_star(in_channels=config.input_channels,out_channels=config.n_rays+1,backbone='convnext_small',pretrained=False,n_rays=config.n_rays,prob_out_channels=1,)
+        self.model1 = FlexibleUNet_star(in_channels=config.input_channels,out_channels=config.n_rays+1,backbone='convnext_small',pretrained=False,n_rays=config.n_rays,prob_out_channels=1,)
+        self.model2 = FlexibleUNet_star(in_channels=config.input_channels,out_channels=config.n_rays+1,backbone='convnext_small',pretrained=False,n_rays=config.n_rays,prob_out_channels=1,)
+        self.model3 = FlexibleUNet_hv(in_channels=config.input_channels,out_channels=2+2,backbone='convnext_small',pretrained=False,n_rays=2,prob_out_channels=2,)
+        self.preprocess=transforms.Compose([
+            transforms.Resize(size=256),
+            transforms.CenterCrop(size=224),
+            transforms.ToTensor(),
+            transforms.Normalize([0.485, 0.456, 0.406],[0.229, 0.224, 0.225])])
+    def load_checkpoints(self,checkpoints):
+        self.cls_model.load_state_dict(checkpoints['cls_model'])
+        self.model0.load_state_dict(checkpoints['class1_model']['model_state_dict'])
+        self.model1.load_state_dict(checkpoints['class2_model']['model_state_dict'])
+        self.model2.load_state_dict(checkpoints['class3_model']['model_state_dict'])
+        self.model3.load_state_dict(checkpoints['class4_model'])
+        
+    def forward(self, pre_img_data):
+        inputs=self.preprocess(Image.fromarray(pre_img_data)).unsqueeze(0)
+        outputs = self.cls_model(inputs)
+        _, preds = torch.max(outputs, 1)    
+        label=preds[0].cpu().numpy()
+        test_npy01 = pre_img_data
+        if label in [0,1,2] or img_data.shape[0] > 4000:
+            if label == 0:
+                output_label = sliding_window_inference_large(test_npy01,config.block_size,config.min_overlap,config.context, config.roi_size,config.sw_batch_size,predictor=self.model0,device=config.device)
+            elif label == 1:
+                output_label = sliding_window_inference_large(test_npy01,config.block_size,config.min_overlap,config.context, config.roi_size,config.sw_batch_size,predictor=self.model1,device=config.device)
+            elif label == 2:
+                output_label = sliding_window_inference_large(test_npy01,config.block_size,config.min_overlap,config.context, config.roi_size,config.sw_batch_size,predictor=self.model2,device=config.device)
+            else:
+                test_tensor = torch.from_numpy(np.expand_dims(test_npy01, 0)).permute(0, 3, 1, 2).type(torch.FloatTensor)
+
+                output_hv, output_np = sliding_window_inference(test_tensor, config.roi, config.sw_batch_size, self.model3, overlap=config.overlap,device=config.device)
+                pred_dict = {'np': output_np, 'hv': output_hv}
+                pred_dict = OrderedDict(
+                    [[k, v.permute(0, 2, 3, 1).contiguous()] for k, v in pred_dict.items()]  # NHWC
+                )
+                pred_dict["np"] = F.softmax(pred_dict["np"], dim=-1)[..., 1:]
+                pred_output = torch.cat(list(pred_dict.values()), -1).cpu().numpy() # NHW3
+                pred_map = np.squeeze(pred_output) # HW3
+                pred_inst = __proc_np_hv(pred_map, config.np_thres, config.ksize, config.overall_thres, config.obj_size_thres)
+                raw_pred_shape = pred_inst.shape[:2]
+                output_label = pred_inst
+        return output_label