Upload 32 files

app.py

@@ -0,0 +1,69 @@
+import gradio as gr
+import torch
+<<<<<<< HEAD
+=======
+from PIL import Image
+>>>>>>> new-branch
+from main import load_and_preprocess_image, genomic_plip_predictions, classify_tiles
+
+def run_load_and_preprocess_image(image_path, clip_processor_path):
+    image_tensor = load_and_preprocess_image(image_path, clip_processor_path)
+    return image_tensor
+
+def run_genomic_plip_predictions(image_tensor, model_path):
+    pred_data = genomic_plip_predictions(image_tensor, model_path)
+    return pred_data
+
+def run_classify_tiles(pred_data, model_path):
+    output = classify_tiles(pred_data, model_path)
+    return output
+
+<<<<<<< HEAD
+with gr.Blocks() as demo:
+    image_file = gr.File(label="Upload Image File")
+=======
+example_files = list(Path("sample_tiles").glob("*.jpeg"))
+
+with gr.Blocks() as demo:
+    gr.Markdown("## Cancer Risk Prediction from Tissue Slide")
+
+    image_file = gr.Image(type="filepath", label="Upload Image File")
+>>>>>>> new-branch
+    clip_processor_path = gr.Textbox(label="CLIP Processor Path", value="./genomic_plip_model")
+    genomic_plip_model_path = gr.Textbox(label="Genomic PLIP Model Path", value="./genomic_plip_model")
+    classifier_model_path = gr.Textbox(label="Classifier Model Path", value="./models/classifier.pth")
+
+    image_tensor_output = gr.Variable()
+    pred_data_output = gr.Variable()
+    result_output = gr.Textbox(label="Result")
+
+    preprocess_button = gr.Button("Preprocess Image")
+    predict_button = gr.Button("Predict with Genomic PLIP")
+    classify_button = gr.Button("Classify Tiles")
+
+    preprocess_button.click(run_load_and_preprocess_image, inputs=[image_file, clip_processor_path], outputs=image_tensor_output)
+    predict_button.click(run_genomic_plip_predictions, inputs=[image_tensor_output, genomic_plip_model_path], outputs=pred_data_output)
+    classify_button.click(run_classify_tiles, inputs=[pred_data_output, classifier_model_path], outputs=result_output)
+
+    gr.Markdown("## Step by Step Workflow")
+    with gr.Row():
+        preprocess_status = gr.Checkbox(label="Preprocessed Image")
+        predict_status = gr.Checkbox(label="Predicted with Genomic PLIP")
+        classify_status = gr.Checkbox(label="Classified Tiles")
+
+    def update_status(status, result):
+        return status, result is not None
+
+    preprocess_button.click(update_status, inputs=[preprocess_status, image_tensor_output], outputs=preprocess_status)
+    predict_button.click(update_status, inputs=[predict_status, pred_data_output], outputs=predict_status)
+    classify_button.click(update_status, inputs=[classify_status, result_output], outputs=classify_status)
+
+<<<<<<< HEAD
+demo.launch()
+=======
+    gr.Markdown("## Example Images")
+    gr.Examples(example_files, inputs=image_file)
+
+demo.launch()
+
+>>>>>>> new-branch

classes/.ipynb_checkpoints/TissueIdentifier-checkpoint.py

@@ -0,0 +1,33 @@
+import torch
+import numpy as np
+from TissueIdentifierModel import TissueIdentifierModel
+
+class TissueIdentifier:
+    def __init__(self, model_path: str, img_processor, threshold: float = 0.95, device='cpu'):
+        self.model = self.load_model(model_path)
+        self.threshold = threshold
+        self.device = device
+        self.img_processor = img_processor
+        self.model.to(self.device)
+
+    def load_model(self, model_path):
+        model = TissueIdentifierModel()
+        model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu')))
+        model.eval()
+        return model
+
+    def process_and_identify(self, data_dict):  # Added 'self' and 'data_dict' as parameters
+        inputs = self.img_processor(images=list(data_dict.values()), return_tensors="pt")
+        x_info = {key: tensor for key, tensor in zip(data_dict.keys(), inputs['pixel_values'])}
+
+        images_tensor = inputs['pixel_values'].to(self.device)
+        with torch.no_grad():
+            outputs = self.model(images_tensor).reshape(-1)
+            predictions = outputs.cpu().numpy()
+
+        updated_dict = {key: x_info[key] for key, pred in zip(x_info.keys(), predictions) if pred > self.threshold}
+        return updated_dict
+    
+    def save_tissue_tensor(self,tissue_tiles,name=None,save_loc=None):
+        tissue_tensor = {"{}_{}".format(str(key[0]),str(key[1])): tensor for key, tensor in tissue_tiles.items()}
+        save_file(tissue_tensor, "{}/{}.safetensors".format(save_loc,name))

