#!/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[ ]: