Upload

.gitignore

@@ -0,0 +1,74 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+ENV/
+.env
+.venv
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+.project
+.pydevproject
+.settings
+
+# Jupyter Notebook
+.ipynb_checkpoints
+*.ipynb_checkpoints/
+
+# PyTorch
+*.pth
+*.pt
+*.pkl
+
+# Logs and databases
+*.log
+*.sqlite
+*.db
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Project specific
+runs/
+checkpoints/
+outputs/
+logs/ 
+lightning_logs/
+gradio_cached_examples/
+
+flagged/
+*.pt
+*.jpeg
+*.png
+*.jpg

app.py

@@ -0,0 +1,148 @@
+import gradio as gr
+import torch
+from torchvision import transforms
+from PIL import Image
+import json
+from pathlib import Path
+import os
+from huggingface_hub import hf_hub_download
+
+
+class ModelPredictor:
+    def __init__(
+        self,
+        model_repo: str,
+        model_filename: str,
+        device: str = None,
+    ):
+        self.device = (
+            device if device else ("cuda" if torch.cuda.is_available() else "cpu")
+        )
+
+        # Load the model
+        checkpoint_path = hf_hub_download(repo_id=model_repo, filename=model_filename)
+        self.model = self.load_model(checkpoint_path)
+        self.model.to(self.device)
+        self.model.eval()
+
+        # Setup transforms
+        self.transform = transforms.Compose(
+            [
+                transforms.Resize(256),
+                transforms.CenterCrop(224),
+                transforms.ToTensor(),
+                transforms.Normalize(
+                    mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                ),
+            ]
+        )
+
+        # Load ImageNet class labels
+        self.class_labels = self.load_imagenet_labels()
+
+    def load_model(self, checkpoint_path: str):
+        """Load the trained model from checkpoint"""
+        from pl_train import ImageNetModule
+
+        checkpoint = torch.load(checkpoint_path, map_location=self.device)
+        model = ImageNetModule(
+            learning_rate=0.156,
+            batch_size=1,
+            num_workers=0,  # Set to 0 for Gradio
+            max_epochs=40,
+            train_path="",
+            val_path="",
+            checkpoint_dir="",
+        )
+        model.load_state_dict(checkpoint["state_dict"])
+        return model
+
+    def load_imagenet_labels(self):
+        """Load ImageNet class labels"""
+        # For HuggingFace Spaces, we'll look for the labels file in the same directory
+        labels_path = Path("data/imagenet-simple-labels.json")
+
+        if labels_path.exists():
+            with open(labels_path) as f:
+                data = json.load(f)
+                return {str(i + 1): name for i, name in enumerate(data)}
+        return {str(i): f"class_{i}" for i in range(1000)}  # Fallback
+
+    def predict(self, image):
+        """
+        Make prediction for a single image
+        Args:
+            image: PIL Image or path to image
+        Returns:
+            Dictionary of class labels and probabilities
+        """
+        if isinstance(image, str):
+            image = Image.open(image).convert("RGB")
+        else:
+            image = Image.fromarray(image).convert("RGB")
+
+        image_tensor = self.transform(image).unsqueeze(0)
+        image_tensor = image_tensor.to(self.device)
+
+        with torch.no_grad():
+            outputs = self.model(image_tensor)
+            probabilities = torch.nn.functional.softmax(outputs, dim=1)
+
+            # Get top 5 predictions
+            top_probs, top_indices = torch.topk(probabilities, 5)
+
+            # Create results dictionary
+            results = {}
+            for prob, idx in zip(top_probs[0], top_indices[0]):
+                class_name = self.class_labels[str(idx.item())]
+                results[class_name] = float(prob)
+
+        return results
+
+
+# Initialize the predictor
+predictor = ModelPredictor(
+    model_repo="Adityak204/ResNetVision-1K",  # Replace with your repo
+    model_filename="resnet50-epoch36-acc60.3506.ckpt",  # Replace with your model filename
+)
+
+
+def predict_image(image):
+    """
+    Gradio interface function
+    """
+    predictions = predictor.predict(image)
+
+    # Format results for display
+    return {k: f"{v:.2%}" for k, v in predictions.items()}
+
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=predict_image,
+    inputs=gr.Image(type="pil"),
+    outputs=gr.Label(num_top_classes=5),
+    title="ImageNet-1K Classification",
+    description="Upload an image to classify it into one of 1000 ImageNet categories",
+    examples=(
+        [
+            ["ResNetVision-1K/data/ILSVRC2012_val_00000048.JPEG"],
+            ["ResNetVision-1K/data/ILSVRC2012_val_00000090.JPEG"],
+            ["ResNetVision-1K/data/ILSVRC2012_val_00000.JPEG"],
+        ]
+        if all(
+            Path(f).exists()
+            for f in [
+                ["ResNetVision-1K/data/ILSVRC2012_val_00000048.JPEG"],
+                ["ResNetVision-1K/data/ILSVRC2012_val_00000090.JPEG"],
+                ["ResNetVision-1K/data/ILSVRC2012_val_00000.JPEG"],
+            ]
+        )
+        else None
+    ),
+    analytics_enabled=False,
+)
+
+# Launch the app
+if __name__ == "__main__":
+    iface.launch()

