Duplicate from muellerzr/deployment-no-fastai

Co-authored-by: Zachary Mueller <[email protected]>

.gitattributes

@@ -0,0 +1,34 @@
+*.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
+*.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

README.md

@@ -0,0 +1,14 @@
+---
+title: Deployment No Fastai
+emoji: 🦀
+colorFrom: red
+colorTo: pink
+sdk: gradio
+sdk_version: 3.19.1
+app_file: src/app.py
+pinned: false
+license: apache-2.0
+duplicated_from: muellerzr/deployment-no-fastai
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

exported_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:770206ed2707889bc09cb496e8fcfd69bd98334cc480ef1282ddbf1d7a235664
+size 22638841

requirements.txt

@@ -0,0 +1,5 @@
+gradio==3.18.0
+pillow==9.4.0
+timm==0.6.12
+torch==1.13.1
+torchvision==0.14.1

src/app.py

@@ -0,0 +1,52 @@
+import torch
+import gradio as gr
+from PIL import Image
+from model import get_model, apply_weights, copy_weight
+from transform import crop, pad, gpu_crop
+from torchvision.transforms import Normalize, ToTensor
+
+# Vocab
+vocab = [
+    'Abyssinian', 'Bengal', 'Birman', 
+    'Bombay', 'British_Shorthair', 
+    'Egyptian_Mau', 'Maine_Coon', 
+    'Persian', 'Ragdoll', 'Russian_Blue', 
+    'Siamese', 'Sphynx', 'american_bulldog',
+     'american_pit_bull_terrier', 'basset_hound', 
+     'beagle', 'boxer', 'chihuahua', 'english_cocker_spaniel', 
+     'english_setter', 'german_shorthaired', 
+     'great_pyrenees', 'havanese', 
+     'japanese_chin', 'keeshond', 
+     'leonberger', 'miniature_pinscher', 'newfoundland', 
+     'pomeranian', 'pug', 'saint_bernard', 'samoyed', 
+     'scottish_terrier', 'shiba_inu', 'staffordshire_bull_terrier', 
+     'wheaten_terrier', 'yorkshire_terrier'
+]
+
+
+model = get_model()
+state = torch.load('exported_model.pth', map_location="cpu")
+apply_weights(model, state, copy_weight)
+
+to_tensor = ToTensor()
+norm = Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+
+def classify_image(inp):
+    inp = Image.fromarray(inp)
+    transformed_input = pad(crop(inp, (460, 460)), (460, 460))
+    transformed_input = to_tensor(transformed_input).unsqueeze(0)
+    transformed_input = gpu_crop(transformed_input, (224, 224))
+    transformed_input = norm(transformed_input)
+    model.eval()
+    with torch.no_grad():
+        pred = model(transformed_input)
+    pred = torch.argmax(pred, dim=1)
+    return vocab[pred]
+
+iface = gr.Interface(
+    fn=classify_image,
+    inputs=gr.inputs.Image(),
+    outputs="text",
+    title="NO Fastai Classifier",
+    description="An example of not using Fastai in Gradio.",
+).launch()

src/model.py

@@ -0,0 +1,63 @@
+import torch
+import torch.nn.functional as F
+import torchvision.transforms.functional as tvf
+import torchvision.transforms as tvtfms
+import operator as op
+from PIL import Image
+from torch import nn
+from timm import create_model
+
+# For type hinting later on
+import collections
+import typing
+
+def get_model():
+    net = create_model("vit_tiny_patch16_224", pretrained=False, num_classes=0, in_chans=3)
+    head = nn.Sequential(
+        nn.BatchNorm1d(192),
+        nn.Dropout(0.25),
+        nn.Linear(192, 512, bias=False),
+        nn.ReLU(inplace=True),
+        nn.BatchNorm1d(512),
+        nn.Dropout(0.5),
+        nn.Linear(512, 37, bias=False)
+    )
+    model = nn.Sequential(net, head)
+    return model
+
+def copy_weight(name, parameter, state_dict):
+    """
+    Takes in a layer `name`, model `parameter`, and `state_dict`
+    and loads the weights from `state_dict` into `parameter`
+    if it exists.
+    """
+    # Part of the body
+    if name[0] == "0":
+        name = name[:2] + "model." + name[2:]
+    if name in state_dict.keys():
+        input_parameter = state_dict[name]
+        if input_parameter.shape == parameter.shape:
+            parameter.copy_(input_parameter)
+        else:
+            print(f'Shape mismatch at layer: {name}, skipping')
+    else:
+        print(f'{name} is not in the state_dict, skipping.')
+
+def apply_weights(input_model:nn.Module, input_weights:collections.OrderedDict, application_function:callable):
+    """
+    Takes an input state_dict and applies those weights to the `input_model`, potentially 
+    with a modifier function.
+    
+    Args:
+        input_model (`nn.Module`):
+            The model that weights should be applied to
+        input_weights (`collections.OrderedDict`):
+            A dictionary of weights, the trained model's `state_dict()`
+        application_function (`callable`):
+            A function that takes in one parameter and layer name from `input_model`
+            and the `input_weights`. Should apply the weights from the state dict into `input_model`.
+    """
+    model_dict = input_model.state_dict()
+    for name, parameter in model_dict.items():
+        application_function(name, parameter, input_weights)
+    input_model.load_state_dict(model_dict)

