Upload 20 files

age_classification.py

@@ -0,0 +1,45 @@
+import gradio as gr
+from transformers import AutoImageProcessor
+from transformers import SiglipForImageClassification
+from transformers.image_utils import load_image
+from PIL import Image
+import torch
+
+# Load model and processor
+model_name = "prithivMLmods/Age-Classification-SigLIP2"
+model = SiglipForImageClassification.from_pretrained(model_name)
+processor = AutoImageProcessor.from_pretrained(model_name)
+
+def age_classification(image):
+    """Predicts the age group of a person from an image."""
+    image = Image.fromarray(image).convert("RGB")
+    inputs = processor(images=image, return_tensors="pt")
+    
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+        probs = torch.nn.functional.softmax(logits, dim=1).squeeze().tolist()
+    
+    labels = {
+        "0": "Child 0-12", 
+        "1": "Teenager 13-20", 
+        "2": "Adult 21-44", 
+        "3": "Middle Age 45-64", 
+        "4": "Aged 65+"
+    }
+    predictions = {labels[str(i)]: round(probs[i], 3) for i in range(len(probs))}
+    
+    return predictions
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=age_classification,
+    inputs=gr.Image(type="numpy"),
+    outputs=gr.Label(label="Prediction Scores"),
+    title="Age Group Classification",
+    description="Upload an image to predict the person's age group."
+)
+
+# Launch the app
+if __name__ == "__main__":
+    iface.launch()

alphabet_sign_language_detection.py

@@ -0,0 +1,43 @@
+import gradio as gr
+from transformers import AutoImageProcessor
+from transformers import SiglipForImageClassification
+from transformers.image_utils import load_image
+from PIL import Image
+import torch
+
+# Load model and processor
+model_name = "prithivMLmods/Alphabet-Sign-Language-Detection"
+model = SiglipForImageClassification.from_pretrained(model_name)
+processor = AutoImageProcessor.from_pretrained(model_name)
+
+def sign_language_classification(image):
+    """Predicts sign language alphabet category for an image."""
+    image = Image.fromarray(image).convert("RGB")
+    inputs = processor(images=image, return_tensors="pt")
+    
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+        probs = torch.nn.functional.softmax(logits, dim=1).squeeze().tolist()
+    
+    labels = {
+        "0": "A", "1": "B", "2": "C", "3": "D", "4": "E", "5": "F", "6": "G", "7": "H", "8": "I", "9": "J",
+        "10": "K", "11": "L", "12": "M", "13": "N", "14": "O", "15": "P", "16": "Q", "17": "R", "18": "S", "19": "T",
+        "20": "U", "21": "V", "22": "W", "23": "X", "24": "Y", "25": "Z"
+    }
+    predictions = {labels[str(i)]: round(probs[i], 3) for i in range(len(probs))}
+    
+    return predictions
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=sign_language_classification,
+    inputs=gr.Image(type="numpy"),
+    outputs=gr.Label(label="Prediction Scores"),
+    title="Alphabet Sign Language Detection",
+    description="Upload an image to classify it into one of the 26 sign language alphabet categories."
+)
+
+# Launch the app
+if __name__ == "__main__":
+    iface.launch()

app.py

@@ -0,0 +1,180 @@
+import gradio as gr
+import torch
+from transformers import AutoModel, AutoProcessor
+
+from gender_classification import gender_classification
+from emotion_classification import emotion_classification
+from dog_breed import dog_breed_classification
+from deepfake_quality import deepfake_classification
+from gym_workout_classification import workout_classification
+from augmented_waste_classifier import waste_classification
+from age_classification import age_classification
+from mnist_digits import classify_digit
+from fashion_mnist_cloth import fashion_mnist_classification
+from indian_western_food_classify import food_classification
+from bird_species import bird_classification
+from alphabet_sign_language_detection import sign_language_classification
+from rice_leaf_disease import classify_leaf_disease
+from traffic_density import traffic_density_classification
+from clip_art import clipart_classification
+from multisource_121 import multisource_classification
+from painting_126 import painting_classification
+from sketch_126 import sketch_classification  # New import
+
+# Main classification function for multi-model classification.
+def classify(image, model_name):
+    if model_name == "gender":
+        return gender_classification(image)
+    elif model_name == "emotion":
+        return emotion_classification(image)
+    elif model_name == "dog breed":
+        return dog_breed_classification(image)
+    elif model_name == "deepfake":
+        return deepfake_classification(image)
+    elif model_name == "gym workout":
+        return workout_classification(image)
+    elif model_name == "waste":
+        return waste_classification(image)
+    elif model_name == "age":
+        return age_classification(image)
+    elif model_name == "mnist":
+        return classify_digit(image)
+    elif model_name == "fashion_mnist":
+        return fashion_mnist_classification(image)
+    elif model_name == "food":
+        return food_classification(image)
+    elif model_name == "bird":
+        return bird_classification(image)
+    elif model_name == "leaf disease":
+        return classify_leaf_disease(image)
+    elif model_name == "sign language":
+        return sign_language_classification(image)
+    elif model_name == "traffic density":
+        return traffic_density_classification(image)
+    elif model_name == "clip art":
+        return clipart_classification(image)
+    elif model_name == "multisource":
+        return multisource_classification(image)
+    elif model_name == "painting":
+        return painting_classification(image)
+    elif model_name == "sketch":  # New option
+        return sketch_classification(image)
+    else:
+        return {"Error": "No model selected"}
+
+# Function to update the selected model and button styles.
+def select_model(model_name):
+    model_variants = {
+        "gender": "secondary", "emotion": "secondary", "dog breed": "secondary", "deepfake": "secondary",
+        "gym workout": "secondary", "waste": "secondary", "age": "secondary", "mnist": "secondary",
+        "fashion_mnist": "secondary", "food": "secondary", "bird": "secondary", "leaf disease": "secondary",
+        "sign language": "secondary", "traffic density": "secondary", "clip art": "secondary",
+        "multisource": "secondary", "painting": "secondary", "sketch": "secondary"  # New model variant
+    }
+    model_variants[model_name] = "primary"
+    return (model_name, *(gr.update(variant=model_variants[key]) for key in model_variants))
+
+# Zero-Shot Classification Setup (SigLIP models)
+sg1_ckpt = "google/siglip-so400m-patch14-384"
+siglip1_model = AutoModel.from_pretrained(sg1_ckpt, device_map="cpu").eval()
+siglip1_processor = AutoProcessor.from_pretrained(sg1_ckpt)
+
+sg2_ckpt = "google/siglip2-so400m-patch14-384"
+siglip2_model = AutoModel.from_pretrained(sg2_ckpt, device_map="cpu").eval()
+siglip2_processor = AutoProcessor.from_pretrained(sg2_ckpt)
+
+def postprocess_siglip(sg1_probs, sg2_probs, labels):
+    sg1_output = {labels[i]: sg1_probs[0][i].item() for i in range(len(labels))}
+    sg2_output = {labels[i]: sg2_probs[0][i].item() for i in range(len(labels))}
+    return sg1_output, sg2_output
+
+def siglip_detector(image, texts):
+    sg1_inputs = siglip1_processor(
+        text=texts, images=image, return_tensors="pt", padding="max_length", max_length=64
+    ).to("cpu")
+    sg2_inputs = siglip2_processor(
+        text=texts, images=image, return_tensors="pt", padding="max_length", max_length=64
+    ).to("cpu")
+    with torch.no_grad():
+        sg1_outputs = siglip1_model(**sg1_inputs)
+        sg2_outputs = siglip2_model(**sg2_inputs)
+        sg1_logits_per_image = sg1_outputs.logits_per_image
+        sg2_logits_per_image = sg2_outputs.logits_per_image
+        sg1_probs = torch.sigmoid(sg1_logits_per_image)
+        sg2_probs = torch.sigmoid(sg2_logits_per_image)
+    return sg1_probs, sg2_probs
+
+def infer(image, candidate_labels):
+    candidate_labels = [label.lstrip(" ") for label in candidate_labels.split(",")]
+    sg1_probs, sg2_probs = siglip_detector(image, candidate_labels)
+    return postprocess_siglip(sg1_probs, sg2_probs, labels=candidate_labels)
+
+# Build the Gradio Interface with two tabs.
+with gr.Blocks(theme="YTheme/Minecraft") as demo:
+    gr.Markdown("# Multi-Domain & Zero-Shot Image Classification")
+    
+    with gr.Tabs():
+        # Tab 1: Multi-Model Classification
+        with gr.Tab("Multi-Domain Classification"):
+            with gr.Sidebar():
+                gr.Markdown("# Choose Domain")
+                with gr.Row():
+                    age_btn = gr.Button("Age Classification", variant="primary")
+                    gender_btn = gr.Button("Gender Classification", variant="secondary")
+                    emotion_btn = gr.Button("Emotion Classification", variant="secondary")
+                    gym_workout_btn = gr.Button("Gym Workout Classification", variant="secondary")
+                    dog_breed_btn = gr.Button("Dog Breed Classification", variant="secondary")
+                    bird_btn = gr.Button("Bird Species Classification", variant="secondary")
+                    waste_btn = gr.Button("Waste Classification", variant="secondary")
+                    deepfake_btn = gr.Button("Deepfake Quality Test", variant="secondary")
+                    traffic_density_btn = gr.Button("Traffic Density", variant="secondary")
+                    sign_language_btn = gr.Button("Alphabet Sign Language", variant="secondary")
+                    clip_art_btn = gr.Button("Clip Art 126", variant="secondary")
+                    mnist_btn = gr.Button("Digit Classify (0-9)", variant="secondary")
+                    fashion_mnist_btn = gr.Button("Fashion MNIST (only cloth)", variant="secondary")
+                    food_btn = gr.Button("Indian/Western Food Type", variant="secondary")
+                    leaf_disease_btn = gr.Button("Rice Leaf Disease", variant="secondary")
+                    multisource_btn = gr.Button("Multi Source 121", variant="secondary")
+                    painting_btn = gr.Button("Painting 126", variant="secondary")
+                    sketch_btn = gr.Button("Sketch 126", variant="secondary")
+                    
+                selected_model = gr.State("age")
+                gr.Markdown("### Current Model:")
+                model_display = gr.Textbox(value="age", interactive=False)
+                selected_model.change(lambda m: m, selected_model, model_display)
+
+                buttons = [
+                    gender_btn, emotion_btn, dog_breed_btn, deepfake_btn, gym_workout_btn, waste_btn,
+                    age_btn, mnist_btn, fashion_mnist_btn, food_btn, bird_btn, leaf_disease_btn,
+                    sign_language_btn, traffic_density_btn, clip_art_btn, multisource_btn, painting_btn, sketch_btn  # Include new button
+                ]
+                model_names = [
+                    "gender", "emotion", "dog breed", "deepfake", "gym workout", "waste",
+                    "age", "mnist", "fashion_mnist", "food", "bird", "leaf disease",
+                    "sign language", "traffic density", "clip art", "multisource", "painting", "sketch"  # New model name
+                ]
+
+                for btn, name in zip(buttons, model_names):
+                    btn.click(fn=lambda n=name: select_model(n), inputs=[], outputs=[selected_model] + buttons)
+
+            with gr.Row():
+                with gr.Column():
+                    image_input = gr.Image(type="numpy", label="Upload Image")
+                    analyze_btn = gr.Button("Classify / Predict")
+                output_label = gr.Label(label="Prediction Scores")
+                analyze_btn.click(fn=classify, inputs=[image_input, selected_model], outputs=output_label)
+        
+        # Tab 2: Zero-Shot Classification (SigLIP)
+        with gr.Tab("Zero-Shot Classification"):
+            gr.Markdown("## Compare SigLIP 1 and SigLIP 2 on Zero-Shot Classification")
+            with gr.Row():
+                with gr.Column():
+                    zs_image_input = gr.Image(type="pil", label="Upload Image")
+                    zs_text_input = gr.Textbox(label="Input a list of labels (comma separated)")
+                    zs_run_button = gr.Button("Run")
+                with gr.Column():
+                    siglip1_output = gr.Label(label="SigLIP 1 Output", num_top_classes=3)
+                    siglip2_output = gr.Label(label="SigLIP 2 Output", num_top_classes=3)
+            zs_run_button.click(fn=infer, inputs=[zs_image_input, zs_text_input], outputs=[siglip1_output, siglip2_output])
+
+demo.launch()

