added: testing app and also the workflow file

.github/workflows/main.yml

@@ -0,0 +1,31 @@
+name: Sync to Hugging Face Hub
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+
+      - name: Add remote
+        run: |
+          git remote add space https://$USER:$HF_TOKEN@huggingface.co/spaces/$USER/$SPACE
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+          USER: soutrik
+          SPACE: gradio_demo
+
+      - name: Push to hub
+        run: |
+          git push --force https://$USER:$HF_TOKEN@huggingface.co/spaces/$USER/$SPACE main
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+          USER: soutrik
+          SPACE: gradio_demo

.gitignore

@@ -30,3 +30,4 @@ artifacts/*
 *jpg
 *jpeg
 artifacts/image_prediction.png
+*.csv

app.py

@@ -0,0 +1,30 @@
+from transformers import pipeline
+import gradio as gr
+
+# Load the summarization model once
+model = pipeline("summarization")
+
+
+# Prediction function
+def predict(prompt):
+    try:
+        # Generate summary and return
+        summary = model(prompt, max_length=150, min_length=30, do_sample=False)[0][
+            "summary_text"
+        ]
+        return summary
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+# Gradio interface
+with gr.Interface(
+    fn=predict,
+    inputs=gr.Textbox(
+        label="Enter text to summarize", placeholder="Type your content here..."
+    ),
+    outputs=gr.Textbox(label="Summary"),
+    title="Text Summarizer",
+    description="Enter text and get a concise summary powered by Hugging Face transformers.",
+) as interface:
+    interface.launch()

chatbot/chatbot_app.py

@@ -0,0 +1,69 @@
+import gradio as gr
+from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
+import torch
+from threading import Thread
+
+# Load model and tokenizer
+checkpoint = "HuggingFaceTB/SmolLM2-1.7B-Instruct"
+device = "cuda"
+tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+model = AutoModelForCausalLM.from_pretrained(checkpoint, device_map="auto")
+torch.cuda.empty_cache()
+
+
+def chat_response(message, history):
+    print(f"Received message: {message}")
+    print(f"History: {history}")
+
+    messages = []
+    for h in history:
+        messages.append(h)  # Each h is already a dict with 'role' and 'content'
+    messages.append({"role": "user", "content": message})
+
+    # Generate response
+    input_text = tokenizer.apply_chat_template(messages, tokenize=False)
+    inputs = tokenizer.encode(input_text, return_tensors="pt").to(device)
+
+    # Setup streamer
+    streamer = TextIteratorStreamer(
+        tokenizer, timeout=10.0, skip_prompt=True, skip_special_tokens=True
+    )
+
+    # Generate with streaming
+    generation_kwargs = dict(
+        inputs=inputs,
+        max_new_tokens=256,
+        temperature=0.2,
+        top_p=0.9,
+        do_sample=True,
+        pad_token_id=tokenizer.eos_token_id,
+        streamer=streamer,
+    )
+
+    # Create a thread to run the generation
+    thread = Thread(target=model.generate, kwargs=generation_kwargs)
+    thread.start()
+
+    # Stream the response
+    partial_message = ""
+    for new_token in streamer:
+        partial_message += new_token
+        yield partial_message
+
+
+# Create and launch the Gradio interface
+demo = gr.ChatInterface(
+    fn=chat_response,
+    type="messages",
+    title="SmolLM2 Chatbot",
+    description="A chatbot powered by SmolLM2-1.7B-Instruct model",
+    examples=[
+        "What is the capital of France?",
+        "How does photosynthesis work?",
+        "Write a short poem about autumn.",
+    ],
+    cache_examples=True,
+)
+
+if __name__ == "__main__":
+    demo.launch()

concurrent_client.py

@@ -0,0 +1,57 @@
+from gradio_client import Client, handle_file
+import concurrent.futures
+import time
+from pathlib import Path
+
+
+def make_prediction(client, image_url):
+    """Make a single prediction"""
+    try:
+        result = client.predict(
+            # image_list=handle_file(image_url),
+            image_list=handle_file(image_url),
+            api_name="/predict",
+        )
+        return result
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def main(requests=16):
+    # Single test image URL
+    image_url = "https://img.freepik.com/free-photo/closeup-shot-cute-grey-kitty-isolated-white-background_181624-35013.jpg?ga=GA1.1.302994776.1729496489&semt=ais_hybrid"
+
+    # Initialize client
+    client = Client("http://127.0.0.1:7860/")
+
+    print("\nSending 16 concurrent requests with the same image...")
+    start_time = time.time()
+
+    # Use ThreadPoolExecutor to send 16 requests concurrently
+    with concurrent.futures.ThreadPoolExecutor(max_workers=16) as executor:
+        futures = [
+            executor.submit(make_prediction, client, image_url) for _ in range(requests)
+        ]
+
+        # Collect results as they complete
+        results = []
+        for i, future in enumerate(concurrent.futures.as_completed(futures)):
+            try:
+                result = future.result()
+                results.append(result)
+                print(f"Completed prediction {i+1}/{requests}")
+            except Exception as e:
+                print(f"Error in request {i+1}: {str(e)}")
+
+    end_time = time.time()
+
+    # Print results
+    print(f"\nAll predictions completed in {end_time - start_time:.2f} seconds")
+    print("\nResults:")
+    for i, result in enumerate(results):
+        print(f"\nRequest {i+1}:")
+        print(result)
+
+
+if __name__ == "__main__":
+    main(16)

image_classifier/batch_classifier.py

@@ -0,0 +1,83 @@
+import gradio as gr
+import torch
+import timm
+from PIL import Image
+import time
+from tqdm import tqdm
+import numpy as np
+import requests
+
+
+class ImageClassifier:
+    def __init__(self):
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model = timm.create_model("resnet50.a1_in1k", pretrained=True)
+        self.model = self.model.to(self.device)
+        self.model.eval()
+
+        data_config = timm.data.resolve_model_data_config(self.model)
+        self.transform = timm.data.create_transform(**data_config, is_training=False)
+        url = "https://storage.googleapis.com/bit_models/ilsvrc2012_wordnet_lemmas.txt"
+        self.labels = requests.get(url).text.strip().split("\n")
+
+    @torch.no_grad()
+    def predict_batch(self, image_list, progress=gr.Progress(track_tqdm=True)):
+        if isinstance(image_list, tuple) and len(image_list) == 1:
+            image_list = [image_list[0]]
+
+        if not image_list or image_list[0] is None:
+            return [[{"none": 1.0}]]
+
+        progress(0.1, desc="Starting preprocessing...")
+        tensors = []
+
+        # Process each image in the batch
+        for image in image_list:
+            if image is None:
+                continue
+            # Convert numpy array to PIL Image
+            img = Image.fromarray(image).convert("RGB")
+            tensor = self.transform(img)
+            tensors.append(tensor)
+
+        if not tensors:
+            return [[{"none": 1.0}]]
+
+        progress(0.4, desc="Batching tensors...")
+        batch = torch.stack(tensors).to(self.device)
+
+        progress(0.6, desc="Running inference...")
+        outputs = self.model(batch)
+        probabilities = torch.nn.functional.softmax(outputs, dim=1)
+
+        progress(0.8, desc="Processing results...")
+        batch_results = []
+        for probs in probabilities:
+            top5_prob, top5_catid = torch.topk(probs, 5)
+            result = {
+                self.labels[idx.item()]: float(prob)
+                for prob, idx in zip(top5_prob, top5_catid)
+            }
+            batch_results.append(result)
+
+        progress(1.0, desc="Done!")
+        # Return results in the required format: list of list of dicts
+        return [batch_results]
+
+
+# Create classifier instance
+classifier = ImageClassifier()
+
+# Create Gradio interface
+demo = gr.Interface(
+    fn=classifier.predict_batch,
+    inputs=gr.Image(),
+    outputs=gr.Label(num_top_classes=5),
+    title="Advanced Image Classification with Mamba",
+    description="Upload images for batch classification with the resnet50.a1_in1k model",
+    batch=True,
+    max_batch_size=4,
+)
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)

image_classifier/single_classifier.py

@@ -0,0 +1,59 @@
+import gradio as gr
+import torch
+import timm
+from PIL import Image
+import requests
+
+
+class ImageClassifier:
+    def __init__(self):
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        # Create model and move to appropriate device
+        self.model = timm.create_model("resnet50.a1_in1k", pretrained=True)
+        self.model = self.model.to(self.device)
+        self.model.eval()
+
+        # Get model specific transforms
+        data_config = timm.data.resolve_model_data_config(self.model)
+        self.transform = timm.data.create_transform(**data_config, is_training=False)
+
+        # Load ImageNet labels
+        url = "https://storage.googleapis.com/bit_models/ilsvrc2012_wordnet_lemmas.txt"
+        self.labels = requests.get(url).text.strip().split("\n")
+
+    @torch.no_grad()
+    def predict(self, image):
+        if image is None:
+            return None
+
+        # Preprocess image
+        img = Image.fromarray(image).convert("RGB")
+        img_tensor = self.transform(img).unsqueeze(0).to(self.device)
+
+        # Get prediction
+        output = self.model(img_tensor)
+        probabilities = torch.nn.functional.softmax(output[0], dim=0)
+
+        # Get top 5 predictions
+        top5_prob, top5_catid = torch.topk(probabilities, 5)
+
+        return {
+            self.labels[idx.item()]: float(prob)
+            for prob, idx in zip(top5_prob, top5_catid)
+        }
+
+
+# Create classifier instance
+classifier = ImageClassifier()
+
+# Create Gradio interface
+demo = gr.Interface(
+    fn=classifier.predict,
+    inputs=gr.Image(type="numpy", label="Input Image"),
+    outputs=gr.Label(num_top_classes=5, label="Top 5 Predictions"),
+    title="Basic Image Classification with Mamba",
+    description="Upload an image to classify it using the resnet50.a1_in1k model",
+)
+
+if __name__ == "__main__":
+    demo.launch()

poetry.lock

@@ -11,6 +11,37 @@ files = [
     {file = "absl_py-2.1.0-py3-none-any.whl", hash = "sha256:526a04eadab8b4ee719ce68f204172ead1027549089702d99b9059f129ff1308"},
 ]
 
+[[package]]
+name = "accelerate"
+version = "1.1.1"
+description = "Accelerate"
+optional = false
+python-versions = ">=3.9.0"
+files = [
+    {file = "accelerate-1.1.1-py3-none-any.whl", hash = "sha256:61edd81762131b8d4bede008643fa1e1f3bf59bec710ebda9771443e24feae02"},
+    {file = "accelerate-1.1.1.tar.gz", hash = "sha256:0d39dfac557052bc735eb2703a0e87742879e1e40b88af8a2f9a93233d4cd7db"},
+]
+
+[package.dependencies]
+huggingface-hub = ">=0.21.0"
+numpy = ">=1.17,<3.0.0"
+packaging = ">=20.0"
+psutil = "*"
+pyyaml = "*"
+safetensors = ">=0.4.3"
+torch = ">=1.10.0"
+
+[package.extras]
+deepspeed = ["deepspeed"]
+dev = ["bitsandbytes", "black (>=23.1,<24.0)", "datasets", "diffusers", "evaluate", "hf-doc-builder (>=0.3.0)", "parameterized", "pytest (>=7.2.0,<=8.0.0)", "pytest-subtests", "pytest-xdist", "rich", "ruff (>=0.6.4,<0.7.0)", "scikit-learn", "scipy", "timm", "torchdata (>=0.8.0)", "torchpippy (>=0.2.0)", "tqdm", "transformers"]
+quality = ["black (>=23.1,<24.0)", "hf-doc-builder (>=0.3.0)", "ruff (>=0.6.4,<0.7.0)"]
+rich = ["rich"]
+sagemaker = ["sagemaker"]
+test-dev = ["bitsandbytes", "datasets", "diffusers", "evaluate", "scikit-learn", "scipy", "timm", "torchdata (>=0.8.0)", "torchpippy (>=0.2.0)", "tqdm", "transformers"]
+test-prod = ["parameterized", "pytest (>=7.2.0,<=8.0.0)", "pytest-subtests", "pytest-xdist"]
+test-trackers = ["comet-ml", "dvclive", "tensorboard", "wandb"]
+testing = ["bitsandbytes", "datasets", "diffusers", "evaluate", "parameterized", "pytest (>=7.2.0,<=8.0.0)", "pytest-subtests", "pytest-xdist", "scikit-learn", "scipy", "timm", "torchdata (>=0.8.0)", "torchpippy (>=0.2.0)", "tqdm", "transformers"]
+
 [[package]]
 name = "adlfs"
 version = "2024.7.0"
@@ -5679,13 +5710,13 @@ yaml = ["pyyaml (>=6.0.1)"]
 
 [[package]]
 name = "pydot"
-version = "3.0.2"
+version = "3.0.3"
 description = "Python interface to Graphviz's Dot"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "pydot-3.0.2-py3-none-any.whl", hash = "sha256:99cedaa55d04abb0b2bc56d9981a6da781053dd5ac75c428e8dd53db53f90b14"},
-    {file = "pydot-3.0.2.tar.gz", hash = "sha256:9180da540b51b3aa09fbf81140b3edfbe2315d778e8589a7d0a4a69c41332bae"},
+    {file = "pydot-3.0.3-py3-none-any.whl", hash = "sha256:9b0b3081e0bd362d0c61148da10eb1281ec80089b02a28cf06f9093843986f3d"},
+    {file = "pydot-3.0.3.tar.gz", hash = "sha256:5e009d97b2fff92b7a88f09ec1fd5b163f07f3b10469c927d362471d6faa0d50"},
 ]
 
 [package.dependencies]
@@ -8304,4 +8335,4 @@ type = ["pytest-mypy"]
 [metadata]
 lock-version = "2.0"
 python-versions = "3.12.6"
-content-hash = "299ab47cb12e9587df06bf93a23ddd51418ed509b6c90d2d13ba35a8cdf7754b"
+content-hash = "ce5c192bdc9f69e1c6fa059963bee1111580cd1665739f1453e9c2a4f8c2ee3a"

pyproject.toml

@@ -74,6 +74,9 @@ gpustat = "^1.1.1"
 nvitop = "^1.3.2"
 gradio = "5.7.1"
 gradio-client = "^1.5.0"
+accelerate = "^1.1.1"
+pyopenssl = "<23.0.0"
+cryptography = "^44.0.0"
 
 [tool.poetry.dev-dependencies]
 pytest-asyncio = "^0.20.3"

requirements.txt

@@ -0,0 +1,3 @@
+gradio
+transformers
+torch