add model

README.md

@@ -1,3 +1,118 @@
 ---
-license: apache-2.0
+tags:
+- clip
+- image-classification
+- endpoints-template
+library_name: generic
 ---
+
+# Fork of [Geonmo/laion-aesthetic-predictor](https://huggingface.co/spaces/Geonmo/laion-aesthetic-predictor) for an Image Aesthetic Predictor).
+
+This repository implements a `custom` task for `Geonmo/laion-aesthetic-predictor` for 🤗 Inference Endpoints. The code for the customized handler is in the [handler.py](https://huggingface.co/philschmid/laion-asthetic-endpoint/tree/main/handler.py).
+
+## Test Handler locally. 
+
+This model & handker can be tested locally using the [
+hf-endpoints-emulator](https://github.com/huggingface/hf-endpoints-emulator).
+
+
+1. Clone the repository and install the requirements. 
+
+```bash
+git lfs install
+git clone https://huggingface.co/philschmid/laion-asthetic-endpoint
+
+cd laion-asthetic-endpoint
+pip install -r requirements.txt
+```
+2. Install `hf-endpoints-emulator`
+
+```bash
+pip install hf-endpoints-emulator
+```
+
+3. Run the emulator
+
+```bash
+hf-endpoints-emulator --handler handler.py
+```
+
+4. Test the endpoint and send request
+
+```bash
+curl --request POST \
+  --url http://localhost \
+  --header 'Content-Type: image/jpg' \
+  --data-binary '@example1.jpg'
+```
+
+
+## Run Request 
+
+The endpoint expects the image to be served as `binary`. Below is an curl and python example
+
+#### cURL 
+
+1. get image 
+
+```bash
+wget https://fki.tic.heia-fr.ch/static/img/a01-122-02-00.jpg -O test.jpg
+```
+
+2. send cURL request
+
+```bash
+curl --request POST \
+  --url https://{ENDPOINT}/ \
+  --header 'Content-Type: image/jpg' \
+  --header 'Authorization: Bearer {HF_TOKEN}' \
+  --data-binary '@test.jpg'
+```
+
+3. the expected output
+
+```json
+{"text": "INDLUS THE"}
+```
+
+#### Python 
+
+
+1. get image 
+
+```bash
+wget https://fki.tic.heia-fr.ch/static/img/a01-122-02-00.jpg -O test.jpg
+```
+
+2. run request
+
+```python
+import json
+from typing import List
+import requests as r
+import base64
+
+ENDPOINT_URL=""
+HF_TOKEN=""
+
+def predict(path_to_image:str=None):
+    with open(path_to_image, "rb") as i:
+      b = i.read()
+    headers= {
+        "Authorization": f"Bearer {HF_TOKEN}",
+        "Content-Type": "image/jpeg" # content type of image
+    }
+    response = r.post(ENDPOINT_URL, headers=headers, data=b)
+    return response.json()
+
+prediction = predict(path_to_image="test.jpg")
+
+prediction
+```
+
+expected output
+
+```python
+{"text": "INDLUS THE"}
+```
+

handler.py

@@ -0,0 +1,52 @@
+import os
+import torch
+import clip
+from utils import MLP, normalized
+
+# set device
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+
+class EndpointHandler:
+    def __init__(self, path=""):
+        model = MLP(768)
+
+        s = torch.load(os.path.join(path, "sac+logos+ava1-l14-linearMSE.pth"), map_location=device)
+
+        model.load_state_dict(s)
+        model.to(device)
+        model.eval()
+
+        model2, preprocess = clip.load("ViT-L/14", device=device)
+
+        self.model_dict = {}
+        self.model_dict["classifier"] = model
+        self.model_dict["clip_model"] = model2
+        self.model_dict["clip_preprocess"] = preprocess
+        self.model_dict["device"] = device
+
+    def __call__(self, data):
+        """
+          data args:
+              images (:obj:`PIL.Image`)
+              candiates (:obj:`list`)
+        Return:
+              A :obj:`list`:. The list contains items that are dicts should be liked {"label": "XXX", "score": 0.82}
+        """
+        # extract converted PIL image from serialized request
+        image = data.pop("inputs", data)
+
+        image_input = self.model_dict["clip_preprocess"](image).unsqueeze(0).to(self.model_dict["device"])
+        with torch.no_grad():
+            image_features = self.model_dict["clip_model"].encode_image(image_input)
+            if self.model_dict["device"].type == "cuda":
+                im_emb_arr = normalized(image_features.detach().cpu().numpy())
+                im_emb = torch.from_numpy(im_emb_arr).to(self.model_dict["device"]).type(torch.cuda.FloatTensor)
+            else:
+                im_emb_arr = normalized(image_features.detach().numpy())
+                im_emb = torch.from_numpy(im_emb_arr).to(self.model_dict["device"]).type(torch.FloatTensor)
+
+            prediction = self.model_dict["classifier"](im_emb)
+        score = prediction.item()
+
+        return {"aesthetic score": score}

requirements.txt

@@ -0,0 +1,4 @@
+ftfy
+regex
+git+https://github.com/openai/CLIP.git
+pytorch-lightning

sac+logos+ava1-l14-linearMSE.pth

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

test.ipynb

@@ -0,0 +1,76 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from handler import EndpointHandler\n",
+    "\n",
+    "# init handler\n",
+    "my_handler = EndpointHandler(path=\".\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'aesthetic score': 6.764713287353516}"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from PIL import Image\n",
+    "\n",
+    "# read PIL image\n",
+    "image = Image.open(\"example1.jpg\")\n",
+    "payload = {\"inputs\": image}\n",
+    "\n",
+    "my_handler(payload)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "dev",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "f6dd96c16031089903d5a31ec148b80aeb0d39c32affb1a1080393235fbfa2fc"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

utils.py

@@ -0,0 +1,35 @@
+import torch
+import torch.nn as nn
+import numpy as np
+
+
+# if you changed the MLP architecture during training, change it also here:
+class MLP(torch.nn.Module):
+    def __init__(self, input_size, xcol="emb", ycol="avg_rating"):
+        super().__init__()
+        self.input_size = input_size
+        self.xcol = xcol
+        self.ycol = ycol
+        self.layers = nn.Sequential(
+            nn.Linear(self.input_size, 1024),
+            # nn.ReLU(),
+            nn.Dropout(0.2),
+            nn.Linear(1024, 128),
+            # nn.ReLU(),
+            nn.Dropout(0.2),
+            nn.Linear(128, 64),
+            # nn.ReLU(),
+            nn.Dropout(0.1),
+            nn.Linear(64, 16),
+            # nn.ReLU(),
+            nn.Linear(16, 1),
+        )
+
+    def forward(self, x):
+        return self.layers(x)
+
+
+def normalized(a, axis=-1, order=2):
+    l2 = np.atleast_1d(np.linalg.norm(a, order, axis))
+    l2[l2 == 0] = 1
+    return a / np.expand_dims(l2, axis)