augmented_waste_classifier.py

@@ -0,0 +1,43 @@
+import gradio as gr
+from transformers import AutoImageProcessor
+from transformers import SiglipForImageClassification
+from transformers.image_utils import load_image
+from PIL import Image
+import torch
+
+# Load model and processor
+model_name = "prithivMLmods/Augmented-Waste-Classifier-SigLIP2"
+model = SiglipForImageClassification.from_pretrained(model_name)
+processor = AutoImageProcessor.from_pretrained(model_name)
+
+def waste_classification(image):
+    """Predicts waste classification for an image."""
+    image = Image.fromarray(image).convert("RGB")
+    inputs = processor(images=image, return_tensors="pt")
+    
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+        probs = torch.nn.functional.softmax(logits, dim=1).squeeze().tolist()
+    
+    labels = {
+        "0": "Battery", "1": "Biological", "2": "Cardboard", "3": "Clothes", 
+        "4": "Glass", "5": "Metal", "6": "Paper", "7": "Plastic", 
+        "8": "Shoes", "9": "Trash"
+    }
+    predictions = {labels[str(i)]: round(probs[i], 3) for i in range(len(probs))}
+    
+    return predictions
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=waste_classification,
+    inputs=gr.Image(type="numpy"),
+    outputs=gr.Label(label="Prediction Scores"),
+    title="Augmented Waste Classification",
+    description="Upload an image to classify the type of waste."
+)
+
+# Launch the app
+if __name__ == "__main__":
+    iface.launch()

bird_species.py