data/imagenet-simple-labels.json

@@ -0,0 +1,1000 @@
+["tench",
+"goldfish",
+"great white shark",
+"tiger shark",
+"hammerhead shark",
+"electric ray",
+"stingray",
+"cock",
+"hen",
+"ostrich",
+"brambling",
+"goldfinch",
+"house finch",
+"junco",
+"indigo bunting",
+"American robin",
+"bulbul",
+"jay",
+"magpie",
+"chickadee",
+"American dipper",
+"kite",
+"bald eagle",
+"vulture",
+"great grey owl",
+"fire salamander",
+"smooth newt",
+"newt",
+"spotted salamander",
+"axolotl",
+"American bullfrog",
+"tree frog",
+"tailed frog",
+"loggerhead sea turtle",
+"leatherback sea turtle",
+"mud turtle",
+"terrapin",
+"box turtle",
+"banded gecko",
+"green iguana",
+"Carolina anole",
+"desert grassland whiptail lizard",
+"agama",
+"frilled-necked lizard",
+"alligator lizard",
+"Gila monster",
+"European green lizard",
+"chameleon",
+"Komodo dragon",
+"Nile crocodile",
+"American alligator",
+"triceratops",
+"worm snake",
+"ring-necked snake",
+"eastern hog-nosed snake",
+"smooth green snake",
+"kingsnake",
+"garter snake",
+"water snake",
+"vine snake",
+"night snake",
+"boa constrictor",
+"African rock python",
+"Indian cobra",
+"green mamba",
+"sea snake",
+"Saharan horned viper",
+"eastern diamondback rattlesnake",
+"sidewinder",
+"trilobite",
+"harvestman",
+"scorpion",
+"yellow garden spider",
+"barn spider",
+"European garden spider",
+"southern black widow",
+"tarantula",
+"wolf spider",
+"tick",
+"centipede",
+"black grouse",
+"ptarmigan",
+"ruffed grouse",
+"prairie grouse",
+"peacock",
+"quail",
+"partridge",
+"grey parrot",
+"macaw",
+"sulphur-crested cockatoo",
+"lorikeet",
+"coucal",
+"bee eater",
+"hornbill",
+"hummingbird",
+"jacamar",
+"toucan",
+"duck",
+"red-breasted merganser",
+"goose",
+"black swan",
+"tusker",
+"echidna",
+"platypus",
+"wallaby",
+"koala",
+"wombat",
+"jellyfish",
+"sea anemone",
+"brain coral",
+"flatworm",
+"nematode",
+"conch",
+"snail",
+"slug",
+"sea slug",
+"chiton",
+"chambered nautilus",
+"Dungeness crab",
+"rock crab",
+"fiddler crab",
+"red king crab",
+"American lobster",
+"spiny lobster",
+"crayfish",
+"hermit crab",
+"isopod",
+"white stork",
+"black stork",
+"spoonbill",
+"flamingo",
+"little blue heron",
+"great egret",
+"bittern",
+"crane (bird)",
+"limpkin",
+"common gallinule",
+"American coot",
+"bustard",
+"ruddy turnstone",
+"dunlin",
+"common redshank",
+"dowitcher",
+"oystercatcher",
+"pelican",
+"king penguin",
+"albatross",
+"grey whale",
+"killer whale",
+"dugong",
+"sea lion",
+"Chihuahua",
+"Japanese Chin",
+"Maltese",
+"Pekingese",
+"Shih Tzu",
+"King Charles Spaniel",
+"Papillon",
+"toy terrier",
+"Rhodesian Ridgeback",
+"Afghan Hound",
+"Basset Hound",
+"Beagle",
+"Bloodhound",
+"Bluetick Coonhound",
+"Black and Tan Coonhound",
+"Treeing Walker Coonhound",
+"English foxhound",
+"Redbone Coonhound",
+"borzoi",
+"Irish Wolfhound",
+"Italian Greyhound",
+"Whippet",
+"Ibizan Hound",
+"Norwegian Elkhound",
+"Otterhound",
+"Saluki",
+"Scottish Deerhound",
+"Weimaraner",
+"Staffordshire Bull Terrier",
+"American Staffordshire Terrier",
+"Bedlington Terrier",
+"Border Terrier",
+"Kerry Blue Terrier",
+"Irish Terrier",
+"Norfolk Terrier",
+"Norwich Terrier",
+"Yorkshire Terrier",
+"Wire Fox Terrier",
+"Lakeland Terrier",
+"Sealyham Terrier",
+"Airedale Terrier",
+"Cairn Terrier",
+"Australian Terrier",
+"Dandie Dinmont Terrier",
+"Boston Terrier",
+"Miniature Schnauzer",
+"Giant Schnauzer",
+"Standard Schnauzer",
+"Scottish Terrier",
+"Tibetan Terrier",
+"Australian Silky Terrier",
+"Soft-coated Wheaten Terrier",
+"West Highland White Terrier",
+"Lhasa Apso",
+"Flat-Coated Retriever",
+"Curly-coated Retriever",
+"Golden Retriever",
+"Labrador Retriever",
+"Chesapeake Bay Retriever",
+"German Shorthaired Pointer",
+"Vizsla",
+"English Setter",
+"Irish Setter",
+"Gordon Setter",
+"Brittany Spaniel",
+"Clumber Spaniel",
+"English Springer Spaniel",
+"Welsh Springer Spaniel",
+"Cocker Spaniels",
+"Sussex Spaniel",
+"Irish Water Spaniel",
+"Kuvasz",
+"Schipperke",
+"Groenendael",
+"Malinois",
+"Briard",
+"Australian Kelpie",
+"Komondor",
+"Old English Sheepdog",
+"Shetland Sheepdog",
+"collie",
+"Border Collie",
+"Bouvier des Flandres",
+"Rottweiler",
+"German Shepherd Dog",
+"Dobermann",
+"Miniature Pinscher",
+"Greater Swiss Mountain Dog",
+"Bernese Mountain Dog",
+"Appenzeller Sennenhund",
+"Entlebucher Sennenhund",
+"Boxer",
+"Bullmastiff",
+"Tibetan Mastiff",
+"French Bulldog",
+"Great Dane",
+"St. Bernard",
+"husky",
+"Alaskan Malamute",
+"Siberian Husky",
+"Dalmatian",
+"Affenpinscher",
+"Basenji",
+"pug",
+"Leonberger",
+"Newfoundland",
+"Pyrenean Mountain Dog",
+"Samoyed",
+"Pomeranian",
+"Chow Chow",
+"Keeshond",
+"Griffon Bruxellois",
+"Pembroke Welsh Corgi",
+"Cardigan Welsh Corgi",
+"Toy Poodle",
+"Miniature Poodle",
+"Standard Poodle",
+"Mexican hairless dog",
+"grey wolf",
+"Alaskan tundra wolf",
+"red wolf",
+"coyote",
+"dingo",
+"dhole",
+"African wild dog",
+"hyena",
+"red fox",
+"kit fox",
+"Arctic fox",
+"grey fox",
+"tabby cat",
+"tiger cat",
+"Persian cat",
+"Siamese cat",
+"Egyptian Mau",
+"cougar",
+"lynx",
+"leopard",
+"snow leopard",
+"jaguar",
+"lion",
+"tiger",
+"cheetah",
+"brown bear",
+"American black bear",
+"polar bear",
+"sloth bear",
+"mongoose",
+"meerkat",
+"tiger beetle",
+"ladybug",
+"ground beetle",
+"longhorn beetle",
+"leaf beetle",
+"dung beetle",
+"rhinoceros beetle",
+"weevil",
+"fly",
+"bee",
+"ant",
+"grasshopper",
+"cricket",
+"stick insect",
+"cockroach",
+"mantis",
+"cicada",
+"leafhopper",
+"lacewing",
+"dragonfly",
+"damselfly",
+"red admiral",
+"ringlet",
+"monarch butterfly",
+"small white",
+"sulphur butterfly",
+"gossamer-winged butterfly",
+"starfish",
+"sea urchin",
+"sea cucumber",
+"cottontail rabbit",
+"hare",
+"Angora rabbit",
+"hamster",
+"porcupine",
+"fox squirrel",
+"marmot",
+"beaver",
+"guinea pig",
+"common sorrel",
+"zebra",
+"pig",
+"wild boar",
+"warthog",
+"hippopotamus",
+"ox",
+"water buffalo",
+"bison",
+"ram",
+"bighorn sheep",
+"Alpine ibex",
+"hartebeest",
+"impala",
+"gazelle",
+"dromedary",
+"llama",
+"weasel",
+"mink",
+"European polecat",
+"black-footed ferret",
+"otter",
+"skunk",
+"badger",
+"armadillo",
+"three-toed sloth",
+"orangutan",
+"gorilla",
+"chimpanzee",
+"gibbon",
+"siamang",
+"guenon",
+"patas monkey",
+"baboon",
+"macaque",
+"langur",
+"black-and-white colobus",
+"proboscis monkey",
+"marmoset",
+"white-headed capuchin",
+"howler monkey",
+"titi",
+"Geoffroy's spider monkey",
+"common squirrel monkey",
+"ring-tailed lemur",
+"indri",
+"Asian elephant",
+"African bush elephant",
+"red panda",
+"giant panda",
+"snoek",
+"eel",
+"coho salmon",
+"rock beauty",
+"clownfish",
+"sturgeon",
+"garfish",
+"lionfish",
+"pufferfish",
+"abacus",
+"abaya",
+"academic gown",
+"accordion",
+"acoustic guitar",
+"aircraft carrier",
+"airliner",
+"airship",
+"altar",
+"ambulance",
+"amphibious vehicle",
+"analog clock",
+"apiary",
+"apron",
+"waste container",
+"assault rifle",
+"backpack",
+"bakery",
+"balance beam",
+"balloon",
+"ballpoint pen",
+"Band-Aid",
+"banjo",
+"baluster",
+"barbell",
+"barber chair",
+"barbershop",
+"barn",
+"barometer",
+"barrel",
+"wheelbarrow",
+"baseball",
+"basketball",
+"bassinet",
+"bassoon",
+"swimming cap",
+"bath towel",
+"bathtub",
+"station wagon",
+"lighthouse",
+"beaker",
+"military cap",
+"beer bottle",
+"beer glass",
+"bell-cot",
+"bib",
+"tandem bicycle",
+"bikini",
+"ring binder",
+"binoculars",
+"birdhouse",
+"boathouse",
+"bobsleigh",
+"bolo tie",
+"poke bonnet",
+"bookcase",
+"bookstore",
+"bottle cap",
+"bow",
+"bow tie",
+"brass",
+"bra",
+"breakwater",
+"breastplate",
+"broom",
+"bucket",
+"buckle",
+"bulletproof vest",
+"high-speed train",
+"butcher shop",
+"taxicab",
+"cauldron",
+"candle",
+"cannon",
+"canoe",
+"can opener",
+"cardigan",
+"car mirror",
+"carousel",
+"tool kit",
+"carton",
+"car wheel",
+"automated teller machine",
+"cassette",
+"cassette player",
+"castle",
+"catamaran",
+"CD player",
+"cello",
+"mobile phone",
+"chain",
+"chain-link fence",
+"chain mail",
+"chainsaw",
+"chest",
+"chiffonier",
+"chime",
+"china cabinet",
+"Christmas stocking",
+"church",
+"movie theater",
+"cleaver",
+"cliff dwelling",
+"cloak",
+"clogs",
+"cocktail shaker",
+"coffee mug",
+"coffeemaker",
+"coil",
+"combination lock",
+"computer keyboard",
+"confectionery store",
+"container ship",
+"convertible",
+"corkscrew",
+"cornet",
+"cowboy boot",
+"cowboy hat",
+"cradle",
+"crane (machine)",
+"crash helmet",
+"crate",
+"infant bed",
+"Crock Pot",
+"croquet ball",
+"crutch",
+"cuirass",
+"dam",
+"desk",
+"desktop computer",
+"rotary dial telephone",
+"diaper",
+"digital clock",
+"digital watch",
+"dining table",
+"dishcloth",
+"dishwasher",
+"disc brake",
+"dock",
+"dog sled",
+"dome",
+"doormat",
+"drilling rig",
+"drum",
+"drumstick",
+"dumbbell",
+"Dutch oven",
+"electric fan",
+"electric guitar",
+"electric locomotive",
+"entertainment center",
+"envelope",
+"espresso machine",
+"face powder",
+"feather boa",
+"filing cabinet",
+"fireboat",
+"fire engine",
+"fire screen sheet",
+"flagpole",
+"flute",
+"folding chair",
+"football helmet",
+"forklift",
+"fountain",
+"fountain pen",
+"four-poster bed",
+"freight car",
+"French horn",
+"frying pan",
+"fur coat",
+"garbage truck",
+"gas mask",
+"gas pump",
+"goblet",
+"go-kart",
+"golf ball",
+"golf cart",
+"gondola",
+"gong",
+"gown",
+"grand piano",
+"greenhouse",
+"grille",
+"grocery store",
+"guillotine",
+"barrette",
+"hair spray",
+"half-track",
+"hammer",
+"hamper",
+"hair dryer",
+"hand-held computer",
+"handkerchief",
+"hard disk drive",
+"harmonica",
+"harp",
+"harvester",
+"hatchet",
+"holster",
+"home theater",
+"honeycomb",
+"hook",
+"hoop skirt",
+"horizontal bar",
+"horse-drawn vehicle",
+"hourglass",
+"iPod",
+"clothes iron",
+"jack-o'-lantern",
+"jeans",
+"jeep",
+"T-shirt",
+"jigsaw puzzle",
+"pulled rickshaw",
+"joystick",
+"kimono",
+"knee pad",
+"knot",
+"lab coat",
+"ladle",
+"lampshade",
+"laptop computer",
+"lawn mower",
+"lens cap",
+"paper knife",
+"library",
+"lifeboat",
+"lighter",
+"limousine",
+"ocean liner",
+"lipstick",
+"slip-on shoe",
+"lotion",
+"speaker",
+"loupe",
+"sawmill",
+"magnetic compass",
+"mail bag",
+"mailbox",
+"tights",
+"tank suit",
+"manhole cover",
+"maraca",
+"marimba",
+"mask",
+"match",
+"maypole",
+"maze",
+"measuring cup",
+"medicine chest",
+"megalith",
+"microphone",
+"microwave oven",
+"military uniform",
+"milk can",
+"minibus",
+"miniskirt",
+"minivan",
+"missile",
+"mitten",
+"mixing bowl",
+"mobile home",
+"Model T",
+"modem",
+"monastery",
+"monitor",
+"moped",
+"mortar",
+"square academic cap",
+"mosque",
+"mosquito net",
+"scooter",
+"mountain bike",
+"tent",
+"computer mouse",
+"mousetrap",
+"moving van",
+"muzzle",
+"nail",
+"neck brace",
+"necklace",
+"nipple",
+"notebook computer",
+"obelisk",
+"oboe",
+"ocarina",
+"odometer",
+"oil filter",
+"organ",
+"oscilloscope",
+"overskirt",
+"bullock cart",
+"oxygen mask",
+"packet",
+"paddle",
+"paddle wheel",
+"padlock",
+"paintbrush",
+"pajamas",
+"palace",
+"pan flute",
+"paper towel",
+"parachute",
+"parallel bars",
+"park bench",
+"parking meter",
+"passenger car",
+"patio",
+"payphone",
+"pedestal",
+"pencil case",
+"pencil sharpener",
+"perfume",
+"Petri dish",
+"photocopier",
+"plectrum",
+"Pickelhaube",
+"picket fence",
+"pickup truck",
+"pier",
+"piggy bank",
+"pill bottle",
+"pillow",
+"ping-pong ball",
+"pinwheel",
+"pirate ship",
+"pitcher",
+"hand plane",
+"planetarium",
+"plastic bag",
+"plate rack",
+"plow",
+"plunger",
+"Polaroid camera",
+"pole",
+"police van",
+"poncho",
+"billiard table",
+"soda bottle",
+"pot",
+"potter's wheel",
+"power drill",
+"prayer rug",
+"printer",
+"prison",
+"projectile",
+"projector",
+"hockey puck",
+"punching bag",
+"purse",
+"quill",
+"quilt",
+"race car",
+"racket",
+"radiator",
+"radio",
+"radio telescope",
+"rain barrel",
+"recreational vehicle",
+"reel",
+"reflex camera",
+"refrigerator",
+"remote control",
+"restaurant",
+"revolver",
+"rifle",
+"rocking chair",
+"rotisserie",
+"eraser",
+"rugby ball",
+"ruler",
+"running shoe",
+"safe",
+"safety pin",
+"salt shaker",
+"sandal",
+"sarong",
+"saxophone",
+"scabbard",
+"weighing scale",
+"school bus",
+"schooner",
+"scoreboard",
+"CRT screen",
+"screw",
+"screwdriver",
+"seat belt",
+"sewing machine",
+"shield",
+"shoe store",
+"shoji",
+"shopping basket",
+"shopping cart",
+"shovel",
+"shower cap",
+"shower curtain",
+"ski",
+"ski mask",
+"sleeping bag",
+"slide rule",
+"sliding door",
+"slot machine",
+"snorkel",
+"snowmobile",
+"snowplow",
+"soap dispenser",
+"soccer ball",
+"sock",
+"solar thermal collector",
+"sombrero",
+"soup bowl",
+"space bar",
+"space heater",
+"space shuttle",
+"spatula",
+"motorboat",
+"spider web",
+"spindle",
+"sports car",
+"spotlight",
+"stage",
+"steam locomotive",
+"through arch bridge",
+"steel drum",
+"stethoscope",
+"scarf",
+"stone wall",
+"stopwatch",
+"stove",
+"strainer",
+"tram",
+"stretcher",
+"couch",
+"stupa",
+"submarine",
+"suit",
+"sundial",
+"sunglass",
+"sunglasses",
+"sunscreen",
+"suspension bridge",
+"mop",
+"sweatshirt",
+"swimsuit",
+"swing",
+"switch",
+"syringe",
+"table lamp",
+"tank",
+"tape player",
+"teapot",
+"teddy bear",
+"television",
+"tennis ball",
+"thatched roof",
+"front curtain",
+"thimble",
+"threshing machine",
+"throne",
+"tile roof",
+"toaster",
+"tobacco shop",
+"toilet seat",
+"torch",
+"totem pole",
+"tow truck",
+"toy store",
+"tractor",
+"semi-trailer truck",
+"tray",
+"trench coat",
+"tricycle",
+"trimaran",
+"tripod",
+"triumphal arch",
+"trolleybus",
+"trombone",
+"tub",
+"turnstile",
+"typewriter keyboard",
+"umbrella",
+"unicycle",
+"upright piano",
+"vacuum cleaner",
+"vase",
+"vault",
+"velvet",
+"vending machine",
+"vestment",
+"viaduct",
+"violin",
+"volleyball",
+"waffle iron",
+"wall clock",
+"wallet",
+"wardrobe",
+"military aircraft",
+"sink",
+"washing machine",
+"water bottle",
+"water jug",
+"water tower",
+"whiskey jug",
+"whistle",
+"wig",
+"window screen",
+"window shade",
+"Windsor tie",
+"wine bottle",
+"wing",
+"wok",
+"wooden spoon",
+"wool",
+"split-rail fence",
+"shipwreck",
+"yawl",
+"yurt",
+"website",
+"comic book",
+"crossword",
+"traffic sign",
+"traffic light",
+"dust jacket",
+"menu",
+"plate",
+"guacamole",
+"consomme",
+"hot pot",
+"trifle",
+"ice cream",
+"ice pop",
+"baguette",
+"bagel",
+"pretzel",
+"cheeseburger",
+"hot dog",
+"mashed potato",
+"cabbage",
+"broccoli",
+"cauliflower",
+"zucchini",
+"spaghetti squash",
+"acorn squash",
+"butternut squash",
+"cucumber",
+"artichoke",
+"bell pepper",
+"cardoon",
+"mushroom",
+"Granny Smith",
+"strawberry",
+"orange",
+"lemon",
+"fig",
+"pineapple",
+"banana",
+"jackfruit",
+"custard apple",
+"pomegranate",
+"hay",
+"carbonara",
+"chocolate syrup",
+"dough",
+"meatloaf",
+"pizza",
+"pot pie",
+"burrito",
+"red wine",
+"espresso",
+"cup",
+"eggnog",
+"alp",
+"bubble",
+"cliff",
+"coral reef",
+"geyser",
+"lakeshore",
+"promontory",
+"shoal",
+"seashore",
+"valley",
+"volcano",
+"baseball player",
+"bridegroom",
+"scuba diver",
+"rapeseed",
+"daisy",
+"yellow lady's slipper",
+"corn",
+"acorn",
+"rose hip",
+"horse chestnut seed",
+"coral fungus",
+"agaric",
+"gyromitra",
+"stinkhorn mushroom",
+"earth star",
+"hen-of-the-woods",
+"bolete",
+"ear of corn",
+"toilet paper"]

