Upload Gradio Examples.py

Gradio Examples.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# #### Gradio Comparing Transfer Learning Models
+
+# In[1]:
+
+
+import tensorflow as tf
+print(tf.__version__)
+
+
+# In[2]:
+
+
+pip install gradio==1.6.0
+
+
+# In[3]:
+
+
+pip install MarkupSafe==2.1.1
+
+
+# In[1]:
+
+
+import gradio as gr
+import tensorflow as tf
+import numpy as np
+from PIL import Image
+import requests
+
+
+# Download human-readable labels for ImageNet.
+response = requests.get("https://git.io/JJkYN")
+labels = response.text.split("\n")
+
+mobile_net = tf.keras.applications.MobileNetV2()
+inception_net = tf.keras.applications.InceptionV3()
+
+
+# In[2]:
+
+
+def classify_image_with_mobile_net(im):
+    im = Image.fromarray(im.astype('uint8'), 'RGB')
+    im = im.resize((224, 224))
+    arr = np.array(im).reshape((-1, 224, 224, 3))
+    arr = tf.keras.applications.mobilenet.preprocess_input(arr)
+    prediction = mobile_net.predict(arr).flatten()
+    return {labels[i]: float(prediction[i]) for i in range(1000)}
+    
+
+
+# In[3]:
+
+
+def classify_image_with_inception_net(im):
+    # Resize the image to
+    im = Image.fromarray(im.astype('uint8'), 'RGB')
+    im = im.resize((299, 299))
+    arr = np.array(im).reshape((-1, 299, 299, 3))
+    arr = tf.keras.applications.inception_v3.preprocess_input(arr)
+    prediction = inception_net.predict(arr).flatten()
+    return {labels[i]: float(prediction[i]) for i in range(1000)}
+
+
+# In[4]:
+
+
+imagein = gr.inputs.Image()
+label = gr.outputs.Label(num_top_classes=3)
+sample_images = [
+                 ["monkey.jpg"],
+                 ["sailboat.jpg"],
+                 ["bicycle.jpg"],
+                 ["download.jpg"],
+]
+
+
+# In[6]:
+
+
+gr.Interface(
+    [classify_image_with_mobile_net, classify_image_with_inception_net],
+    imagein,
+    label,
+    title="MobileNet vs. InceptionNet",
+    description="""Let's compare 2 state-of-the-art machine learning models that classify images into one of 1,000 categories: MobileNet (top),
+          a lightweight model that has an accuracy of 0.704, vs. InceptionNet
+          (bottom), a much heavier model that has an accuracy of 0.779.""",
+    examples=sample_images).launch()
+
+
+# In[6]:
+
+
+pip install transformers
+
+
+# In[6]:
+
+
+import gradio as gr
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+# Load the models and tokenizers
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+tokenizer1 = AutoTokenizer.from_pretrained("textattack/bert-base-uncased-imdb")
+tokenizer2 = AutoTokenizer.from_pretrained("nlptown/bert-base-multilingual-uncased-sentiment")
+model1 = AutoModelForSequenceClassification.from_pretrained("textattack/bert-base-uncased-imdb")
+model2 = AutoModelForSequenceClassification.from_pretrained("nlptown/bert-base-multilingual-uncased-sentiment")
+
+
+
+
+# Define the sentiment prediction functions
+def predict_sentiment(text):
+    # Predict sentiment using model 1
+    inputs1 = tokenizer1.encode_plus(text, padding="longest", truncation=True, return_tensors="pt")
+    outputs1 = model1(**inputs1)
+    predicted_label1 = outputs1.logits.argmax().item()
+    sentiment1 = "Positive" if predicted_label1 == 1 else "Negative" if predicted_label1 == 0 else "Neutral"
+
+    # Predict sentiment using model 2
+    inputs2 = tokenizer2.encode_plus(text, padding="longest", truncation=True, return_tensors="pt")
+    outputs2 = model2(**inputs2)
+    predicted_label2 = outputs2.logits.argmax().item()
+    sentiment2 = "Positive" if predicted_label2 == 1 else "Negative" if predicted_label2 == 0 else "Neutral"
+
+    return sentiment1, sentiment2
+
+# Create the Gradio interface
+iface = gr.Interface(
+    fn=predict_sentiment,
+    inputs="text",
+    outputs=["text", "text"],
+    title="Sentiment Analysis (Model 1 vs Model 2)",
+    description="Compare sentiment predictions from two models.",
+)
+
+# Launch the interface
+iface.launch()
+
+
+# In[17]:
+
+
+import gradio as gr
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import torch
+from torchvision import transforms
+from io import BytesIO
+from PIL import Image
+
+# Define the available models and datasets
+models = {
+    "Model 1": {
+        "model_name": "bert-base-uncased",
+        "tokenizer": None,
+        "model": None
+    },
+    "Model 2": {
+        "model_name": "distilbert-base-uncased",
+        "tokenizer": None,
+        "model": None
+    },
+    # Add more models as needed
+}
+
+datasets = {
+    "Dataset 1": {
+        "name": "imdb",
+        "split": "test",
+        "features": ["text"],
+    },
+    "Dataset 2": {
+        "name": "ag_news",
+        "split": "test",
+        "features": ["text"],
+    },
+    # Add more datasets as needed
+}
+
+# Load models
+for model_key, model_info in models.items():
+    tokenizer = AutoTokenizer.from_pretrained(model_info["model_name"])
+    model = AutoModelForSequenceClassification.from_pretrained(model_info["model_name"])
+    model_info["tokenizer"] = tokenizer
+    model_info["model"] = model
+
+# Set the device to GPU if available
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+for model_info in models.values():
+    model_info["model"].to(device)
+
+# Define the preprocessing function
+def preprocess(image_file):
+    image = Image.open(BytesIO(image_file.read())).convert("RGB")
+    preprocess_transform = transforms.Compose([
+        transforms.Resize((224, 224)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+    ])
+    image = preprocess_transform(image)
+    image = image.unsqueeze(0)
+    return image.to(device)
+
+# Define the prediction function
+def predict(image_file, model_key):
+    model_info = models[model_key]
+    tokenizer = model_info["tokenizer"]
+    model = model_info["model"]
+
+    image = preprocess(image_file)
+
+    with torch.no_grad():
+        outputs = model(image)
+
+    predictions = outputs.logits.argmax(dim=1)
+
+    return predictions.item()
+
+def classify_image(image, model_key):
+    image = Image.fromarray(image.astype('uint8'), 'RGB')
+    image_file = BytesIO()
+    image.save(image_file, format="JPEG")
+    prediction = predict(image_file=image_file, model_key=model_key)
+    return prediction
+
+iface = gr.Interface(fn=classify_image,
+                     inputs=["image", gr.inputs.Dropdown(list(models.keys()), label="Model")],
+                     outputs="text",
+                     title="Image Classification",
+                     description="Classify images using Hugging Face models")
+
+iface.launch()
+
+
+# In[ ]:
+
+
+
+