@@ -0,0 +1,564 @@
+import gradio as gr
+from transformers import AutoImageProcessor
+from transformers import SiglipForImageClassification
+from PIL import Image
+import torch
+
+# Load model and processor with the new bird classifier name
+model_name = "prithivMLmods/Bird-Species-Classifier-526"
+model = SiglipForImageClassification.from_pretrained(model_name)
+processor = AutoImageProcessor.from_pretrained(model_name)
+
+def bird_classification(image):
+    """Predicts bird species classification for an image."""
+    image = Image.fromarray(image).convert("RGB")
+    inputs = processor(images=image, return_tensors="pt")
+    
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+        probs = torch.nn.functional.softmax(logits, dim=1).squeeze().tolist()
+    
+    labels = {
+        "0": "ABBOTTS BABBLER",
+        "1": "ABBOTTS BOOBY",
+        "2": "ABYSSINIAN GROUND HORNBILL",
+        "3": "AFRICAN CROWNED CRANE",
+        "4": "AFRICAN EMERALD CUCKOO",
+        "5": "AFRICAN FIREFINCH",
+        "6": "AFRICAN OYSTER CATCHER",
+        "7": "AFRICAN PIED HORNBILL",
+        "8": "AFRICAN PYGMY GOOSE",
+        "9": "ALBATROSS",
+        "10": "ALBERTS TOWHEE",
+        "11": "ALEXANDRINE PARAKEET",
+        "12": "ALPINE CHOUGH",
+        "13": "ALTAMIRA YELLOWTHROAT",
+        "14": "AMERICAN AVOCET",
+        "15": "AMERICAN BITTERN",
+        "16": "AMERICAN COOT",
+        "17": "AMERICAN DIPPER",
+        "18": "AMERICAN FLAMINGO",
+        "19": "AMERICAN GOLDFINCH",
+        "20": "AMERICAN KESTREL",
+        "21": "AMERICAN PIPIT",
+        "22": "AMERICAN REDSTART",
+        "23": "AMERICAN ROBIN",
+        "24": "AMERICAN WIGEON",
+        "25": "AMETHYST WOODSTAR",
+        "26": "ANDEAN GOOSE",
+        "27": "ANDEAN LAPWING",
+        "28": "ANDEAN SISKIN",
+        "29": "ANHINGA",
+        "30": "ANIANIAU",
+        "31": "ANNAS HUMMINGBIRD",
+        "32": "ANTBIRD",
+        "33": "ANTILLEAN EUPHONIA",
+        "34": "APAPANE",
+        "35": "APOSTLEBIRD",
+        "36": "ARARIPE MANAKIN",
+        "37": "ASHY STORM PETREL",
+        "38": "ASHY THRUSHBIRD",
+        "39": "ASIAN CRESTED IBIS",
+        "40": "ASIAN DOLLARD BIRD",
+        "41": "ASIAN GREEN BEE EATER",
+        "42": "ASIAN OPENBILL STORK",
+        "43": "AUCKLAND SHAQ",
+        "44": "AUSTRAL CANASTERO",
+        "45": "AUSTRALASIAN FIGBIRD",
+        "46": "AVADAVAT",
+        "47": "AZARAS SPINETAIL",
+        "48": "AZURE BREASTED PITTA",
+        "49": "AZURE JAY",
+        "50": "AZURE TANAGER",
+        "51": "AZURE TIT",
+        "52": "BAIKAL TEAL",
+        "53": "BALD EAGLE",
+        "54": "BALD IBIS",
+        "55": "BALI STARLING",
+        "56": "BALTIMORE ORIOLE",
+        "57": "BANANAQUIT",
+        "58": "BAND TAILED GUAN",
+        "59": "BANDED BROADBILL",
+        "60": "BANDED PITA",
+        "61": "BANDED STILT",
+        "62": "BAR-TAILED GODWIT",
+        "63": "BARN OWL",
+        "64": "BARN SWALLOW",
+        "65": "BARRED PUFFBIRD",
+        "66": "BARROWS GOLDENEYE",
+        "67": "BAY-BREASTED WARBLER",
+        "68": "BEARDED BARBET",
+        "69": "BEARDED BELLBIRD",
+        "70": "BEARDED REEDLING",
+        "71": "BELTED KINGFISHER",
+        "72": "BIRD OF PARADISE",
+        "73": "BLACK AND YELLOW BROADBILL",
+        "74": "BLACK BAZA",
+        "75": "BLACK BREASTED PUFFBIRD",
+        "76": "BLACK COCKATO",
+        "77": "BLACK FACED SPOONBILL",
+        "78": "BLACK FRANCOLIN",
+        "79": "BLACK HEADED CAIQUE",
+        "80": "BLACK NECKED STILT",
+        "81": "BLACK SKIMMER",
+        "82": "BLACK SWAN",
+        "83": "BLACK TAIL CRAKE",
+        "84": "BLACK THROATED BUSHTIT",
+        "85": "BLACK THROATED HUET",
+        "86": "BLACK THROATED WARBLER",
+        "87": "BLACK VENTED SHEARWATER",
+        "88": "BLACK VULTURE",
+        "89": "BLACK-CAPPED CHICKADEE",
+        "90": "BLACK-NECKED GREBE",
+        "91": "BLACK-THROATED SPARROW",
+        "92": "BLACKBURNIAM WARBLER",
+        "93": "BLONDE CRESTED WOODPECKER",
+        "94": "BLOOD PHEASANT",
+        "95": "BLUE COAU",
+        "96": "BLUE DACNIS",
+        "97": "BLUE GRAY GNATCATCHER",
+        "98": "BLUE GROSBEAK",
+        "99": "BLUE GROUSE",
+        "100": "BLUE HERON",
+        "101": "BLUE MALKOHA",
+        "102": "BLUE THROATED PIPING GUAN",
+        "103": "BLUE THROATED TOUCANET",
+        "104": "BOBOLINK",
+        "105": "BORNEAN BRISTLEHEAD",
+        "106": "BORNEAN LEAFBIRD",
+        "107": "BORNEAN PHEASANT",
+        "108": "BRANDT CORMARANT",
+        "109": "BREWERS BLACKBIRD",
+        "110": "BROWN CREPPER",
+        "111": "BROWN HEADED COWBIRD",
+        "112": "BROWN NOODY",
+        "113": "BROWN THRASHER",
+        "114": "BUFFLEHEAD",
+        "115": "BULWERS PHEASANT",
+        "116": "BURCHELLS COURSER",
+        "117": "BUSH TURKEY",
+        "118": "CAATINGA CACHOLOTE",
+        "119": "CABOTS TRAGOPAN",
+        "120": "CACTUS WREN",
+        "121": "CALIFORNIA CONDOR",
+        "122": "CALIFORNIA GULL",
+        "123": "CALIFORNIA QUAIL",
+        "124": "CAMPO FLICKER",
+        "125": "CANARY",
+        "126": "CANVASBACK",
+        "127": "CAPE GLOSSY STARLING",
+        "128": "CAPE LONGCLAW",
+        "129": "CAPE MAY WARBLER",
+        "130": "CAPE ROCK THRUSH",
+        "131": "CAPPED HERON",
+        "132": "CAPUCHINBIRD",
+        "133": "CARMINE BEE-EATER",
+        "134": "CASPIAN TERN",
+        "135": "CASSOWARY",
+        "136": "CEDAR WAXWING",
+        "137": "CERULEAN WARBLER",
+        "138": "CHARA DE COLLAR",
+        "139": "CHATTERING LORY",
+        "140": "CHESTNET BELLIED EUPHONIA",
+        "141": "CHESTNUT WINGED CUCKOO",
+        "142": "CHINESE BAMBOO PARTRIDGE",
+        "143": "CHINESE POND HERON",
+        "144": "CHIPPING SPARROW",
+        "145": "CHUCAO TAPACULO",
+        "146": "CHUKAR PARTRIDGE",
+        "147": "CINNAMON ATTILA",
+        "148": "CINNAMON FLYCATCHER",
+        "149": "CINNAMON TEAL",
+        "150": "CLARKS GREBE",
+        "151": "CLARKS NUTCRACKER",
+        "152": "COCK OF THE  ROCK",
+        "153": "COCKATOO",
+        "154": "COLLARED ARACARI",
+        "155": "COLLARED CRESCENTCHEST",
+        "156": "COMMON FIRECREST",
+        "157": "COMMON GRACKLE",
+        "158": "COMMON HOUSE MARTIN",
+        "159": "COMMON IORA",
+        "160": "COMMON LOON",
+        "161": "COMMON POORWILL",
+        "162": "COMMON STARLING",
+        "163": "COPPERSMITH BARBET",
+        "164": "COPPERY TAILED COUCAL",
+        "165": "CRAB PLOVER",
+        "166": "CRANE HAWK",
+        "167": "CREAM COLORED WOODPECKER",
+        "168": "CRESTED AUKLET",
+        "169": "CRESTED CARACARA",
+        "170": "CRESTED COUA",
+        "171": "CRESTED FIREBACK",
+        "172": "CRESTED KINGFISHER",
+        "173": "CRESTED NUTHATCH",
+        "174": "CRESTED OROPENDOLA",
+        "175": "CRESTED SERPENT EAGLE",
+        "176": "CRESTED SHRIKETIT",
+        "177": "CRESTED WOOD PARTRIDGE",
+        "178": "CRIMSON CHAT",
+        "179": "CRIMSON SUNBIRD",
+        "180": "CROW",
+        "181": "CUBAN TODY",
+        "182": "CUBAN TROGON",
+        "183": "CURL CRESTED ARACURI",
+        "184": "D-ARNAUDS BARBET",
+        "185": "DALMATIAN PELICAN",
+        "186": "DARJEELING WOODPECKER",
+        "187": "DARK EYED JUNCO",
+        "188": "DAURIAN REDSTART",
+        "189": "DEMOISELLE CRANE",
+        "190": "DOUBLE BARRED FINCH",
+        "191": "DOUBLE BRESTED CORMARANT",
+        "192": "DOUBLE EYED FIG PARROT",
+        "193": "DOWNY WOODPECKER",
+        "194": "DUNLIN",
+        "195": "DUSKY LORY",
+        "196": "DUSKY ROBIN",
+        "197": "EARED PITA",
+        "198": "EASTERN BLUEBIRD",
+        "199": "EASTERN BLUEBONNET",
+        "200": "EASTERN GOLDEN WEAVER",
+        "201": "EASTERN MEADOWLARK",
+        "202": "EASTERN ROSELLA",
+        "203": "EASTERN TOWEE",
+        "204": "EASTERN WIP POOR WILL",
+        "205": "EASTERN YELLOW ROBIN",
+        "206": "ECUADORIAN HILLSTAR",
+        "207": "EGYPTIAN GOOSE",
+        "208": "ELEGANT TROGON",
+        "209": "ELLIOTS  PHEASANT",
+        "210": "EMERALD TANAGER",
+        "211": "EMPEROR PENGUIN",
+        "212": "EMU",
+        "213": "ENGGANO MYNA",
+        "214": "EURASIAN BULLFINCH",
+        "215": "EURASIAN GOLDEN ORIOLE",
+        "216": "EURASIAN MAGPIE",
+        "217": "EUROPEAN GOLDFINCH",
+        "218": "EUROPEAN TURTLE DOVE",
+        "219": "EVENING GROSBEAK",
+        "220": "FAIRY BLUEBIRD",
+        "221": "FAIRY PENGUIN",
+        "222": "FAIRY TERN",
+        "223": "FAN TAILED WIDOW",
+        "224": "FASCIATED WREN",
+        "225": "FIERY MINIVET",
+        "226": "FIORDLAND PENGUIN",
+        "227": "FIRE TAILLED MYZORNIS",
+        "228": "FLAME BOWERBIRD",
+        "229": "FLAME TANAGER",
+        "230": "FOREST WAGTAIL",
+        "231": "FRIGATE",
+        "232": "FRILL BACK PIGEON",
+        "233": "GAMBELS QUAIL",
+        "234": "GANG GANG COCKATOO",
+        "235": "GILA WOODPECKER",
+        "236": "GILDED FLICKER",
+        "237": "GLOSSY IBIS",
+        "238": "GO AWAY BIRD",
+        "239": "GOLD WING WARBLER",
+        "240": "GOLDEN BOWER BIRD",
+        "241": "GOLDEN CHEEKED WARBLER",
+        "242": "GOLDEN CHLOROPHONIA",
+        "243": "GOLDEN EAGLE",
+        "244": "GOLDEN PARAKEET",
+        "245": "GOLDEN PHEASANT",
+        "246": "GOLDEN PIPIT",
+        "247": "GOULDIAN FINCH",
+        "248": "GRANDALA",
+        "249": "GRAY CATBIRD",
+        "250": "GRAY KINGBIRD",
+        "251": "GRAY PARTRIDGE",
+        "252": "GREAT ARGUS",
+        "253": "GREAT GRAY OWL",
+        "254": "GREAT JACAMAR",
+        "255": "GREAT KISKADEE",
+        "256": "GREAT POTOO",
+        "257": "GREAT TINAMOU",
+        "258": "GREAT XENOPS",
+        "259": "GREATER PEWEE",
+        "260": "GREATER PRAIRIE CHICKEN",
+        "261": "GREATOR SAGE GROUSE",
+        "262": "GREEN BROADBILL",
+        "263": "GREEN JAY",
+        "264": "GREEN MAGPIE",
+        "265": "GREEN WINGED DOVE",
+        "266": "GREY CUCKOOSHRIKE",
+        "267": "GREY HEADED CHACHALACA",
+        "268": "GREY HEADED FISH EAGLE",
+        "269": "GREY PLOVER",
+        "270": "GROVED BILLED ANI",
+        "271": "GUINEA TURACO",
+        "272": "GUINEAFOWL",
+        "273": "GURNEYS PITTA",
+        "274": "GYRFALCON",
+        "275": "HAMERKOP",
+        "276": "HARLEQUIN DUCK",
+        "277": "HARLEQUIN QUAIL",
+        "278": "HARPY EAGLE",
+        "279": "HAWAIIAN GOOSE",
+        "280": "HAWFINCH",
+        "281": "HELMET VANGA",
+        "282": "HEPATIC TANAGER",
+        "283": "HIMALAYAN BLUETAIL",
+        "284": "HIMALAYAN MONAL",
+        "285": "HOATZIN",
+        "286": "HOODED MERGANSER",
+        "287": "HOOPOES",
+        "288": "HORNED GUAN",
+        "289": "HORNED LARK",
+        "290": "HORNED SUNGEM",
+        "291": "HOUSE FINCH",
+        "292": "HOUSE SPARROW",
+        "293": "HYACINTH MACAW",
+        "294": "IBERIAN MAGPIE",
+        "295": "IBISBILL",
+        "296": "IMPERIAL SHAQ",
+        "297": "INCA TERN",
+        "298": "INDIAN BUSTARD",
+        "299": "INDIAN PITTA",
+        "300": "INDIAN ROLLER",
+        "301": "INDIAN VULTURE",
+        "302": "INDIGO BUNTING",
+        "303": "INDIGO FLYCATCHER",
+        "304": "INLAND DOTTEREL",
+        "305": "IVORY BILLED ARACARI",
+        "306": "IVORY GULL",
+        "307": "IWI",
+        "308": "JABIRU",
+        "309": "JACK SNIPE",
+        "310": "JACOBIN PIGEON",
+        "311": "JANDAYA PARAKEET",
+        "312": "JAPANESE ROBIN",
+        "313": "JAVA SPARROW",
+        "314": "JOCOTOCO ANTPITTA",
+        "315": "KAGU",
+        "316": "KAKAPO",
+        "317": "KILLDEAR",
+        "318": "KING EIDER",
+        "319": "KING VULTURE",
+        "320": "KIWI",
+        "321": "KNOB BILLED DUCK",
+        "322": "KOOKABURRA",
+        "323": "LARK BUNTING",
+        "324": "LAUGHING GULL",
+        "325": "LAZULI BUNTING",
+        "326": "LESSER ADJUTANT",
+        "327": "LILAC ROLLER",
+        "328": "LIMPKIN",
+        "329": "LITTLE AUK",
+        "330": "LOGGERHEAD SHRIKE",
+        "331": "LONG-EARED OWL",
+        "332": "LOONEY BIRDS",
+        "333": "LUCIFER HUMMINGBIRD",
+        "334": "MAGPIE GOOSE",
+        "335": "MALABAR HORNBILL",
+        "336": "MALACHITE KINGFISHER",
+        "337": "MALAGASY WHITE EYE",
+        "338": "MALEO",
+        "339": "MALLARD DUCK",
+        "340": "MANDRIN DUCK",
+        "341": "MANGROVE CUCKOO",
+        "342": "MARABOU STORK",
+        "343": "MASKED BOBWHITE",
+        "344": "MASKED BOOBY",
+        "345": "MASKED LAPWING",
+        "346": "MCKAYS BUNTING",
+        "347": "MERLIN",
+        "348": "MIKADO  PHEASANT",
+        "349": "MILITARY MACAW",
+        "350": "MOURNING DOVE",
+        "351": "MYNA",
+        "352": "NICOBAR PIGEON",
+        "353": "NOISY FRIARBIRD",
+        "354": "NORTHERN BEARDLESS TYRANNULET",
+        "355": "NORTHERN CARDINAL",
+        "356": "NORTHERN FLICKER",
+        "357": "NORTHERN FULMAR",
+        "358": "NORTHERN GANNET",
+        "359": "NORTHERN GOSHAWK",
+        "360": "NORTHERN JACANA",
+        "361": "NORTHERN MOCKINGBIRD",
+        "362": "NORTHERN PARULA",
+        "363": "NORTHERN RED BISHOP",
+        "364": "NORTHERN SHOVELER",
+        "365": "OCELLATED TURKEY",
+        "366": "OILBIRD",
+        "367": "OKINAWA RAIL",
+        "368": "ORANGE BREASTED TROGON",
+        "369": "ORANGE BRESTED BUNTING",
+        "370": "ORIENTAL BAY OWL",
+        "371": "ORNATE HAWK EAGLE",
+        "372": "OSPREY",
+        "373": "OSTRICH",
+        "374": "OVENBIRD",
+        "375": "OYSTER CATCHER",
+        "376": "PAINTED BUNTING",
+        "377": "PALILA",
+        "378": "PALM NUT VULTURE",
+        "379": "PARADISE TANAGER",
+        "380": "PARAKETT  AUKLET",
+        "381": "PARAKETT AUKLET",
+        "382": "PARUS MAJOR",
+        "383": "PATAGONIAN SIERRA FINCH",
+        "384": "PEACOCK",
+        "385": "PEREGRINE FALCON",
+        "386": "PHAINOPEPLA",
+        "387": "PHILIPPINE EAGLE",
+        "388": "PINK ROBIN",
+        "389": "PLUSH CRESTED JAY",
+        "390": "POMARINE JAEGER",
+        "391": "PUFFIN",
+        "392": "PUNA TEAL",
+        "393": "PURPLE FINCH",
+        "394": "PURPLE GALLINULE",
+        "395": "PURPLE MARTIN",
+        "396": "PURPLE SWAMPHEN",
+        "397": "PYGMY KINGFISHER",
+        "398": "PYRRHULOXIA",
+        "399": "QUETZAL",
+        "400": "RAINBOW LORIKEET",
+        "401": "RAZORBILL",
+        "402": "RED BEARDED BEE EATER",
+        "403": "RED BELLIED PITTA",
+        "404": "RED BILLED TROPICBIRD",
+        "405": "RED BROWED FINCH",
+        "406": "RED CROSSBILL",
+        "407": "RED FACED CORMORANT",
+        "408": "RED FACED WARBLER",
+        "409": "RED FODY",
+        "410": "RED HEADED DUCK",
+        "411": "RED HEADED WOODPECKER",
+        "412": "RED KNOT",
+        "413": "RED LEGGED HONEYCREEPER",
+        "414": "RED NAPED TROGON",
+        "415": "RED SHOULDERED HAWK",
+        "416": "RED TAILED HAWK",
+        "417": "RED TAILED THRUSH",
+        "418": "RED WINGED BLACKBIRD",
+        "419": "RED WISKERED BULBUL",
+        "420": "REGENT BOWERBIRD",
+        "421": "RING-NECKED PHEASANT",
+        "422": "ROADRUNNER",
+        "423": "ROCK DOVE",
+        "424": "ROSE BREASTED COCKATOO",
+        "425": "ROSE BREASTED GROSBEAK",
+        "426": "ROSEATE SPOONBILL",
+        "427": "ROSY FACED LOVEBIRD",
+        "428": "ROUGH LEG BUZZARD",
+        "429": "ROYAL FLYCATCHER",
+        "430": "RUBY CROWNED KINGLET",
+        "431": "RUBY THROATED HUMMINGBIRD",
+        "432": "RUDDY SHELDUCK",
+        "433": "RUDY KINGFISHER",
+        "434": "RUFOUS KINGFISHER",
+        "435": "RUFOUS TREPE",
+        "436": "RUFUOS MOTMOT",
+        "437": "SAMATRAN THRUSH",
+        "438": "SAND MARTIN",
+        "439": "SANDHILL CRANE",
+        "440": "SATYR TRAGOPAN",
+        "441": "SAYS PHOEBE",
+        "442": "SCARLET CROWNED FRUIT DOVE",
+        "443": "SCARLET FACED LIOCICHLA",
+        "444": "SCARLET IBIS",
+        "445": "SCARLET MACAW",
+        "446": "SCARLET TANAGER",
+        "447": "SHOEBILL",
+        "448": "SHORT BILLED DOWITCHER",
+        "449": "SMITHS LONGSPUR",
+        "450": "SNOW GOOSE",
+        "451": "SNOW PARTRIDGE",
+        "452": "SNOWY EGRET",
+        "453": "SNOWY OWL",
+        "454": "SNOWY PLOVER",
+        "455": "SNOWY SHEATHBILL",
+        "456": "SORA",
+        "457": "SPANGLED COTINGA",
+        "458": "SPLENDID WREN",
+        "459": "SPOON BILED SANDPIPER",
+        "460": "SPOTTED CATBIRD",
+        "461": "SPOTTED WHISTLING DUCK",
+        "462": "SQUACCO HERON",
+        "463": "SRI LANKA BLUE MAGPIE",
+        "464": "STEAMER DUCK",
+        "465": "STORK BILLED KINGFISHER",
+        "466": "STRIATED CARACARA",
+        "467": "STRIPED OWL",
+        "468": "STRIPPED MANAKIN",
+        "469": "STRIPPED SWALLOW",
+        "470": "SUNBITTERN",
+        "471": "SUPERB STARLING",
+        "472": "SURF SCOTER",
+        "473": "SWINHOES PHEASANT",
+        "474": "TAILORBIRD",
+        "475": "TAIWAN MAGPIE",
+        "476": "TAKAHE",
+        "477": "TASMANIAN HEN",
+        "478": "TAWNY FROGMOUTH",
+        "479": "TEAL DUCK",
+        "480": "TIT MOUSE",
+        "481": "TOUCHAN",
+        "482": "TOWNSENDS WARBLER",
+        "483": "TREE SWALLOW",
+        "484": "TRICOLORED BLACKBIRD",
+        "485": "TROPICAL KINGBIRD",
+        "486": "TRUMPTER SWAN",
+        "487": "TURKEY VULTURE",
+        "488": "TURQUOISE MOTMOT",
+        "489": "UMBRELLA BIRD",
+        "490": "VARIED THRUSH",
+        "491": "VEERY",
+        "492": "VENEZUELIAN TROUPIAL",
+        "493": "VERDIN",
+        "494": "VERMILION FLYCATHER",
+        "495": "VICTORIA CROWNED PIGEON",
+        "496": "VIOLET BACKED STARLING",
+        "497": "VIOLET CUCKOO",
+        "498": "VIOLET GREEN SWALLOW",
+        "499": "VIOLET TURACO",
+        "500": "VISAYAN HORNBILL",
+        "501": "VULTURINE GUINEAFOWL",
+        "502": "WALL CREAPER",
+        "503": "WATTLED CURASSOW",
+        "504": "WATTLED LAPWING",
+        "505": "WHIMBREL",
+        "506": "WHITE BREASTED WATERHEN",
+        "507": "WHITE BROWED CRAKE",
+        "508": "WHITE CHEEKED TURACO",
+        "509": "WHITE CRESTED HORNBILL",
+        "510": "WHITE EARED HUMMINGBIRD",
+        "511": "WHITE NECKED RAVEN",
+        "512": "WHITE TAILED TROPIC",
+        "513": "WHITE THROATED BEE EATER",
+        "514": "WILD TURKEY",
+        "515": "WILLOW PTARMIGAN",
+        "516": "WILSONS BIRD OF PARADISE",
+        "517": "WOOD DUCK",
+        "518": "WOOD THRUSH",
+        "519": "WOODLAND KINGFISHER",
+        "520": "WRENTIT",
+        "521": "YELLOW BELLIED FLOWERPECKER",
+        "522": "YELLOW BREASTED CHAT",
+        "523": "YELLOW CACIQUE",
+        "524": "YELLOW HEADED BLACKBIRD",
+        "525": "ZEBRA DOVE"
+    }
+    
+    predictions = {labels[str(i)]: round(probs[i], 3) for i in range(len(probs))}
+    return predictions
+
+# Create Gradio interface for the bird species classifier
+iface = gr.Interface(
+    fn=bird_classification,
+    inputs=gr.Image(type="numpy"),
+    outputs=gr.Label(label="Prediction Scores"),
+    title="Bird Species Classifier",
+    description="Upload an image to classify the bird species."
+)
+
+if __name__ == "__main__":
+    iface.launch()

