get image working

experimental/clip_app.py

@@ -54,12 +54,13 @@ class CLIPTransform:
         if "text" in request:
             prompt = request["text"]
             embeddings = self.text_to_embeddings(prompt)
-        elif "image" in request:
+        elif "image_url" in request:
             image_url = request["image_url"]
             # download image from url
             import requests
             from io import BytesIO
-            input_image = Image.open(BytesIO(image_url))
+            image_bytes = requests.get(image_url).content
+            input_image = Image.open(BytesIO(image_bytes))
             input_image = input_image.convert('RGB')
             input_image = np.array(input_image)
             embeddings = self.image_to_embeddings(input_image)

experimental/clip_app_client.py

@@ -2,27 +2,72 @@
 from concurrent.futures import ThreadPoolExecutor
 import json
 import os
+import numpy as np
 import requests
 from concurrent.futures import ThreadPoolExecutor, as_completed
 import time
 
+import torch
+
+# hack for debugging, set HTTP_ADDRESS to "http://127.0.0.1:8000/"
+# os.environ["HTTP_ADDRESS"] = "http://192.168.7.79:8000"
+
 test_image_url = "https://static.wixstatic.com/media/4d6b49_42b9435ce1104008b1b5f7a3c9bfcd69~mv2.jpg/v1/fill/w_454,h_333,fp_0.50_0.50,q_90/4d6b49_42b9435ce1104008b1b5f7a3c9bfcd69~mv2.jpg"
 english_text = (
     "It was the best of times, it was the worst of times, it was the age "
     "of wisdom, it was the age of foolishness, it was the epoch of belief"
 )
 
+clip_model="ViT-L/14"
+clip_model_id ="laion5B-L-14"
+device = "cuda:0" if torch.cuda.is_available() else "cpu"
+print ("using device", device)
+from clip_retrieval.load_clip import load_clip, get_tokenizer 
+# from clip_retrieval.clip_client import ClipClient, Modality
+model, preprocess = load_clip(clip_model, use_jit=True, device=device)
+tokenizer = get_tokenizer(clip_model)
+
+def preprocess_image(image_url):
+    # download image from url
+    import requests
+    from PIL import Image
+    from io import BytesIO
+    response = requests.get(test_image_url)
+    input_image = Image.open(BytesIO(response.content))
+    input_image = input_image.convert('RGB')
+    # convert image to numpy array
+    input_image = np.array(input_image)
+    input_im = Image.fromarray(input_image)
+    prepro = preprocess(input_im).unsqueeze(0).to(device)
+    return prepro
+
+preprocessed_image = preprocess_image(test_image_url)
 
 def send_text_request(number):
-    json = {"text": english_text}
+    data = {"text": english_text}
+    url = os.environ.get("HTTP_ADDRESS", "http://127.0.0.1:8000/")
+    response = requests.post(url, json=data)
+    embeddings = response.text
+    return number, embeddings
+
+def send_image_url_request(number):
+    data = {"image_url": test_image_url}
     url = os.environ.get("HTTP_ADDRESS", "http://127.0.0.1:8000/")
-    response = requests.post(url, json=json)
+    response = requests.post(url, json=data)
     embeddings = response.text
     return number, embeddings
 
-def process_text(numbers, max_workers=10):
+def send_preprocessed_image_request(number):
+    nested_list = preprocessed_image.tolist()
+    data = {"preprocessed_image": nested_list}
+    url = os.environ.get("HTTP_ADDRESS", "http://127.0.0.1:8000/")
+    response = requests.post(url, json=data)
+    embeddings = response.text
+    return number, embeddings
+
+def process(numbers, send_func, max_workers=10):
     with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        futures = [executor.submit(send_text_request, number) for number in numbers]
+        futures = [executor.submit(send_func, number) for number in numbers]
         for future in as_completed(futures):
             n_result, result = future.result()
             result = json.loads(result)
@@ -35,15 +80,45 @@ def process_text(numbers, max_workers=10):
 #         print (f"{n_result} : {len(result[0])}")
 
 if __name__ == "__main__":
-    # n_calls = 100000
     n_calls = 10000
+
+    # test text
+    # n_calls = 1
     numbers = list(range(n_calls))
     start_time = time.monotonic()
-    process_text(numbers)
+    process(numbers, send_text_request)
     end_time = time.monotonic()
     total_time = end_time - start_time
     avg_time_ms = total_time / n_calls * 1000
     calls_per_sec = n_calls / total_time
-    print(f"Average time taken: {avg_time_ms:.2f} ms")
-    print(f"Number of calls per second: {calls_per_sec:.2f}")    
+    print(f"Text...")
+    print(f" Average time taken: {avg_time_ms:.2f} ms")
+    print(f" Number of calls per second: {calls_per_sec:.2f}")    
+
+    n_calls = 100
 
+    # test image url
+    # n_calls = 1
+    numbers = list(range(n_calls))
+    start_time = time.monotonic()
+    process(numbers, send_image_url_request)
+    end_time = time.monotonic()
+    total_time = end_time - start_time
+    avg_time_ms = total_time / n_calls * 1000
+    calls_per_sec = n_calls / total_time
+    print(f"Image passing url...")
+    print(f" Average time taken: {avg_time_ms:.2f} ms")
+    print(f" Number of calls per second: {calls_per_sec:.2f}")    
+
+    # test image as vector
+    # n_calls = 1
+    numbers = list(range(n_calls))
+    start_time = time.monotonic()
+    process(numbers, send_preprocessed_image_request)
+    end_time = time.monotonic()
+    total_time = end_time - start_time
+    avg_time_ms = total_time / n_calls * 1000
+    calls_per_sec = n_calls / total_time
+    print(f"Text...")
+    print(f" Average time taken: {avg_time_ms:.2f} ms")
+    print(f" Number of calls per second: {calls_per_sec:.2f}")