src/transform.py

@@ -0,0 +1,106 @@
+import typing
+import torch
+from PIL import Image
+import torchvision.transforms.functional as tvf
+import torch.nn.functional as F
+
+def crop(image:typing.Union[Image.Image, torch.tensor], size:typing.Tuple[int,int]) -> Image:
+    """
+    Takes a `PIL.Image` and crops it `size` unless one 
+    dimension is larger than the actual image. Padding 
+    must be performed afterwards if so.
+    
+    Args:
+        image (`PIL.Image`):
+            An image to perform cropping on
+        size (`tuple` of integers):
+            A size to crop to, should be in the form
+            of (width, height)
+            
+    Returns:
+        An augmented `PIL.Image`
+    """
+    top = (image.size[-2] - size[0]) // 2
+    left = (image.size[-1] - size[1]) // 2
+    
+    top = max(top, 0)
+    left = max(left, 0)
+    
+    height = min(top + size[0], image.size[-2])
+    width = min(left + size[1], image.size[-1])
+    return image.crop((top, left, height, width))
+
+def pad(image, size:typing.Tuple[int,int]) -> Image:
+    """
+    Takes a `PIL.Image` and pads it to `size` with
+    zeros.
+    
+    Args:
+        image (`PIL.Image`):
+            An image to perform padding on
+        size (`tuple` of integers):
+            A size to pad to, should be in the form
+            of (width, height)
+            
+    Returns:
+        An augmented `PIL.Image`
+    """
+    top = (image.size[-2] - size[0]) // 2
+    left = (image.size[-1] - size[1]) // 2
+    
+    pad_top = max(-top, 0)
+    pad_left = max(-left, 0)
+    
+    height, width = (
+        max(size[1] - image.size[-2] + top, 0), 
+        max(size[0] - image.size[-1] + left, 0)
+    )
+    return tvf.pad(
+        image, 
+        [pad_top, pad_left, height, width], 
+        padding_mode="constant"
+    )
+
+def gpu_crop(
+    batch:torch.tensor, 
+    size:typing.Tuple[int,int]
+):
+    """
+    Crops each image in `batch` to a particular `size`.
+    
+    Args:
+        batch (array of `torch.Tensor`):
+            A batch of images, should be of shape `NxCxWxH`
+        size (`tuple` of integers):
+            A size to pad to, should be in the form
+            of (width, height)
+            
+    Returns:
+        A batch of cropped images
+    """
+    # Split into multiple lines for clarity
+    affine_matrix = torch.eye(3, device=batch.device).float()
+    affine_matrix = affine_matrix.unsqueeze(0)
+    affine_matrix = affine_matrix.expand(batch.size(0), 3, 3)
+    affine_matrix = affine_matrix.contiguous()[:,:2]
+    
+    coords = F.affine_grid(
+        affine_matrix, batch.shape[:2] + size, align_corners=True
+    )
+    
+    top_range, bottom_range = coords.min(), coords.max()
+    zoom = 1/(bottom_range - top_range).item()*2
+    
+    resizing_limit = min(
+        batch.shape[-2]/coords.shape[-2],
+        batch.shape[-1]/coords.shape[-1]
+    )/2
+    
+    if resizing_limit > 1 and resizing_limit > zoom:
+        batch = F.interpolate(
+            batch, 
+            scale_factor=1/resizing_limit, 
+            mode='area', 
+            recompute_scale_factor=True
+        )
+    return F.grid_sample(batch, coords, mode='bilinear', padding_mode='reflection', align_corners=True)