classes/.ipynb_checkpoints/TissueIdentifierModel-checkpoint.py

@@ -0,0 +1,35 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class TissueIdentifierModel(nn.Module):
+    def __init__(self):
+        super(TissueIdentifierModel, self).__init__()
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(3, 16, kernel_size=3,stride=1,padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(2, 2)  )
+        
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(16, 32, kernel_size=3,stride=1,padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(2, 2))
+        
+        self.conv3 = nn.Sequential(
+            nn.Conv2d(32, 64, kernel_size=3, stride=1,padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(2, 2))
+        
+        self.classifier = nn.Sequential(
+            # nn.Flatten(),
+            nn.Linear(64 * 28 * 28, 1),
+
+            nn.Sigmoid())
+    
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.conv2(x)
+        x = self.conv3(x)
+        x = x.view(x.size(0), -1)
+        x = self.classifier(x)
+        return x

classes/.ipynb_checkpoints/binary_neural_classifier-checkpoint.py

@@ -0,0 +1,16 @@
+import torch.nn as nn
+import torch
+class SimpleNN(nn.Module):
+    def __init__(self):
+        super(SimpleNN, self).__init__()
+        self.fc1 = nn.Linear(512, 512)
+        self.fc2 = nn.Linear(512, 256)
+        self.fc3 = nn.Linear(256, 1)
+
+    def forward(self, x):
+        x = torch.relu(self.fc1(x))
+        x = torch.relu(self.fc2(x))
+        x = torch.sigmoid(self.fc3(x))
+        return x
+
+

classes/.ipynb_checkpoints/genomic_plip_model-checkpoint.py

@@ -0,0 +1,18 @@
+import torch
+from transformers import PreTrainedModel, CLIPConfig, CLIPModel
+
+class GenomicPLIPModel(PreTrainedModel):
+    config_class = CLIPConfig 
+
+    def __init__(self, config):
+        super(GenomicPLIPModel, self).__init__(config)
+        vision_config = CLIPModel.config_class.from_pretrained('openai/clip-vit-base-patch32')
+        self.vision_model = CLIPModel(vision_config).vision_model
+        self.vision_projection = torch.nn.Linear(768, 512)
+
+    def forward(self, pixel_values):
+        vision_output = self.vision_model(pixel_values)
+        pooled_output = vision_output.pooler_output
+        vision_features = self.vision_projection(pooled_output)
+        
+        return vision_features

classes/.ipynb_checkpoints/slide_processor-checkpoint.py

@@ -0,0 +1,64 @@
+import numpy as np
+from concurrent.futures import ThreadPoolExecutor
+import pandas as pd
+import matplotlib.pyplot as plt
+import os
+import openslide
+from openslide import OpenSlideError
+from openslide.deepzoom import DeepZoomGenerator
+from concurrent.futures import ProcessPoolExecutor
+import math
+import tqdm
+
+class SlideProcessor:
+    def __init__(self, tile_size=1024, overlap=0, tissue_threshold=0.65, max_workers=60,CINFO=None):
+        self.tile_size = tile_size
+        self.overlap = overlap
+        self.tissue_threshold = tissue_threshold
+        self.max_workers = max_workers
+
+
+    def fetch_tile(self, tile_index, generator):
+        """ Fetch a single tile given a tile index and the tile generator. """
+        tile_size, overlap, zoom_level, col, row = tile_index
+        tile = np.asarray(generator.get_tile(zoom_level, (col, row)))
+        return (col, row), tile
+
+    def get_tiles(self, filtered_tiles, tile_indices, generator):
+        """ Retrieve tiles in parallel and return them as a dictionary with (col, row) keys. """
+        tiles = {}
+        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+            futures = [executor.submit(self.fetch_tile, ti, generator) for ti in tile_indices if (ti[3], ti[4]) in filtered_tiles]
+            
+            for future in futures:
+                key, tile = future.result()
+                if tile.shape == (self.tile_size,self.tile_size,3):
+                    tiles[key] = tile        
+        
+        return tiles
+
+    def process_one_slide(self, file_loc):
+        f2p = file_loc
+        
+        img1 = openslide.open_slide(f2p) 
+        generator = DeepZoomGenerator(img1, tile_size=self.tile_size, overlap=self.overlap, limit_bounds=True)
+        highest_zoom_level = generator.level_count - 1
+
+        try:
+            mag = int(img1.properties[openslide.PROPERTY_NAME_OBJECTIVE_POWER])
+            offset = math.floor((mag / 20) / 2)
+            level = highest_zoom_level - offset
+        except (ValueError, KeyError):
+            level = highest_zoom_level
+
+        zoom_level = level
+        cols, rows = generator.level_tiles[zoom_level]
+        tile_indices = [(self.tile_size, self.overlap, zoom_level, col, row) for col in range(cols) for row in range(rows)]
+        
+        x_info = tile_indices.copy()
+
+        all_x_info = [x[-2:] for x in x_info ]
+
+        tiles = self.get_tiles(all_x_info, tile_indices, generator)
+        
+        return tiles

classes/binary_neural_classifier.py

@@ -0,0 +1,16 @@
+import torch.nn as nn
+import torch
+class SimpleNN(nn.Module):
+    def __init__(self):
+        super(SimpleNN, self).__init__()
+        self.fc1 = nn.Linear(512, 512)
+        self.fc2 = nn.Linear(512, 256)
+        self.fc3 = nn.Linear(256, 1)
+
+    def forward(self, x):
+        x = torch.relu(self.fc1(x))
+        x = torch.relu(self.fc2(x))
+        x = torch.sigmoid(self.fc3(x))
+        return x
+
+

classes/genomic_plip_model.py

@@ -0,0 +1,18 @@
+import torch
+from transformers import PreTrainedModel, CLIPConfig, CLIPModel
+
+class GenomicPLIPModel(PreTrainedModel):
+    config_class = CLIPConfig 
+
+    def __init__(self, config):
+        super(GenomicPLIPModel, self).__init__(config)
+        vision_config = CLIPModel.config_class.from_pretrained('openai/clip-vit-base-patch32')
+        self.vision_model = CLIPModel(vision_config).vision_model
+        self.vision_projection = torch.nn.Linear(768, 512)
+
+    def forward(self, pixel_values):
+        vision_output = self.vision_model(pixel_values)
+        pooled_output = vision_output.pooler_output
+        vision_features = self.vision_projection(pooled_output)
+        
+        return vision_features

classes/slide_processor.py

@@ -0,0 +1,175 @@
+import numpy as np
+from concurrent.futures import ThreadPoolExecutor
+<<<<<<< HEAD
+=======
+<<<<<<< HEAD
+import os
+import openslide
+from PIL import Image
+from openslide import OpenSlideError
+from openslide.deepzoom import DeepZoomGenerator
+import math
+import random
+from scipy.ndimage.morphology import binary_fill_holes
+from skimage.color import rgb2gray
+from skimage.feature import canny
+from skimage.morphology import binary_closing, binary_dilation, disk
+from concurrent.futures import ProcessPoolExecutor
+
+class SlideProcessor:
+    def __init__(self,img_processor=None, tile_size=1024, overlap=0, tissue_threshold=0.65, max_workers=30):
+=======
+>>>>>>> new-branch
+#import pandas as pd
+import matplotlib.pyplot as plt
+import os
+import openslide
+from openslide import OpenSlideError
+from openslide.deepzoom import DeepZoomGenerator
+from concurrent.futures import ProcessPoolExecutor
+import math
+import tqdm
+
+class SlideProcessor:
+    def __init__(self, tile_size=1024, overlap=0, tissue_threshold=0.65, max_workers=60,CINFO=None):
+<<<<<<< HEAD
+=======
+>>>>>>> Initial commit for reconnecting to Hugging Face
+>>>>>>> new-branch
+        self.tile_size = tile_size
+        self.overlap = overlap
+        self.tissue_threshold = tissue_threshold
+        self.max_workers = max_workers
+<<<<<<< HEAD
+=======
+<<<<<<< HEAD
+        self.img_processor = img_processor
+
+    def optical_density(self, tile):
+        tile = tile.astype(np.float64)
+        od = -np.log((tile+1)/240)
+        return od
+
+    def keep_tile(self, tile, tissue_threshold=None):
+        if tissue_threshold is None:
+            tissue_threshold = self.tissue_threshold
+            
+        if tile.shape[0:2] == (self.tile_size, self.tile_size):
+            tile_orig = tile
+            tile = rgb2gray(tile)
+            tile = 1 - tile
+            tile = canny(tile)
+            tile = binary_closing(tile, disk(10))
+            tile = binary_dilation(tile, disk(10))
+            tile = binary_fill_holes(tile)
+            percentage = tile.mean()
+
+            check1 = percentage >= tissue_threshold
+
+            tile = self.optical_density(tile_orig)
+            beta = 0.15
+            tile = np.min(tile, axis=2) >= beta
+            tile = binary_closing(tile, disk(2))
+            tile = binary_dilation(tile, disk(2))
+            tile = binary_fill_holes(tile)
+            percentage = tile.mean()
+
+            check2 = percentage >= tissue_threshold
+
+            return check1 and check2
+        else:
+            return False
+        
+    def filter_tiles(self, tile_indices, generator):
+        def process_tile(tile_index):
+            tile_size, overlap, zoom_level, col, row = tile_index
+            tile = np.asarray(generator.get_tile(zoom_level, (col, row)))
+            if self.keep_tile(tile, self.tissue_threshold):
+                return col, row
+            return None
+
+        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+            results = executor.map(process_tile, tile_indices)
+        
+        return [result for result in results if result is not None]
+
+
+    def get_tiles(self, filtered_tiles, tile_indices, generator):
+        tiles = {}
+        for col, row in filtered_tiles:
+            # Find the tile_index with matching col and row
+            tile_index = next((ti for ti in tile_indices if ti[3] == col and ti[4] == row), None)
+            if tile_index:
+                tile_size, overlap, zoom_level, col, row = tile_index
+                tile = np.asarray(generator.get_tile(zoom_level, (col, row)))
+                tiles[(col,row)] = tile
+=======
+>>>>>>> new-branch
+
+
+    def fetch_tile(self, tile_index, generator):
+        """ Fetch a single tile given a tile index and the tile generator. """
+        tile_size, overlap, zoom_level, col, row = tile_index
+        tile = np.asarray(generator.get_tile(zoom_level, (col, row)))
+        return (col, row), tile
+
+    def get_tiles(self, filtered_tiles, tile_indices, generator):
+        """ Retrieve tiles in parallel and return them as a dictionary with (col, row) keys. """
+        tiles = {}
+        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+            futures = [executor.submit(self.fetch_tile, ti, generator) for ti in tile_indices if (ti[3], ti[4]) in filtered_tiles]
+            
+            for future in futures:
+                key, tile = future.result()
+                if tile.shape == (self.tile_size,self.tile_size,3):
+                    tiles[key] = tile        
+        
+<<<<<<< HEAD
+=======
+>>>>>>> Initial commit for reconnecting to Hugging Face
+>>>>>>> new-branch
+        return tiles
+
+    def process_one_slide(self, file_loc):
+        f2p = file_loc
+        
+        img1 = openslide.open_slide(f2p) 
+        generator = DeepZoomGenerator(img1, tile_size=self.tile_size, overlap=self.overlap, limit_bounds=True)
+        highest_zoom_level = generator.level_count - 1
+
+        try:
+            mag = int(img1.properties[openslide.PROPERTY_NAME_OBJECTIVE_POWER])
+            offset = math.floor((mag / 20) / 2)
+            level = highest_zoom_level - offset
+        except (ValueError, KeyError):
+            level = highest_zoom_level
+
+        zoom_level = level
+        cols, rows = generator.level_tiles[zoom_level]
+        tile_indices = [(self.tile_size, self.overlap, zoom_level, col, row) for col in range(cols) for row in range(rows)]
+        
+<<<<<<< HEAD
+=======
+<<<<<<< HEAD
+        filtered_tiles = self.filter_tiles(tile_indices, generator)
+
+        if file_loc.endswith('.svs'):
+            file = file_loc[-16:-4]
+            print(file)
+        
+        tiles = self.get_tiles(filtered_tiles, tile_indices, generator)
+
+        return tiles
+=======
+>>>>>>> new-branch
+        x_info = tile_indices.copy()
+
+        all_x_info = [x[-2:] for x in x_info ]
+
+        tiles = self.get_tiles(all_x_info, tile_indices, generator)
+        
+        return tiles
+<<<<<<< HEAD
+=======
+>>>>>>> Initial commit for reconnecting to Hugging Face
+>>>>>>> new-branch

genomic_plip/README.md

@@ -0,0 +1,3 @@
+---
+license: apache-2.0
+---

genomic_plip/config.json

@@ -0,0 +1,26 @@
+{
+  "_name_or_path": "genomic_plip_hug/",
+  "architectures": [
+    "GenomicPLIPModel"
+  ],
+  "genomic_config": {
+    "fc_layer_input": 4,
+    "fc_layer_output": 512
+  },
+  "initializer_factor": 1.0,
+  "logit_scale_init_value": 2.6592,
+  "model_type": "clip",
+  "projection_dim": 512,
+  "text_config": {
+    "bos_token_id": 0,
+    "dropout": 0.0,
+    "eos_token_id": 2,
+    "model_type": "clip_text_model"
+  },
+  "torch_dtype": "float32",
+  "transformers_version": "4.32.1",
+  "vision_config": {
+    "dropout": 0.0,
+    "model_type": "clip_vision_model"
+  }
+}

genomic_plip/preprocessor_config.json

@@ -0,0 +1,28 @@
+{
+  "crop_size": {
+    "height": 224,
+    "width": 224
+  },
+  "do_center_crop": true,
+  "do_convert_rgb": true,
+  "do_normalize": true,
+  "do_rescale": true,
+  "do_resize": true,
+  "feature_extractor_type": "CLIPFeatureExtractor",
+  "image_mean": [
+    0.48145466,
+    0.4578275,
+    0.40821073
+  ],
+  "image_processor_type": "CLIPImageProcessor",
+  "image_std": [
+    0.26862954,
+    0.26130258,
+    0.27577711
+  ],
+  "resample": 3,
+  "rescale_factor": 0.00392156862745098,
+  "size": {
+    "shortest_edge": 224
+  }
+}

genomic_plip_model/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

genomic_plip_model/README.md

@@ -0,0 +1,3 @@
+---
+license: apache-2.0
+---

genomic_plip_model/config.json

@@ -0,0 +1,26 @@
+{
+  "_name_or_path": "genomic_plip_hug/",
+  "architectures": [
+    "GenomicPLIPModel"
+  ],
+  "genomic_config": {
+    "fc_layer_input": 4,
+    "fc_layer_output": 512
+  },
+  "initializer_factor": 1.0,
+  "logit_scale_init_value": 2.6592,
+  "model_type": "clip",
+  "projection_dim": 512,
+  "text_config": {
+    "bos_token_id": 0,
+    "dropout": 0.0,
+    "eos_token_id": 2,
+    "model_type": "clip_text_model"
+  },
+  "torch_dtype": "float32",
+  "transformers_version": "4.32.1",
+  "vision_config": {
+    "dropout": 0.0,
+    "model_type": "clip_vision_model"
+  }
+}

genomic_plip_model/preprocessor_config.json

@@ -0,0 +1,28 @@
+{
+  "crop_size": {
+    "height": 224,
+    "width": 224
+  },
+  "do_center_crop": true,
+  "do_convert_rgb": true,
+  "do_normalize": true,
+  "do_rescale": true,
+  "do_resize": true,
+  "feature_extractor_type": "CLIPFeatureExtractor",
+  "image_mean": [
+    0.48145466,
+    0.4578275,
+    0.40821073
+  ],
+  "image_processor_type": "CLIPImageProcessor",
+  "image_std": [
+    0.26862954,
+    0.26130258,
+    0.27577711
+  ],
+  "resample": 3,
+  "rescale_factor": 0.00392156862745098,
+  "size": {
+    "shortest_edge": 224
+  }
+}

genomic_plip_model/pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3549ad683f995391b8dce6d18f4177d8b6bb1bd91f2275cf62eabdc62ad9474e
+size 351465073

main.py

@@ -0,0 +1,32 @@
+import torch
+from PIL import Image
+from classes.genomic_plip_model import GenomicPLIPModel 
+from classes.binary_neural_classifier import SimpleNN
+from transformers import CLIPImageProcessor
+
+def load_and_preprocess_image(image_path, clip_processor_path):
+    clip_processor = CLIPImageProcessor.from_pretrained(clip_processor_path)
+    image = Image.open(image_path).convert("RGB")
+    inputs = clip_processor(images=[image], return_tensors="pt")
+    image_tensor = inputs['pixel_values']
+    return image_tensor
+
+def genomic_plip_predictions(image_tensor, model_path):
+    gmodel = GenomicPLIPModel.from_pretrained(model_path)
+    gmodel.eval()
+    with torch.no_grad():
+        pred_data = gmodel(image_tensor)
+    return pred_data
+
+def classify_tiles(pred_data, model_path):
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = SimpleNN().to(device)
+    model.load_state_dict(torch.load(model_path, map_location=device))
+    model.eval()
+    with torch.no_grad():
+        output = model(pred_data).mean()
+    return output.item()
+<<<<<<< HEAD
+=======
+
+>>>>>>> new-branch

models/classifier.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0272ab645560a4c884ebe88324943f668bf664d074186d29f3f4240d4b7e126f
+size 1579319

requirements.txt

@@ -0,0 +1,14 @@
+numpy
+openslide-python
+scikit-image
+scikit-learn
+Pillow
+transformers
+torch
+<<<<<<< HEAD
+=======
+<<<<<<< HEAD
+Flask
+=======
+>>>>>>> Initial commit for reconnecting to Hugging Face
+>>>>>>> new-branch