clip_art.py

@@ -0,0 +1,72 @@
+import gradio as gr
+from transformers import AutoImageProcessor, SiglipForImageClassification
+from transformers.image_utils import load_image
+from PIL import Image
+import torch
+
+# Load model and processor
+model_name = "prithivMLmods/Clipart-126-DomainNet"
+model = SiglipForImageClassification.from_pretrained(model_name)
+processor = AutoImageProcessor.from_pretrained(model_name)
+
+def clipart_classification(image):
+    """Predicts the clipart category for an input image."""
+    # Convert the input numpy array to a PIL Image and ensure it's in RGB format
+    image = Image.fromarray(image).convert("RGB")
+    
+    # Process the image and prepare it for the model
+    inputs = processor(images=image, return_tensors="pt")
+    
+    # Perform inference without gradient computation
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+        # Apply softmax to obtain probabilities for each class
+        probs = torch.nn.functional.softmax(logits, dim=1).squeeze().tolist()
+    
+    # Mapping from indices to clipart category labels
+    labels = {
+        "0": "aircraft_carrier", "1": "alarm_clock", "2": "ant", "3": "anvil", "4": "asparagus",
+        "5": "axe", "6": "banana", "7": "basket", "8": "bathtub", "9": "bear",
+        "10": "bee", "11": "bird", "12": "blackberry", "13": "blueberry", "14": "bottlecap",
+        "15": "broccoli", "16": "bus", "17": "butterfly", "18": "cactus", "19": "cake",
+        "20": "calculator", "21": "camel", "22": "camera", "23": "candle", "24": "cannon",
+        "25": "canoe", "26": "carrot", "27": "castle", "28": "cat", "29": "ceiling_fan",
+        "30": "cell_phone", "31": "cello", "32": "chair", "33": "chandelier", "34": "coffee_cup",
+        "35": "compass", "36": "computer", "37": "cow", "38": "crab", "39": "crocodile",
+        "40": "cruise_ship", "41": "dog", "42": "dolphin", "43": "dragon", "44": "drums",
+        "45": "duck", "46": "dumbbell", "47": "elephant", "48": "eyeglasses", "49": "feather",
+        "50": "fence", "51": "fish", "52": "flamingo", "53": "flower", "54": "foot",
+        "55": "fork", "56": "frog", "57": "giraffe", "58": "goatee", "59": "grapes",
+        "60": "guitar", "61": "hammer", "62": "helicopter", "63": "helmet", "64": "horse",
+        "65": "kangaroo", "66": "lantern", "67": "laptop", "68": "leaf", "69": "lion",
+        "70": "lipstick", "71": "lobster", "72": "microphone", "73": "monkey", "74": "mosquito",
+        "75": "mouse", "76": "mug", "77": "mushroom", "78": "onion", "79": "panda",
+        "80": "peanut", "81": "pear", "82": "peas", "83": "pencil", "84": "penguin",
+        "85": "pig", "86": "pillow", "87": "pineapple", "88": "potato", "89": "power_outlet",
+        "90": "purse", "91": "rabbit", "92": "raccoon", "93": "rhinoceros", "94": "rifle",
+        "95": "saxophone", "96": "screwdriver", "97": "sea_turtle", "98": "see_saw", "99": "sheep",
+        "100": "shoe", "101": "skateboard", "102": "snake", "103": "speedboat", "104": "spider",
+        "105": "squirrel", "106": "strawberry", "107": "streetlight", "108": "string_bean",
+        "109": "submarine", "110": "swan", "111": "table", "112": "teapot", "113": "teddy-bear",
+        "114": "television", "115": "the_Eiffel_Tower", "116": "the_Great_Wall_of_China",
+        "117": "tiger", "118": "toe", "119": "train", "120": "truck", "121": "umbrella",
+        "122": "vase", "123": "watermelon", "124": "whale", "125": "zebra"
+    }
+    
+    # Create a dictionary mapping each label to its corresponding probability (rounded)
+    predictions = {labels[str(i)]: round(probs[i], 3) for i in range(len(probs))}
+    return predictions
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=clipart_classification,
+    inputs=gr.Image(type="numpy"),
+    outputs=gr.Label(label="Prediction Scores"),
+    title="Clipart-126-DomainNet Classification",
+    description="Upload a clipart image to classify it into one of 126 domain categories."
+)
+
+# Launch the app
+if __name__ == "__main__":
+    iface.launch()

