Upload folder using huggingface_hub

MyConfig.py

@@ -0,0 +1,17 @@
+
+from transformers import PretrainedConfig
+from typing import List
+
+class MnistConfig(PretrainedConfig):
+    # since we have an image classification task
+    # we need to put a model type that is close to our task
+    # don't worry this will not affect our model
+    model_type = "MobileNetV1"
+    def __init__(
+        self,
+        conv1=10,
+        conv2=20,
+        **kwargs):
+      self.conv1 = conv1
+      self.conv2 = conv2
+      super().__init__(**kwargs)

MyModel.py

@@ -0,0 +1,29 @@
+
+from transformers import PreTrainedModel
+from .MyConfig import MnistConfig
+from torch import nn
+import torch.nn.functional as F
+
+class MnistModel(PreTrainedModel):
+    config_class = MnistConfig
+    def __init__(self, config):
+        super().__init__(config)
+        # use the config to instantiate our model
+        self.conv1 = nn.Conv2d(1, config.conv1, kernel_size=5)
+        self.conv2 = nn.Conv2d(config.conv1, config.conv2, kernel_size=5)
+        self.conv2_drop = nn.Dropout2d()
+        self.fc1 = nn.Linear(320, 50)
+        self.fc2 = nn.Linear(50, 10)
+        self.softmax = nn.Softmax(dim=-1)
+    def forward(self, x,labels=None):
+        x = F.relu(F.max_pool2d(self.conv1(x), 2))
+        x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
+        x = x.view(-1, 320)
+        x = F.relu(self.fc1(x))
+        x = F.dropout(x, training=self.training)
+        x = self.fc2(x)
+        output = self.softmax(x)
+        if labels != None :
+          print("continue training script here")
+
+        return output

MyPipe.py

@@ -0,0 +1,65 @@
+
+from transformers import Pipeline
+import requests
+from PIL import Image
+import torchvision.transforms as transforms
+import torch
+
+class MnistPipe(Pipeline):
+    def __init__(self,**kwargs):
+
+      # self.tokenizer = (...) # code if you want to instantiate more parameters
+
+      Pipeline.__init__(self,**kwargs) # self.model automatically instantiated here
+
+      self.transform = transforms.Compose(
+                              [transforms.ToTensor(),
+                              transforms.Resize((28,28), antialias=True)
+                              ])
+
+    def _sanitize_parameters(self, **kwargs):
+        # will make sure where each parameter goes
+        preprocess_kwargs = {}
+        postprocess_kwargs = {}
+        if "download" in kwargs:
+            preprocess_kwargs["download"] = kwargs["download"]
+        if "clean_output" in kwargs :
+          postprocess_kwargs["clean_output"] = kwargs["clean_output"]
+        return preprocess_kwargs, {}, postprocess_kwargs
+
+    def preprocess(self, inputs, download=False):
+        if download == True :
+          # call download_img method and name image as "image.png"
+          self.download_img(inputs)
+          inputs = "image.png"
+
+        # we open and process the image
+        img = Image.open(inputs)
+        gray = img.convert('L')
+        tensor = self.transform(gray)
+        tensor = tensor.unsqueeze(0)
+        return tensor
+
+    def _forward(self, tensor):
+        with torch.no_grad():
+            # the model has been automatically instantiated
+            # in the __init__ method
+            out = self.model(tensor)
+        return out
+
+    def postprocess(self, out, clean_output=True):
+        if clean_output ==True :
+          label = torch.argmax(out,axis=-1) # get class
+          label = label.tolist()[0]
+          return label
+        else :
+          return out
+
+    def download_img(self,url):
+      # if download = True download image and name it image.png
+      response = requests.get(url, stream=True)
+
+      with open("image.png", "wb") as f:
+          for chunk in response.iter_content(chunk_size=8192):
+              f.write(chunk)
+      print("image saved as image.png")

README.md

@@ -0,0 +1,34 @@
+
+---
+tags:
+- custom_code
+---
+# how to create custom architectures
+you can read this [blogpost](https://huggingface.co/blog/not-lain/custom-architectures-with-huggingface) to find out more 📖
+
+# How to use
+you can the model via the command
+```python
+from transformers import AutoModelForImageClassification
+model = AutoModelForImageClassification.from_pretrained("not-lain/MyRepo", trust_remote_code=True)
+```
+or you can use the pipeline
+```python
+from transformers import pipeline
+pipe = pipeline(model="not-lain/MyRepo", trust_remote_code=True)
+pipe(
+    "url",
+    download=True, # will call the download_img method
+    clean_output=False # will be passed as postprocess_kwargs
+  )
+```
+# parameters
+the pipeline supports the following parameters :
+* download
+* clean_output
+
+you can also use the following method to download images from the web
+```python
+pipe.download_img(url)
+```
+

config.json

@@ -0,0 +1,25 @@
+{
+  "_name_or_path": "not-lain/MyRepo",
+  "architectures": [
+    "MnistModel"
+  ],
+  "auto_map": {
+    "AutoConfig": "MyConfig.MnistConfig",
+    "AutoModelForImageClassification": "MyModel.MnistModel"
+  },
+  "conv1": 10,
+  "conv2": 20,
+  "custom_pipelines": {
+    "image-classification": {
+      "impl": "MyPipe.MnistPipe",
+      "pt": [
+        "AutoModelForImageClassification"
+      ],
+      "tf": [],
+      "type": "image"
+    }
+  },
+  "model_type": "MobileNetV1",
+  "torch_dtype": "float32",
+  "transformers_version": "4.35.2"
+}

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6eee7d5198f4d57968bd06755727c4e89cd627b1b5fa7e0bfa42cf5a3bcd6697
+size 87976