Upload model

Config.py

@@ -0,0 +1,28 @@
+from transformers import PretrainedConfig
+from typing import List
+import warnings
+warnings.filterwarnings("ignore")
+
+class InceptionV3Config(PretrainedConfig):
+	model_type = "inceptionv3"
+	def __init__(self, model_name: str = "inception_v3", num_classes: int = 3, input_size: List[int] = [3, 299, 299], interpolation: str = "bicubic", mean: List[float] = [0.5, 0.5, 0.5], std: List[float] = [0.5, 0.5, 0.5], classifier: str = "fc", has_aux: bool = True, label_offset: int = 1, classes: dict = { '0': 'nsfw_gore', '1': 'nsfw_suggestive', '2': 'safe' }, output_channels: int = 2048, use_jit=False, **kwargs):
+		self.model_name = model_name
+		self.num_classes = num_classes
+		self.input_size = input_size
+		self.interpolation = interpolation
+		self.mean = mean
+		self.std = std
+		self.classifier = classifier
+		self.has_aux = has_aux
+		self.label_offset = label_offset
+		self.classes = classes
+		self.output_channels = output_channels
+		self.use_jit = use_jit
+		super().__init__(**kwargs)
+
+"""
+
+inceptionv3_config = InceptionV3Config()
+inceptionv3_config.save_pretrained("inceptionv3_config")
+
+"""

Model.py

@@ -0,0 +1,117 @@
+from transformers import PreTrainedModel
+import torch
+import os
+
+class InceptionV3ModelForImageClassification(PreTrainedModel):
+	def __init__(self, config):
+		super().__init__(config)
+
+		model_path = "google-safesearch-mini.bin"
+
+		if self.config.model_name == "google-safesearch-mini":
+			if not os.path.exists(model_path):
+				import requests
+				url = "https://huggingface.co/FredZhang7/google-safesearch-mini/resolve/main/pytorch_model.bin"
+				r = requests.get(url, allow_redirects=True)
+				open(model_path, 'wb').write(r.content)
+			self.model = torch.jit.load(model_path)
+		else:
+			raise ValueError(f"Model {self.config.model_name} not found.")
+
+	def forward(self, input_ids):
+		return self.model(input_ids), None if self.config.model_name == "inception_v3" else self.model(input_ids)
+
+	def freeze(self):
+		for param in self.model.parameters():
+			param.requires_grad = False
+
+	def unfreeze(self):
+		for param in self.model.parameters():
+			param.requires_grad = True
+
+	def train(self, mode=True):
+		super().train(mode)
+		self.model.train(mode)
+
+	def eval(self):
+		return self.train(False)
+
+	def to(self, device):
+		self.model.to(device)
+		return self
+
+	def cuda(self, device=None):
+		return self.to("cuda")
+
+	def cpu(self):
+		return self.to("cpu")
+
+	def state_dict(self, destination=None, prefix='', keep_vars=False):
+		return self.model.state_dict(destination, prefix, keep_vars)
+
+	def load_state_dict(self, state_dict, strict=True):
+		return self.model.load_state_dict(state_dict, strict)
+
+	def parameters(self, recurse=True):
+		return self.model.parameters(recurse)
+
+	def named_parameters(self, prefix='', recurse=True):
+		return self.model.named_parameters(prefix, recurse)
+
+	def children(self):
+		return self.model.children()
+
+	def named_children(self):
+		return self.model.named_children()
+
+	def modules(self):
+		return self.model.modules()
+
+	def named_modules(self, memo=None, prefix=''):
+		return self.model.named_modules(memo, prefix)
+
+	def zero_grad(self, set_to_none=False):
+		return self.model.zero_grad(set_to_none)
+
+	def share_memory(self):
+		return self.model.share_memory()
+
+	def transform(self, image):
+		from torchvision import transforms
+		transform = transforms.Compose([
+			transforms.Resize(299),
+			transforms.ToTensor(),
+			transforms.Normalize(mean=self.config.mean, std=self.config.std)
+		])
+		image = transform(image)
+		return image
+
+	def open_image(self, path):
+		from PIL import Image
+		path = 'https://images.unsplash.com/photo-1594568284297-7c64464062b1'
+		if path.startswith('http://') or path.startswith('https://'):
+			import requests
+			from io import BytesIO
+			response = requests.get(path)
+			image = Image.open(BytesIO(response.content)).convert('RGB')
+		else:
+			image = Image.open(path).convert('RGB')
+		return image
+
+	def predict(self, path, device="cuda", print_tensor=True):
+		image = self.open_image(path)
+		image = self.transform(image)
+		image = image.unsqueeze(0)
+		
+		if device == "cuda":
+			image = image.cuda()
+			self.cuda()
+		else:
+			image = image.cpu()
+			self.cpu()
+		with torch.no_grad():
+			out, aux = self(image)
+			if print_tensor:
+				print(out)
+			_, predicted = torch.max(out.logits, 1)
+		return self.config.classes[str(predicted.item())]

config.json

@@ -0,0 +1,40 @@
+{
+  "architectures": [
+    "InceptionV3ModelForImageClassification"
+  ],
+  "auto_map": {
+    "AutoConfig": "Config.InceptionV3Config",
+    "AutoModelForImageClassification": "Model.InceptionV3ModelForImageClassification"
+  },
+  "classes": {
+    "0": "nsfw_gore",
+    "1": "nsfw_suggestive",
+    "2": "safe"
+  },
+  "classifier": "fc",
+  "has_aux": true,
+  "input_size": [
+    3,
+    299,
+    299
+  ],
+  "interpolation": "bicubic",
+  "label_offset": 1,
+  "mean": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "model_name": "google-safesearch-mini",
+  "model_type": "inceptionv3",
+  "num_classes": 3,
+  "output_channels": 2048,
+  "std": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "torch_dtype": "float32",
+  "transformers_version": "4.25.1",
+  "use_jit": true
+}

pytorch_model.bin

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