deepfake_quality.py

@@ -0,0 +1,41 @@
+import gradio as gr
+from transformers import AutoImageProcessor
+from transformers import SiglipForImageClassification
+from transformers.image_utils import load_image
+from PIL import Image
+import torch
+
+# Load model and processor
+model_name = "prithivMLmods/Deepfake-Quality-Classifier2-SigLIP2"
+model = SiglipForImageClassification.from_pretrained(model_name)
+processor = AutoImageProcessor.from_pretrained(model_name)
+
+def deepfake_classification(image):
+    """Predicts whether an image is a Deepfake or Real."""
+    image = Image.fromarray(image).convert("RGB")
+    inputs = processor(images=image, return_tensors="pt")
+    
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+        probs = torch.nn.functional.softmax(logits, dim=1).squeeze().tolist()
+    
+    labels = {
+        "0": "Issue In Deepfake", "1": "High Quality Deepfake"
+    }
+    predictions = {labels[str(i)]: round(probs[i], 3) for i in range(len(probs))}
+    
+    return predictions
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=deepfake_classification,
+    inputs=gr.Image(type="numpy"),
+    outputs=gr.Label(label="Prediction Scores"),
+    title="Deepfake Quality Detection",
+    description="Upload an image to check its deepfake probability scores."
+)
+
+# Launch the app
+if __name__ == "__main__":
+    iface.launch()

dog_breed.py