pl_train.py

@@ -0,0 +1,361 @@
+import os
+from datetime import datetime
+from typing import Optional, Tuple
+import glob
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+from torchvision import transforms, models, datasets
+from pytorch_lightning import LightningModule, Trainer
+from pytorch_lightning.callbacks import ModelCheckpoint, TQDMProgressBar
+from loguru import logger
+
+class CustomProgressBar(TQDMProgressBar):
+    def __init__(self):
+        super().__init__()
+        self.enable = True
+
+    def on_train_epoch_start(self, trainer, pl_module):
+        super().on_train_epoch_start(trainer, pl_module)
+        logger.info(f"\n{'='*20} Epoch {trainer.current_epoch} {'='*20}")
+
+class ImageNetModule(LightningModule):
+    def __init__(
+        self,
+        learning_rate: float = 0.1,
+        momentum: float = 0.9,
+        weight_decay: float = 1e-4,
+        batch_size: int = 256,
+        num_workers: int = 16,
+        max_epochs: int = 90,
+        train_path: str = "path/to/imagenet",
+        val_path: str = "path/to/imagenet",
+        checkpoint_dir: str = "checkpoints"
+    ):
+        super().__init__()
+        # self.save_hyperparameters()
+        
+        # Model
+        self.model = models.resnet50(weights=None)
+        
+        # Training parameters
+        self.learning_rate = learning_rate
+        self.momentum = momentum
+        self.weight_decay = weight_decay
+        self.batch_size = batch_size
+        self.num_workers = num_workers
+        self.max_epochs = max_epochs
+        self.train_path = train_path
+        self.val_path = val_path
+        self.checkpoint_dir = checkpoint_dir
+        
+        # Metrics tracking
+        self.training_step_outputs = []
+        self.validation_step_outputs = []
+        self.best_val_acc = 0.0
+        
+        # Set up transforms
+        self.train_transforms = transforms.Compose([
+            transforms.RandomResizedCrop(224),
+            transforms.RandomHorizontalFlip(),
+            transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], 
+                              std=[0.229, 0.224, 0.225])
+        ])
+        
+        self.val_transforms = transforms.Compose([
+            transforms.Resize(256),
+            transforms.CenterCrop(224),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], 
+                              std=[0.229, 0.224, 0.225])
+        ])
+
+    def forward(self, x):
+        return self.model(x)
+
+    def training_step(self, batch, batch_idx):
+        images, labels = batch
+        outputs = self(images)
+        loss = F.cross_entropy(outputs, labels)
+        
+        # Calculate accuracy
+        _, predicted = torch.max(outputs.data, 1)
+        correct = (predicted == labels).sum().item()
+        accuracy = (correct / labels.size(0))*100
+        
+        # Log metrics for this step
+        self.log('train_loss', loss, on_step=False, on_epoch=True, prog_bar=True)
+        self.log('train_acc', accuracy, on_step=False, on_epoch=True, prog_bar=True)
+        
+        self.training_step_outputs.append({
+            'loss': loss.detach(),
+            'acc': torch.tensor(accuracy)
+        })
+        
+        return loss
+
+    def on_train_epoch_end(self):
+        if not self.training_step_outputs:
+            print("Warning: No training outputs available for this epoch")
+            return
+        avg_loss = torch.stack([x['loss'] for x in self.training_step_outputs]).mean()
+        avg_acc = torch.stack([x['acc'] for x in self.training_step_outputs]).mean()
+        
+        # Get current learning rate
+        current_lr = self.optimizers().param_groups[0]['lr']
+        
+        logger.info(f"Training metrics - Loss: {avg_loss:.4f}, Accuracy: {avg_acc:.4f}, LR: {current_lr:.6f}")
+        
+        self.training_step_outputs.clear()
+
+    def validation_step(self, batch, batch_idx):
+        images, labels = batch
+        outputs = self(images)
+        loss = F.cross_entropy(outputs, labels)
+        
+        # Calculate accuracy
+        _, predicted = torch.max(outputs.data, 1)
+        correct = (predicted == labels).sum().item()
+        accuracy = (correct / labels.size(0))*100
+        
+        # Log metrics for this step
+        self.log('val_loss', loss, on_step=False, on_epoch=True, prog_bar=True)
+        self.log('val_acc', accuracy, on_step=False, on_epoch=True, prog_bar=True)
+        
+        self.validation_step_outputs.append({
+            'val_loss': loss.detach(),
+            'val_acc': torch.tensor(accuracy)
+        })
+        
+        return {'val_loss': loss, 'val_acc': accuracy}
+
+    def on_validation_epoch_end(self):
+        avg_loss = torch.stack([x['val_loss'] for x in self.validation_step_outputs]).mean()
+        avg_acc = torch.stack([x['val_acc'] for x in self.validation_step_outputs]).mean()
+        
+        # Log final validation metrics
+        self.log('val_loss_epoch', avg_loss)
+        self.log('val_acc_epoch', avg_acc)
+        
+        # Save checkpoint if validation accuracy improves
+        if avg_acc > self.best_val_acc:
+            self.best_val_acc = avg_acc
+            checkpoint_path = os.path.join(
+                self.checkpoint_dir,
+                f"resnet50-epoch{self.current_epoch:02d}-acc{avg_acc:.4f}.ckpt"
+            )
+            self.trainer.save_checkpoint(checkpoint_path)
+            logger.info(f"New best validation accuracy: {avg_acc:.4f}. Saved checkpoint to {checkpoint_path}")
+        
+        logger.info(f"Validation metrics - Loss: {avg_loss:.4f}, Accuracy: {avg_acc:.4f}")
+        
+        self.validation_step_outputs.clear()
+
+    def train_dataloader(self):
+        train_dataset = datasets.ImageFolder(
+            self.train_path,
+            transform=self.train_transforms
+        )
+        return DataLoader(
+            train_dataset,
+            batch_size=self.batch_size,
+            shuffle=True,
+            num_workers=self.num_workers,
+            pin_memory=True
+        )
+
+    def val_dataloader(self):
+        val_dataset = datasets.ImageFolder(
+            self.val_path,
+            transform=self.val_transforms
+        )
+        return DataLoader(
+            val_dataset,
+            batch_size=self.batch_size,
+            shuffle=False,
+            num_workers=self.num_workers,
+            pin_memory=True
+        )
+
+    def configure_optimizers(self):
+        optimizer = torch.optim.SGD(
+            self.parameters(),
+            lr=self.learning_rate,
+            momentum=self.momentum,
+            weight_decay=self.weight_decay
+        )
+        
+        # OneCycleLR scheduler
+        scheduler = torch.optim.lr_scheduler.OneCycleLR(
+            optimizer,
+            max_lr=self.learning_rate,
+            epochs=self.max_epochs,
+            steps_per_epoch=len(self.train_dataloader()),
+            pct_start=0.3,
+            anneal_strategy='cos',
+            div_factor=25.0,
+            cycle_momentum=True,
+            base_momentum=0.85,
+            max_momentum=0.95,
+        )
+        
+        return {
+            "optimizer": optimizer,
+            "lr_scheduler": {
+                "scheduler": scheduler,
+                "interval": "step"
+            }
+        }
+
+def setup_logging(log_dir="logs"):
+    os.makedirs(log_dir, exist_ok=True)
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    log_file = os.path.join(log_dir, f"training_{timestamp}.log")
+    
+    logger.remove()
+    logger.add(
+        lambda msg: print(msg),
+        format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | {message}",
+        colorize=True,
+        level="INFO"
+    )
+    
+    logger.add(
+        log_file,
+        format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {message}",
+        level="INFO",
+        rotation="100 MB",
+        retention="30 days"
+    )
+    
+    logger.info(f"Logging setup complete. Logs will be saved to: {log_file}")
+    return log_file
+
+def find_latest_checkpoint(checkpoint_dir: str) -> Optional[str]:
+    """Find the latest checkpoint file using various possible naming patterns."""
+    # Look for checkpoint files with different possible patterns
+    patterns = [
+        "*.ckpt",  # Generic checkpoint files
+        "resnet50-epoch*.ckpt",  # Our custom format
+        "*epoch=*.ckpt",  # PyTorch Lightning default format
+        "checkpoint_epoch*.ckpt"  # Another common format
+    ]
+    
+    all_checkpoints = []
+    for pattern in patterns:
+        checkpoint_pattern = os.path.join(checkpoint_dir, pattern)
+        all_checkpoints.extend(glob.glob(checkpoint_pattern))
+    
+    if not all_checkpoints:
+        logger.info("No existing checkpoints found.")
+        return None
+    
+    def extract_info(checkpoint_path: str) -> Tuple[int, float]:
+        """Extract epoch and optional accuracy from checkpoint filename."""
+        filename = os.path.basename(checkpoint_path)
+        
+        # Try different patterns to extract epoch number
+        epoch_patterns = [
+            r'epoch=(\d+)',  # matches epoch=X
+            r'epoch(\d+)',   # matches epochX
+            r'epoch[_-](\d+)',  # matches epoch_X or epoch-X
+        ]
+        
+        epoch = None
+        for pattern in epoch_patterns:
+            match = re.search(pattern, filename)
+            if match:
+                epoch = int(match.group(1))
+                break
+        
+        # If no epoch found, try to get from file modification time
+        if epoch is None:
+            epoch = int(os.path.getmtime(checkpoint_path))
+        
+        # Try to extract accuracy if present
+        acc_match = re.search(r'acc[_-]?([\d.]+)', filename)
+        acc = float(acc_match.group(1)) if acc_match else 0.0
+        
+        return epoch, acc
+    
+    try:
+        latest_checkpoint = max(all_checkpoints, key=lambda x: extract_info(x)[0])
+        epoch, acc = extract_info(latest_checkpoint)
+        logger.info(f"Found latest checkpoint: {latest_checkpoint}")
+        logger.info(f"Epoch: {epoch}" + (f", Accuracy: {acc:.4f}" if acc > 0 else ""))
+        return latest_checkpoint
+    except Exception as e:
+        logger.error(f"Error processing checkpoints: {str(e)}")
+        # If there's any error in parsing, return the most recently modified file
+        latest_checkpoint = max(all_checkpoints, key=os.path.getmtime)
+        logger.info(f"Falling back to most recently modified checkpoint: {latest_checkpoint}")
+        return latest_checkpoint
+
+
+def main():
+    checkpoint_dir = "/home/ec2-user/ebs/volumes/era_session9"
+    log_file = setup_logging(log_dir=checkpoint_dir)
+    
+    logger.info("Starting training with configuration:")
+    logger.info(f"PyTorch version: {torch.__version__}")
+    logger.info(f"CUDA available: {torch.cuda.is_available()}")
+    if torch.cuda.is_available():
+        logger.info(f"CUDA device count: {torch.cuda.device_count()}")
+        logger.info(f"CUDA devices: {[torch.cuda.get_device_name(i) for i in range(torch.cuda.device_count())]}")
+    
+    # Find latest checkpoint
+    # latest_checkpoint = find_latest_checkpoint(checkpoint_dir)
+    latest_checkpoint = "/home/ec2-user/ebs/volumes/era_session9/resnet50-epoch18-acc53.7369.ckpt"
+    
+    model = ImageNetModule(
+        learning_rate=0.156,
+        batch_size=256,
+        num_workers=16,
+        max_epochs=60,
+        train_path="/home/ec2-user/ebs/volumes/imagenet/ILSVRC/Data/CLS-LOC/train",
+        val_path="/home/ec2-user/ebs/volumes/imagenet/imagenet_validation",
+        checkpoint_dir=checkpoint_dir
+    )
+    
+    logger.info(f"Model configuration:")
+    logger.info(f"Learning rate: {model.learning_rate}")
+    logger.info(f"Batch size: {model.batch_size}")
+    logger.info(f"Number of workers: {model.num_workers}")
+    logger.info(f"Max epochs: {model.max_epochs}")
+    
+    progress_bar = CustomProgressBar()
+    
+    trainer = Trainer(
+        max_epochs=60,
+        accelerator="gpu",
+        devices=4,
+        strategy="ddp",
+        precision=16,
+        callbacks=[progress_bar],
+        enable_progress_bar=True,
+    )
+    
+    logger.info("Starting training")
+    
+    try:
+        if latest_checkpoint:
+            logger.info(f"Resuming training from checkpoint: {latest_checkpoint}")
+            trainer.fit(model, ckpt_path=latest_checkpoint)
+        else:
+            logger.info("Starting training from scratch")
+            trainer.fit(model)
+            
+        logger.info("Training completed successfully")
+    except Exception as e:
+        logger.error(f"Training failed with error: {str(e)}")
+        raise
+    finally:
+        logger.info(f"Training session ended. Log file: {log_file}")
+
+if __name__ == "__main__":
+    main()
+    # pass

requirements.txt

@@ -0,0 +1,7 @@
+typing
+torch
+torchvision
+pytorch-lightning
+loguru
+Pillow
+huggingface_hub