@@ -0,0 +1,159 @@
+import gradio as gr
+from transformers import AutoImageProcessor, SiglipForImageClassification
+from PIL import Image
+import torch
+
+# Load model and processor
+model_name = "prithivMLmods/Dog-Breed-120"
+model = SiglipForImageClassification.from_pretrained(model_name)
+processor = AutoImageProcessor.from_pretrained(model_name)
+
+def dog_breed_classification(image):
+    """Predicts the dog breed for an image."""
+    image = Image.fromarray(image).convert("RGB")
+    inputs = processor(images=image, return_tensors="pt")
+    
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+        probs = torch.nn.functional.softmax(logits, dim=1).squeeze().tolist()
+    
+    labels = {
+        "0": "affenpinscher",
+        "1": "afghan_hound",
+        "2": "african_hunting_dog",
+        "3": "airedale",
+        "4": "american_staffordshire_terrier",
+        "5": "appenzeller",
+        "6": "australian_terrier",
+        "7": "basenji",
+        "8": "basset",
+        "9": "beagle",
+        "10": "bedlington_terrier",
+        "11": "bernese_mountain_dog",
+        "12": "black-and-tan_coonhound",
+        "13": "blenheim_spaniel",
+        "14": "bloodhound",
+        "15": "bluetick",
+        "16": "border_collie",
+        "17": "border_terrier",
+        "18": "borzoi",
+        "19": "boston_bull",
+        "20": "bouvier_des_flandres",
+        "21": "boxer",
+        "22": "brabancon_griffon",
+        "23": "briard",
+        "24": "brittany_spaniel",
+        "25": "bull_mastiff",
+        "26": "cairn",
+        "27": "cardigan",
+        "28": "chesapeake_bay_retriever",
+        "29": "chihuahua",
+        "30": "chow",
+        "31": "clumber",
+        "32": "cocker_spaniel",
+        "33": "collie",
+        "34": "curly-coated_retriever",
+        "35": "dandie_dinmont",
+        "36": "dhole",
+        "37": "dingo",
+        "38": "doberman",
+        "39": "english_foxhound",
+        "40": "english_setter",
+        "41": "english_springer",
+        "42": "entlebucher",
+        "43": "eskimo_dog",
+        "44": "flat-coated_retriever",
+        "45": "french_bulldog",
+        "46": "german_shepherd",
+        "47": "german_short-haired_pointer",
+        "48": "giant_schnauzer",
+        "49": "golden_retriever",
+        "50": "gordon_setter",
+        "51": "great_dane",
+        "52": "great_pyrenees",
+        "53": "greater_swiss_mountain_dog",
+        "54": "groenendael",
+        "55": "ibizan_hound",
+        "56": "irish_setter",
+        "57": "irish_terrier",
+        "58": "irish_water_spaniel",
+        "59": "irish_wolfhound",
+        "60": "italian_greyhound",
+        "61": "japanese_spaniel",
+        "62": "keeshond",
+        "63": "kelpie",
+        "64": "kerry_blue_terrier",
+        "65": "komondor",
+        "66": "kuvasz",
+        "67": "labrador_retriever",
+        "68": "lakeland_terrier",
+        "69": "leonberg",
+        "70": "lhasa",
+        "71": "malamute",
+        "72": "malinois",
+        "73": "maltese_dog",
+        "74": "mexican_hairless",
+        "75": "miniature_pinscher",
+        "76": "miniature_poodle",
+        "77": "miniature_schnauzer",
+        "78": "newfoundland",
+        "79": "norfolk_terrier",
+        "80": "norwegian_elkhound",
+        "81": "norwich_terrier",
+        "82": "old_english_sheepdog",
+        "83": "otterhound",
+        "84": "papillon",
+        "85": "pekinese",
+        "86": "pembroke",
+        "87": "pomeranian",
+        "88": "pug",
+        "89": "redbone",
+        "90": "rhodesian_ridgeback",
+        "91": "rottweiler",
+        "92": "saint_bernard",
+        "93": "saluki",
+        "94": "samoyed",
+        "95": "schipperke",
+        "96": "scotch_terrier",
+        "97": "scottish_deerhound",
+        "98": "sealyham_terrier",
+        "99": "shetland_sheepdog",
+        "100": "shih-tzu",
+        "101": "siberian_husky",
+        "102": "silky_terrier",
+        "103": "soft-coated_wheaten_terrier",
+        "104": "staffordshire_bullterrier",
+        "105": "standard_poodle",
+        "106": "standard_schnauzer",
+        "107": "sussex_spaniel",
+        "108": "test",
+        "109": "tibetan_mastiff",
+        "110": "tibetan_terrier",
+        "111": "toy_poodle",
+        "112": "toy_terrier",
+        "113": "vizsla",
+        "114": "walker_hound",
+        "115": "weimaraner",
+        "116": "welsh_springer_spaniel",
+        "117": "west_highland_white_terrier",
+        "118": "whippet",
+        "119": "wire-haired_fox_terrier",
+        "120": "yorkshire_terrier"
+    }
+    
+    predictions = {labels[str(i)]: round(probs[i], 3) for i in range(len(probs))}
+    return predictions
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=dog_breed_classification,
+    inputs=gr.Image(type="numpy"),
+    outputs=gr.Label(label="Prediction Scores"),
+    title="Dog Breed Classification",
+    description="Upload an image to classify it into one of the 121 dog breed categories."
+)
+
+# Launch the app
+if __name__ == "__main__":
+    iface.launch()

emotion_classification.py

@@ -0,0 +1,38 @@
+import gradio as gr
+from transformers import AutoImageProcessor
+from transformers import SiglipForImageClassification
+from PIL import Image
+import torch
+
+# Load model and processor
+model_name = "prithivMLmods/Facial-Emotion-Detection-SigLIP2"
+model = SiglipForImageClassification.from_pretrained(model_name)
+processor = AutoImageProcessor.from_pretrained(model_name)
+
+def emotion_classification(image):
+    """Predicts facial emotion classification for an image."""
+    image = Image.fromarray(image).convert("RGB")
+    inputs = processor(images=image, return_tensors="pt")
+    
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+        probs = torch.nn.functional.softmax(logits, dim=1).squeeze().tolist()
+    
+    labels = {
+        "0": "Ahegao", "1": "Angry", "2": "Happy", "3": "Neutral",
+        "4": "Sad", "5": "Surprise"
+    }
+    predictions = {labels[str(i)]: round(probs[i], 3) for i in range(len(probs))}
+    
+    return predictions
+
+if __name__ == "__main__":
+    iface = gr.Interface(
+        fn=emotion_classification,
+        inputs=gr.Image(type="numpy"),
+        outputs=gr.Label(label="Prediction Scores"),
+        title="Facial Emotion Detection",
+        description="Upload an image to classify the facial emotion."
+    )
+    iface.launch()

fashion_mnist_cloth.py

@@ -0,0 +1,42 @@
+import gradio as gr
+from transformers import AutoImageProcessor
+from transformers import SiglipForImageClassification
+from transformers.image_utils import load_image
+from PIL import Image
+import torch
+
+# Load model and processor
+model_name = "prithivMLmods/Fashion-Mnist-SigLIP2"
+model = SiglipForImageClassification.from_pretrained(model_name)
+processor = AutoImageProcessor.from_pretrained(model_name)
+
+def fashion_mnist_classification(image):
+    """Predicts fashion category for an image."""
+    image = Image.fromarray(image).convert("RGB")
+    inputs = processor(images=image, return_tensors="pt")
+    
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+        probs = torch.nn.functional.softmax(logits, dim=1).squeeze().tolist()
+    
+    labels = {
+        "0": "T-shirt / top", "1": "Trouser", "2": "Pullover", "3": "Dress", "4": "Coat",
+        "5": "Sandal", "6": "Shirt", "7": "Sneaker", "8": "Bag", "9": "Ankle boot"
+    }
+    predictions = {labels[str(i)]: round(probs[i], 3) for i in range(len(probs))}
+    
+    return predictions
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=fashion_mnist_classification,
+    inputs=gr.Image(type="numpy"),
+    outputs=gr.Label(label="Prediction Scores"),
+    title="Fashion MNIST Classification Labels",
+    description="Upload an image to classify it into one of the 10 Fashion-MNIST categories."
+)
+
+# Launch the app
+if __name__ == "__main__":
+    iface.launch()

gender_classification.py

@@ -0,0 +1,36 @@
+import gradio as gr
+from transformers import AutoImageProcessor
+from transformers import SiglipForImageClassification
+from PIL import Image
+import torch
+
+# Load model and processor
+model_name = "prithivMLmods/Gender-Classifier-Mini"
+model = SiglipForImageClassification.from_pretrained(model_name)
+processor = AutoImageProcessor.from_pretrained(model_name)
+
+def gender_classification(image):
+    """Predicts gender category for an image."""
+    image = Image.fromarray(image).convert("RGB")
+    inputs = processor(images=image, return_tensors="pt")
+    
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+        probs = torch.nn.functional.softmax(logits, dim=1).squeeze().tolist()
+    
+    labels = {"0": "Female ♀", "1": "Male ♂"}
+    predictions = {labels[str(i)]: round(probs[i], 3) for i in range(len(probs))}
+    
+    return predictions
+
+if __name__ == "__main__":
+    import gradio as gr
+    iface = gr.Interface(
+        fn=gender_classification,
+        inputs=gr.Image(type="numpy"),
+        outputs=gr.Label(label="Prediction Scores"),
+        title="Gender Classification",
+        description="Upload an image to classify its gender."
+    )
+    iface.launch()

gym_workout_classification.py

@@ -0,0 +1,46 @@
+import gradio as gr
+from transformers import AutoImageProcessor
+from transformers import SiglipForImageClassification
+from transformers.image_utils import load_image
+from PIL import Image
+import torch
+
+# Load model and processor
+model_name = "prithivMLmods/Gym-Workout-Classifier-SigLIP2"
+model = SiglipForImageClassification.from_pretrained(model_name)
+processor = AutoImageProcessor.from_pretrained(model_name)
+
+def workout_classification(image):
+    """Predicts workout exercise classification for an image."""
+    image = Image.fromarray(image).convert("RGB")
+    inputs = processor(images=image, return_tensors="pt")
+    
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+        probs = torch.nn.functional.softmax(logits, dim=1).squeeze().tolist()
+    
+    labels = {
+        "0": "barbell biceps curl", "1": "bench press", "2": "chest fly machine", "3": "deadlift",
+        "4": "decline bench press", "5": "hammer curl", "6": "hip thrust", "7": "incline bench press",
+        "8": "lat pulldown", "9": "lateral raises", "10": "leg extension", "11": "leg raises",
+        "12": "plank", "13": "pull up", "14": "push up", "15": "romanian deadlift",
+        "16": "russian twist", "17": "shoulder press", "18": "squat", "19": "t bar row",
+        "20": "tricep dips", "21": "tricep pushdown"
+    }
+    predictions = {labels[str(i)]: round(probs[i], 3) for i in range(len(probs))}
+    
+    return predictions
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=workout_classification,
+    inputs=gr.Image(type="numpy"),
+    outputs=gr.Label(label="Prediction Scores"),
+    title="Gym Workout Classification",
+    description="Upload an image to classify the workout exercise."
+)
+
+# Launch the app
+if __name__ == "__main__":
+    iface.launch()

indian_western_food_classify.py

@@ -0,0 +1,48 @@
+import gradio as gr
+from transformers import AutoImageProcessor
+from transformers import SiglipForImageClassification
+from transformers.image_utils import load_image
+from PIL import Image
+import torch
+
+# Load model and processor
+model_name = "prithivMLmods/Indian-Western-Food-34"
+model = SiglipForImageClassification.from_pretrained(model_name)
+processor = AutoImageProcessor.from_pretrained(model_name)
+
+def food_classification(image):
+    """Predicts the type of food in an image."""
+    image = Image.fromarray(image).convert("RGB")
+    inputs = processor(images=image, return_tensors="pt")
+    
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+        probs = torch.nn.functional.softmax(logits, dim=1).squeeze().tolist()
+    
+    labels = {
+        "0": "Baked Potato", "1": "Crispy Chicken", "2": "Donut", "3": "Fries", 
+        "4": "Hot Dog", "5": "Sandwich", "6": "Taco", "7": "Taquito", "8": "Apple Pie", 
+        "9": "Burger", "10": "Butter Naan", "11": "Chai", "12": "Chapati", "13": "Cheesecake", 
+        "14": "Chicken Curry", "15": "Chole Bhature", "16": "Dal Makhani", "17": "Dhokla", 
+        "18": "Fried Rice", "19": "Ice Cream", "20": "Idli", "21": "Jalebi", "22": "Kaathi Rolls", 
+        "23": "Kadai Paneer", "24": "Kulfi", "25": "Masala Dosa", "26": "Momos", "27": "Omelette", 
+        "28": "Paani Puri", "29": "Pakode", "30": "Pav Bhaji", "31": "Pizza", "32": "Samosa", 
+        "33": "Sushi"
+    }
+    predictions = {labels[str(i)]: round(probs[i], 3) for i in range(len(probs))}
+    
+    return predictions
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=food_classification,
+    inputs=gr.Image(type="numpy"),
+    outputs=gr.Label(label="Prediction Scores"),
+    title="Indian & Western Food Classification",
+    description="Upload a food image to classify it into one of the 34 food types."
+)
+
+# Launch the app
+if __name__ == "__main__":
+    iface.launch()

mnist_digits.py

@@ -0,0 +1,41 @@
+import gradio as gr
+from transformers import AutoImageProcessor, SiglipForImageClassification
+from transformers.image_utils import load_image
+from PIL import Image
+import torch
+
+# Load model and processor
+model_name = "prithivMLmods/Mnist-Digits-SigLIP2"
+model = SiglipForImageClassification.from_pretrained(model_name)
+processor = AutoImageProcessor.from_pretrained(model_name)
+
+def classify_digit(image):
+    """Predicts the digit in the given handwritten digit image."""
+    image = Image.fromarray(image).convert("RGB")
+    inputs = processor(images=image, return_tensors="pt")
+    
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+        probs = torch.nn.functional.softmax(logits, dim=1).squeeze().tolist()
+    
+    labels = {
+        "0": "0", "1": "1", "2": "2", "3": "3", "4": "4",
+        "5": "5", "6": "6", "7": "7", "8": "8", "9": "9"
+    }
+    predictions = {labels[str(i)]: round(probs[i], 3) for i in range(len(probs))}
+    
+    return predictions
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=classify_digit,
+    inputs=gr.Image(type="numpy"),
+    outputs=gr.Label(label="Prediction Scores"),
+    title="MNIST Digit Classification 🔢",
+    description="Upload a handwritten digit image (0-9) to recognize it using MNIST-Digits-SigLIP2."
+)
+
+# Launch the app
+if __name__ == "__main__":
+    iface.launch()

multisource_121.py

@@ -0,0 +1,71 @@
+import gradio as gr
+from transformers import AutoImageProcessor, SiglipForImageClassification
+from transformers.image_utils import load_image
+from PIL import Image
+import torch
+
+# Load model and processor
+model_name = "prithivMLmods/Multisource-121-DomainNet"
+model = SiglipForImageClassification.from_pretrained(model_name)
+processor = AutoImageProcessor.from_pretrained(model_name)
+
+def multisource_classification(image):
+    """Predicts the domain category for an input image."""
+    # Convert the input numpy array to a PIL Image and ensure it is in RGB format
+    image = Image.fromarray(image).convert("RGB")
+    
+    # Process the image and convert it to model inputs
+    inputs = processor(images=image, return_tensors="pt")
+    
+    # Get model predictions without gradient calculations
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+        # Convert logits to probabilities using softmax
+        probs = torch.nn.functional.softmax(logits, dim=1).squeeze().tolist()
+    
+    # Mapping from class indices to domain labels
+    labels = {
+        "0": "barn", "1": "baseball_bat", "2": "basket", "3": "beach", "4": "bear",
+        "5": "beard", "6": "bee", "7": "bird", "8": "blueberry", "9": "bowtie",
+        "10": "bracelet", "11": "brain", "12": "bread", "13": "broccoli", "14": "bus",
+        "15": "butterfly", "16": "circle", "17": "cloud", "18": "cruise_ship", "19": "dolphin",
+        "20": "dumbbell", "21": "elephant", "22": "eye", "23": "eyeglasses", "24": "feather",
+        "25": "fish", "26": "flower", "27": "foot", "28": "frog", "29": "giraffe",
+        "30": "goatee", "31": "golf_club", "32": "grapes", "33": "grass", "34": "guitar",
+        "35": "hamburger", "36": "hand", "37": "hat", "38": "headphones", "39": "helicopter",
+        "40": "hexagon", "41": "hockey_stick", "42": "horse", "43": "hourglass", "44": "house",
+        "45": "ice_cream", "46": "jacket", "47": "ladder", "48": "leg", "49": "lipstick",
+        "50": "megaphone", "51": "monkey", "52": "moon", "53": "mushroom", "54": "necklace",
+        "55": "owl", "56": "panda", "57": "pear", "58": "peas", "59": "penguin",
+        "60": "pig", "61": "pillow", "62": "pineapple", "63": "pizza", "64": "pool",
+        "65": "popsicle", "66": "rabbit", "67": "rhinoceros", "68": "rifle", "69": "river",
+        "70": "sailboat", "71": "sandwich", "72": "sea_turtle", "73": "shark", "74": "shoe",
+        "75": "skyscraper", "76": "snorkel", "77": "snowman", "78": "soccer_ball", "79": "speedboat",
+        "80": "spider", "81": "spoon", "82": "square", "83": "squirrel", "84": "stethoscope",
+        "85": "strawberry", "86": "streetlight", "87": "submarine", "88": "suitcase", "89": "sun",
+        "90": "sweater", "91": "sword", "92": "table", "93": "teapot", "94": "teddy-bear",
+        "95": "telephone", "96": "tent", "97": "The_Eiffel_Tower", "98": "The_Great_Wall_of_China",
+        "99": "The_Mona_Lisa", "100": "tiger", "101": "toaster", "102": "tooth", "103": "tornado",
+        "104": "tractor", "105": "train", "106": "tree", "107": "triangle", "108": "trombone",
+        "109": "truck", "110": "trumpet", "111": "umbrella", "112": "vase", "113": "violin",
+        "114": "watermelon", "115": "whale", "116": "windmill", "117": "wine_glass", "118": "yoga",
+        "119": "zebra", "120": "zigzag"
+    }
+    
+    # Create a dictionary mapping each label to its corresponding probability (rounded)
+    predictions = {labels[str(i)]: round(probs[i], 3) for i in range(len(probs))}
+    return predictions
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=multisource_classification,
+    inputs=gr.Image(type="numpy"),
+    outputs=gr.Label(label="Prediction Scores"),
+    title="Multisource-121-DomainNet Classification",
+    description="Upload an image to classify it into one of 121 domain categories."
+)
+
+# Launch the app
+if __name__ == "__main__":
+    iface.launch()

painting_126.py

@@ -0,0 +1,72 @@
+import gradio as gr
+from transformers import AutoImageProcessor, SiglipForImageClassification
+from transformers.image_utils import load_image
+from PIL import Image
+import torch
+
+# Load model and processor
+model_name = "prithivMLmods/Painting-126-DomainNet"
+model = SiglipForImageClassification.from_pretrained(model_name)
+processor = AutoImageProcessor.from_pretrained(model_name)
+
+def painting_classification(image):
+    """Predicts the painting category for an input image."""
+    # Convert the input numpy array to a PIL image and ensure it is in RGB format
+    image = Image.fromarray(image).convert("RGB")
+    
+    # Process the image for the model
+    inputs = processor(images=image, return_tensors="pt")
+    
+    # Get predictions from the model without gradient computation
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+        # Convert logits to probabilities using softmax
+        probs = torch.nn.functional.softmax(logits, dim=1).squeeze().tolist()
+    
+    # Define the label mapping for each class index
+    labels = {
+        "0": "aircraft_carrier", "1": "alarm_clock", "2": "ant", "3": "anvil", "4": "asparagus",
+        "5": "axe", "6": "banana", "7": "basket", "8": "bathtub", "9": "bear",
+        "10": "bee", "11": "bird", "12": "blackberry", "13": "blueberry", "14": "bottlecap",
+        "15": "broccoli", "16": "bus", "17": "butterfly", "18": "cactus", "19": "cake",
+        "20": "calculator", "21": "camel", "22": "camera", "23": "candle", "24": "cannon",
+        "25": "canoe", "26": "carrot", "27": "castle", "28": "cat", "29": "ceiling_fan",
+        "30": "cell_phone", "31": "cello", "32": "chair", "33": "chandelier", "34": "coffee_cup",
+        "35": "compass", "36": "computer", "37": "cow", "38": "crab", "39": "crocodile",
+        "40": "cruise_ship", "41": "dog", "42": "dolphin", "43": "dragon", "44": "drums",
+        "45": "duck", "46": "dumbbell", "47": "elephant", "48": "eyeglasses", "49": "feather",
+        "50": "fence", "51": "fish", "52": "flamingo", "53": "flower", "54": "foot",
+        "55": "fork", "56": "frog", "57": "giraffe", "58": "goatee", "59": "grapes",
+        "60": "guitar", "61": "hammer", "62": "helicopter", "63": "helmet", "64": "horse",
+        "65": "kangaroo", "66": "lantern", "67": "laptop", "68": "leaf", "69": "lion",
+        "70": "lipstick", "71": "lobster", "72": "microphone", "73": "monkey", "74": "mosquito",
+        "75": "mouse", "76": "mug", "77": "mushroom", "78": "onion", "79": "panda",
+        "80": "peanut", "81": "pear", "82": "peas", "83": "pencil", "84": "penguin",
+        "85": "pig", "86": "pillow", "87": "pineapple", "88": "potato", "89": "power_outlet",
+        "90": "purse", "91": "rabbit", "92": "raccoon", "93": "rhinoceros", "94": "rifle",
+        "95": "saxophone", "96": "screwdriver", "97": "sea_turtle", "98": "see_saw", "99": "sheep",
+        "100": "shoe", "101": "skateboard", "102": "snake", "103": "speedboat", "104": "spider",
+        "105": "squirrel", "106": "strawberry", "107": "streetlight", "108": "string_bean",
+        "109": "submarine", "110": "swan", "111": "table", "112": "teapot", "113": "teddy-bear",
+        "114": "television", "115": "the_Eiffel_Tower", "116": "the_Great_Wall_of_China",
+        "117": "tiger", "118": "toe", "119": "train", "120": "truck", "121": "umbrella",
+        "122": "vase", "123": "watermelon", "124": "whale", "125": "zebra"
+    }
+    
+    # Map each label to its corresponding probability (rounded)
+    predictions = {labels[str(i)]: round(probs[i], 3) for i in range(len(probs))}
+    return predictions
+
+# Create Gradio interface for the painting classifier
+iface = gr.Interface(
+    fn=painting_classification,
+    inputs=gr.Image(type="numpy"),
+    outputs=gr.Label(label="Prediction Scores"),
+    title="Painting-126-DomainNet Classification",
+    description="Upload a painting to classify it into one of 126 categories."
+)
+
+# Launch the app
+if __name__ == "__main__":
+    iface.launch()

requirements.txt

@@ -0,0 +1,8 @@
+transformers
+accelerate
+torch
+protobuf
+sentencepiece
+pillow
+gradio
+spaces

rice_leaf_disease.py

@@ -0,0 +1,44 @@
+import gradio as gr
+from transformers import AutoImageProcessor, SiglipForImageClassification
+from transformers.image_utils import load_image
+from PIL import Image
+import torch
+
+# Load model and processor
+model_name = "prithivMLmods/Rice-Leaf-Disease"
+model = SiglipForImageClassification.from_pretrained(model_name)
+processor = AutoImageProcessor.from_pretrained(model_name)
+
+def classify_leaf_disease(image):
+    """Predicts the disease type in a rice leaf image."""
+    image = Image.fromarray(image).convert("RGB")
+    inputs = processor(images=image, return_tensors="pt")
+    
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+        probs = torch.nn.functional.softmax(logits, dim=1).squeeze().tolist()
+    
+    labels = {
+        "0": "Bacterial Blight",
+        "1": "Blast",
+        "2": "Brown Spot",
+        "3": "Healthy",
+        "4": "Tungro"
+    }
+    predictions = {labels[str(i)]: round(probs[i], 3) for i in range(len(probs))}
+    
+    return predictions
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=classify_leaf_disease,
+    inputs=gr.Image(type="numpy"),
+    outputs=gr.Label(label="Prediction Scores"),
+    title="Rice Leaf Disease Classification 🌾",
+    description="Upload an image of a rice leaf to identify if it is healthy or affected by diseases like Bacterial Blight, Blast, Brown Spot, or Tungro."
+)
+
+# Launch the app
+if __name__ == "__main__":
+    iface.launch()

sketch_126.py

@@ -0,0 +1,72 @@
+import gradio as gr
+from transformers import AutoImageProcessor, SiglipForImageClassification
+from transformers.image_utils import load_image
+from PIL import Image
+import torch
+
+# Load model and processor
+model_name = "prithivMLmods/Sketch-126-DomainNet"
+model = SiglipForImageClassification.from_pretrained(model_name)
+processor = AutoImageProcessor.from_pretrained(model_name)
+
+def sketch_classification(image):
+    """Predicts the sketch category for an input image."""
+    # Convert the input numpy array to a PIL Image and ensure it has 3 channels (RGB)
+    image = Image.fromarray(image).convert("RGB")
+    
+    # Process the image and prepare it for the model
+    inputs = processor(images=image, return_tensors="pt")
+    
+    # Perform inference without gradient calculation
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+        # Convert logits to probabilities using softmax
+        probs = torch.nn.functional.softmax(logits, dim=1).squeeze().tolist()
+    
+    # Mapping from indices to corresponding sketch category labels
+    labels = {
+        "0": "aircraft_carrier", "1": "alarm_clock", "2": "ant", "3": "anvil", "4": "asparagus",
+        "5": "axe", "6": "banana", "7": "basket", "8": "bathtub", "9": "bear",
+        "10": "bee", "11": "bird", "12": "blackberry", "13": "blueberry", "14": "bottlecap",
+        "15": "broccoli", "16": "bus", "17": "butterfly", "18": "cactus", "19": "cake",
+        "20": "calculator", "21": "camel", "22": "camera", "23": "candle", "24": "cannon",
+        "25": "canoe", "26": "carrot", "27": "castle", "28": "cat", "29": "ceiling_fan",
+        "30": "cell_phone", "31": "cello", "32": "chair", "33": "chandelier", "34": "coffee_cup",
+        "35": "compass", "36": "computer", "37": "cow", "38": "crab", "39": "crocodile",
+        "40": "cruise_ship", "41": "dog", "42": "dolphin", "43": "dragon", "44": "drums",
+        "45": "duck", "46": "dumbbell", "47": "elephant", "48": "eyeglasses", "49": "feather",
+        "50": "fence", "51": "fish", "52": "flamingo", "53": "flower", "54": "foot",
+        "55": "fork", "56": "frog", "57": "giraffe", "58": "goatee", "59": "grapes",
+        "60": "guitar", "61": "hammer", "62": "helicopter", "63": "helmet", "64": "horse",
+        "65": "kangaroo", "66": "lantern", "67": "laptop", "68": "leaf", "69": "lion",
+        "70": "lipstick", "71": "lobster", "72": "microphone", "73": "monkey", "74": "mosquito",
+        "75": "mouse", "76": "mug", "77": "mushroom", "78": "onion", "79": "panda",
+        "80": "peanut", "81": "pear", "82": "peas", "83": "pencil", "84": "penguin",
+        "85": "pig", "86": "pillow", "87": "pineapple", "88": "potato", "89": "power_outlet",
+        "90": "purse", "91": "rabbit", "92": "raccoon", "93": "rhinoceros", "94": "rifle",
+        "95": "saxophone", "96": "screwdriver", "97": "sea_turtle", "98": "see_saw", "99": "sheep",
+        "100": "shoe", "101": "skateboard", "102": "snake", "103": "speedboat", "104": "spider",
+        "105": "squirrel", "106": "strawberry", "107": "streetlight", "108": "string_bean",
+        "109": "submarine", "110": "swan", "111": "table", "112": "teapot", "113": "teddy-bear",
+        "114": "television", "115": "the_Eiffel_Tower", "116": "the_Great_Wall_of_China",
+        "117": "tiger", "118": "toe", "119": "train", "120": "truck", "121": "umbrella",
+        "122": "vase", "123": "watermelon", "124": "whale", "125": "zebra"
+    }
+    
+    # Create a dictionary mapping each label to its predicted probability (rounded)
+    predictions = {labels[str(i)]: round(probs[i], 3) for i in range(len(probs))}
+    return predictions
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=sketch_classification,
+    inputs=gr.Image(type="numpy"),
+    outputs=gr.Label(label="Prediction Scores"),
+    title="Sketch-126-DomainNet Classification",
+    description="Upload a sketch to classify it into one of 126 categories."
+)
+
+# Launch the app
+if __name__ == "__main__":
+    iface.launch()

traffic_density.py

@@ -0,0 +1,41 @@
+import gradio as gr
+from transformers import AutoImageProcessor
+from transformers import SiglipForImageClassification
+from transformers.image_utils import load_image
+from PIL import Image
+import torch
+
+# Load model and processor
+model_name = "prithivMLmods/Traffic-Density-Classification"
+model = SiglipForImageClassification.from_pretrained(model_name)
+processor = AutoImageProcessor.from_pretrained(model_name)
+
+def traffic_density_classification(image):
+    """Predicts traffic density category for an image."""
+    image = Image.fromarray(image).convert("RGB")
+    inputs = processor(images=image, return_tensors="pt")
+    
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+        probs = torch.nn.functional.softmax(logits, dim=1).squeeze().tolist()
+    
+    labels = {
+        "0": "high-traffic", "1": "low-traffic", "2": "medium-traffic", "3": "no-traffic"
+    }
+    predictions = {labels[str(i)]: round(probs[i], 3) for i in range(len(probs))}
+    
+    return predictions
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=traffic_density_classification,
+    inputs=gr.Image(type="numpy"),
+    outputs=gr.Label(label="Prediction Scores"),
+    title="Traffic Density Classification",
+    description="Upload an image to classify it into one of the 4 traffic density categories."
+)
+
+# Launch the app
+if __name__ == "__main__":
+    iface.launch()