BiliSakura commited on 27 days ago

Commit

86e180f

verified ·

1 Parent(s): dd09d1e

Clean repo before reupload from local JLT-diffusers

Browse files

Files changed (17) hide show

JLT-B-1-256/model_index.json +0 -1021
JLT-B-1-256/pipeline.py +0 -548
JLT-B-1-256/scheduler/scheduler_config.json +0 -6
JLT-B-1-256/transformer/config.json +0 -21
JLT-B-1-256/transformer/diffusion_pytorch_model.safetensors +0 -3
JLT-B-1-256/transformer/transformer_jlt.py +0 -639
JLT-B-1-256/vae/config.json +0 -40
JLT-B-1-256/vae/diffusion_pytorch_model.safetensors +0 -3
JLT-H-1-256/model_index.json +0 -1021
JLT-H-1-256/pipeline.py +0 -548
JLT-H-1-256/scheduler/scheduler_config.json +0 -6
JLT-H-1-256/transformer/__pycache__/transformer_jlt.cpython-312.pyc +0 -0
JLT-H-1-256/transformer/config.json +0 -21
JLT-H-1-256/transformer/diffusion_pytorch_model.safetensors +0 -3
JLT-H-1-256/transformer/transformer_jlt.py +0 -648
JLT-H-1-256/vae/config.json +0 -40
JLT-H-1-256/vae/diffusion_pytorch_model.safetensors +0 -3

JLT-B-1-256/model_index.json DELETED Viewed

@@ -1,1021 +0,0 @@
-{
-  "_class_name": [
-    "pipeline",
-    "JLTPipeline"
-  ],
-  "_diffusers_version": "0.36.0",
-  "scheduler": [
-    "diffusers",
-    "FlowMatchHeunDiscreteScheduler"
-  ],
-  "transformer": [
-    "transformer_jlt",
-    "JLTTransformer2DModel"
-  ],
-  "id2label": {
-    "0": "tench, Tinca tinca",
-    "1": "goldfish, Carassius auratus",
-    "2": "great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias",
-    "3": "tiger shark, Galeocerdo cuvieri",
-    "4": "hammerhead, hammerhead shark",
-    "5": "electric ray, crampfish, numbfish, torpedo",
-    "6": "stingray",
-    "7": "cock",
-    "8": "hen",
-    "9": "ostrich, Struthio camelus",
-    "10": "brambling, Fringilla montifringilla",
-    "11": "goldfinch, Carduelis carduelis",
-    "12": "house finch, linnet, Carpodacus mexicanus",
-    "13": "junco, snowbird",
-    "14": "indigo bunting, indigo finch, indigo bird, Passerina cyanea",
-    "15": "robin, American robin, Turdus migratorius",
-    "16": "bulbul",
-    "17": "jay",
-    "18": "magpie",
-    "19": "chickadee",
-    "20": "water ouzel, dipper",
-    "21": "kite",
-    "22": "bald eagle, American eagle, Haliaeetus leucocephalus",
-    "23": "vulture",
-    "24": "great grey owl, great gray owl, Strix nebulosa",
-    "25": "European fire salamander, Salamandra salamandra",
-    "26": "common newt, Triturus vulgaris",
-    "27": "eft",
-    "28": "spotted salamander, Ambystoma maculatum",
-    "29": "axolotl, mud puppy, Ambystoma mexicanum",
-    "30": "bullfrog, Rana catesbeiana",
-    "31": "tree frog, tree-frog",
-    "32": "tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui",
-    "33": "loggerhead, loggerhead turtle, Caretta caretta",
-    "34": "leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea",
-    "35": "mud turtle",
-    "36": "terrapin",
-    "37": "box turtle, box tortoise",
-    "38": "banded gecko",
-    "39": "common iguana, iguana, Iguana iguana",
-    "40": "American chameleon, anole, Anolis carolinensis",
-    "41": "whiptail, whiptail lizard",
-    "42": "agama",
-    "43": "frilled lizard, Chlamydosaurus kingi",
-    "44": "alligator lizard",
-    "45": "Gila monster, Heloderma suspectum",
-    "46": "green lizard, Lacerta viridis",
-    "47": "African chameleon, Chamaeleo chamaeleon",
-    "48": "Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis",
-    "49": "African crocodile, Nile crocodile, Crocodylus niloticus",
-    "50": "American alligator, Alligator mississipiensis",
-    "51": "triceratops",
-    "52": "thunder snake, worm snake, Carphophis amoenus",
-    "53": "ringneck snake, ring-necked snake, ring snake",
-    "54": "hognose snake, puff adder, sand viper",
-    "55": "green snake, grass snake",
-    "56": "king snake, kingsnake",
-    "57": "garter snake, grass snake",
-    "58": "water snake",
-    "59": "vine snake",
-    "60": "night snake, Hypsiglena torquata",
-    "61": "boa constrictor, Constrictor constrictor",
-    "62": "rock python, rock snake, Python sebae",
-    "63": "Indian cobra, Naja naja",
-    "64": "green mamba",
-    "65": "sea snake",
-    "66": "horned viper, cerastes, sand viper, horned asp, Cerastes cornutus",
-    "67": "diamondback, diamondback rattlesnake, Crotalus adamanteus",
-    "68": "sidewinder, horned rattlesnake, Crotalus cerastes",
-    "69": "trilobite",
-    "70": "harvestman, daddy longlegs, Phalangium opilio",
-    "71": "scorpion",
-    "72": "black and gold garden spider, Argiope aurantia",
-    "73": "barn spider, Araneus cavaticus",
-    "74": "garden spider, Aranea diademata",
-    "75": "black widow, Latrodectus mactans",
-    "76": "tarantula",
-    "77": "wolf spider, hunting spider",
-    "78": "tick",
-    "79": "centipede",
-    "80": "black grouse",
-    "81": "ptarmigan",
-    "82": "ruffed grouse, partridge, Bonasa umbellus",
-    "83": "prairie chicken, prairie grouse, prairie fowl",
-    "84": "peacock",
-    "85": "quail",
-    "86": "partridge",
-    "87": "African grey, African gray, Psittacus erithacus",
-    "88": "macaw",
-    "89": "sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita",
-    "90": "lorikeet",
-    "91": "coucal",
-    "92": "bee eater",
-    "93": "hornbill",
-    "94": "hummingbird",
-    "95": "jacamar",
-    "96": "toucan",
-    "97": "drake",
-    "98": "red-breasted merganser, Mergus serrator",
-    "99": "goose",
-    "100": "black swan, Cygnus atratus",
-    "101": "tusker",
-    "102": "echidna, spiny anteater, anteater",
-    "103": "platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus",
-    "104": "wallaby, brush kangaroo",
-    "105": "koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus",
-    "106": "wombat",
-    "107": "jellyfish",
-    "108": "sea anemone, anemone",
-    "109": "brain coral",
-    "110": "flatworm, platyhelminth",
-    "111": "nematode, nematode worm, roundworm",
-    "112": "conch",
-    "113": "snail",
-    "114": "slug",
-    "115": "sea slug, nudibranch",
-    "116": "chiton, coat-of-mail shell, sea cradle, polyplacophore",
-    "117": "chambered nautilus, pearly nautilus, nautilus",
-    "118": "Dungeness crab, Cancer magister",
-    "119": "rock crab, Cancer irroratus",
-    "120": "fiddler crab",
-    "121": "king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica",
-    "122": "American lobster, Northern lobster, Maine lobster, Homarus americanus",
-    "123": "spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish",
-    "124": "crayfish, crawfish, crawdad, crawdaddy",
-    "125": "hermit crab",
-    "126": "isopod",
-    "127": "white stork, Ciconia ciconia",
-    "128": "black stork, Ciconia nigra",
-    "129": "spoonbill",
-    "130": "flamingo",
-    "131": "little blue heron, Egretta caerulea",
-    "132": "American egret, great white heron, Egretta albus",
-    "133": "bittern",
-    "134": "crane",
-    "135": "limpkin, Aramus pictus",
-    "136": "European gallinule, Porphyrio porphyrio",
-    "137": "American coot, marsh hen, mud hen, water hen, Fulica americana",
-    "138": "bustard",
-    "139": "ruddy turnstone, Arenaria interpres",
-    "140": "red-backed sandpiper, dunlin, Erolia alpina",
-    "141": "redshank, Tringa totanus",
-    "142": "dowitcher",
-    "143": "oystercatcher, oyster catcher",
-    "144": "pelican",
-    "145": "king penguin, Aptenodytes patagonica",
-    "146": "albatross, mollymawk",
-    "147": "grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus",
-    "148": "killer whale, killer, orca, grampus, sea wolf, Orcinus orca",
-    "149": "dugong, Dugong dugon",
-    "150": "sea lion",
-    "151": "Chihuahua",
-    "152": "Japanese spaniel",
-    "153": "Maltese dog, Maltese terrier, Maltese",
-    "154": "Pekinese, Pekingese, Peke",
-    "155": "Shih-Tzu",
-    "156": "Blenheim spaniel",
-    "157": "papillon",
-    "158": "toy terrier",
-    "159": "Rhodesian ridgeback",
-    "160": "Afghan hound, Afghan",
-    "161": "basset, basset hound",
-    "162": "beagle",
-    "163": "bloodhound, sleuthhound",
-    "164": "bluetick",
-    "165": "black-and-tan coonhound",
-    "166": "Walker hound, Walker foxhound",
-    "167": "English foxhound",
-    "168": "redbone",
-    "169": "borzoi, Russian wolfhound",
-    "170": "Irish wolfhound",
-    "171": "Italian greyhound",
-    "172": "whippet",
-    "173": "Ibizan hound, Ibizan Podenco",
-    "174": "Norwegian elkhound, elkhound",
-    "175": "otterhound, otter hound",
-    "176": "Saluki, gazelle hound",
-    "177": "Scottish deerhound, deerhound",
-    "178": "Weimaraner",
-    "179": "Staffordshire bullterrier, Staffordshire bull terrier",
-    "180": "American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier",
-    "181": "Bedlington terrier",
-    "182": "Border terrier",
-    "183": "Kerry blue terrier",
-    "184": "Irish terrier",
-    "185": "Norfolk terrier",
-    "186": "Norwich terrier",
-    "187": "Yorkshire terrier",
-    "188": "wire-haired fox terrier",
-    "189": "Lakeland terrier",
-    "190": "Sealyham terrier, Sealyham",
-    "191": "Airedale, Airedale terrier",
-    "192": "cairn, cairn terrier",
-    "193": "Australian terrier",
-    "194": "Dandie Dinmont, Dandie Dinmont terrier",
-    "195": "Boston bull, Boston terrier",
-    "196": "miniature schnauzer",
-    "197": "giant schnauzer",
-    "198": "standard schnauzer",
-    "199": "Scotch terrier, Scottish terrier, Scottie",
-    "200": "Tibetan terrier, chrysanthemum dog",
-    "201": "silky terrier, Sydney silky",
-    "202": "soft-coated wheaten terrier",
-    "203": "West Highland white terrier",
-    "204": "Lhasa, Lhasa apso",
-    "205": "flat-coated retriever",
-    "206": "curly-coated retriever",
-    "207": "golden retriever",
-    "208": "Labrador retriever",
-    "209": "Chesapeake Bay retriever",
-    "210": "German short-haired pointer",
-    "211": "vizsla, Hungarian pointer",
-    "212": "English setter",
-    "213": "Irish setter, red setter",
-    "214": "Gordon setter",
-    "215": "Brittany spaniel",
-    "216": "clumber, clumber spaniel",
-    "217": "English springer, English springer spaniel",
-    "218": "Welsh springer spaniel",
-    "219": "cocker spaniel, English cocker spaniel, cocker",
-    "220": "Sussex spaniel",
-    "221": "Irish water spaniel",
-    "222": "kuvasz",
-    "223": "schipperke",
-    "224": "groenendael",
-    "225": "malinois",
-    "226": "briard",
-    "227": "kelpie",
-    "228": "komondor",
-    "229": "Old English sheepdog, bobtail",
-    "230": "Shetland sheepdog, Shetland sheep dog, Shetland",
-    "231": "collie",
-    "232": "Border collie",
-    "233": "Bouvier des Flandres, Bouviers des Flandres",
-    "234": "Rottweiler",
-    "235": "German shepherd, German shepherd dog, German police dog, alsatian",
-    "236": "Doberman, Doberman pinscher",
-    "237": "miniature pinscher",
-    "238": "Greater Swiss Mountain dog",
-    "239": "Bernese mountain dog",
-    "240": "Appenzeller",
-    "241": "EntleBucher",
-    "242": "boxer",
-    "243": "bull mastiff",
-    "244": "Tibetan mastiff",
-    "245": "French bulldog",
-    "246": "Great Dane",
-    "247": "Saint Bernard, St Bernard",
-    "248": "Eskimo dog, husky",
-    "249": "malamute, malemute, Alaskan malamute",
-    "250": "Siberian husky",
-    "251": "dalmatian, coach dog, carriage dog",
-    "252": "affenpinscher, monkey pinscher, monkey dog",
-    "253": "basenji",
-    "254": "pug, pug-dog",
-    "255": "Leonberg",
-    "256": "Newfoundland, Newfoundland dog",
-    "257": "Great Pyrenees",
-    "258": "Samoyed, Samoyede",
-    "259": "Pomeranian",
-    "260": "chow, chow chow",
-    "261": "keeshond",
-    "262": "Brabancon griffon",
-    "263": "Pembroke, Pembroke Welsh corgi",
-    "264": "Cardigan, Cardigan Welsh corgi",
-    "265": "toy poodle",
-    "266": "miniature poodle",
-    "267": "standard poodle",
-    "268": "Mexican hairless",
-    "269": "timber wolf, grey wolf, gray wolf, Canis lupus",
-    "270": "white wolf, Arctic wolf, Canis lupus tundrarum",
-    "271": "red wolf, maned wolf, Canis rufus, Canis niger",
-    "272": "coyote, prairie wolf, brush wolf, Canis latrans",
-    "273": "dingo, warrigal, warragal, Canis dingo",
-    "274": "dhole, Cuon alpinus",
-    "275": "African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus",
-    "276": "hyena, hyaena",
-    "277": "red fox, Vulpes vulpes",
-    "278": "kit fox, Vulpes macrotis",
-    "279": "Arctic fox, white fox, Alopex lagopus",
-    "280": "grey fox, gray fox, Urocyon cinereoargenteus",
-    "281": "tabby, tabby cat",
-    "282": "tiger cat",
-    "283": "Persian cat",
-    "284": "Siamese cat, Siamese",
-    "285": "Egyptian cat",
-    "286": "cougar, puma, catamount, mountain lion, painter, panther, Felis concolor",
-    "287": "lynx, catamount",
-    "288": "leopard, Panthera pardus",
-    "289": "snow leopard, ounce, Panthera uncia",
-    "290": "jaguar, panther, Panthera onca, Felis onca",
-    "291": "lion, king of beasts, Panthera leo",
-    "292": "tiger, Panthera tigris",
-    "293": "cheetah, chetah, Acinonyx jubatus",
-    "294": "brown bear, bruin, Ursus arctos",
-    "295": "American black bear, black bear, Ursus americanus, Euarctos americanus",
-    "296": "ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus",
-    "297": "sloth bear, Melursus ursinus, Ursus ursinus",
-    "298": "mongoose",
-    "299": "meerkat, mierkat",
-    "300": "tiger beetle",
-    "301": "ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle",
-    "302": "ground beetle, carabid beetle",
-    "303": "long-horned beetle, longicorn, longicorn beetle",
-    "304": "leaf beetle, chrysomelid",
-    "305": "dung beetle",
-    "306": "rhinoceros beetle",
-    "307": "weevil",
-    "308": "fly",
-    "309": "bee",
-    "310": "ant, emmet, pismire",
-    "311": "grasshopper, hopper",
-    "312": "cricket",
-    "313": "walking stick, walkingstick, stick insect",
-    "314": "cockroach, roach",
-    "315": "mantis, mantid",
-    "316": "cicada, cicala",
-    "317": "leafhopper",
-    "318": "lacewing, lacewing fly",
-    "319": "dragonfly, darning needle, devils darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk",
-    "320": "damselfly",
-    "321": "admiral",
-    "322": "ringlet, ringlet butterfly",
-    "323": "monarch, monarch butterfly, milkweed butterfly, Danaus plexippus",
-    "324": "cabbage butterfly",
-    "325": "sulphur butterfly, sulfur butterfly",
-    "326": "lycaenid, lycaenid butterfly",
-    "327": "starfish, sea star",
-    "328": "sea urchin",
-    "329": "sea cucumber, holothurian",
-    "330": "wood rabbit, cottontail, cottontail rabbit",
-    "331": "hare",
-    "332": "Angora, Angora rabbit",
-    "333": "hamster",
-    "334": "porcupine, hedgehog",
-    "335": "fox squirrel, eastern fox squirrel, Sciurus niger",
-    "336": "marmot",
-    "337": "beaver",
-    "338": "guinea pig, Cavia cobaya",
-    "339": "sorrel",
-    "340": "zebra",
-    "341": "hog, pig, grunter, squealer, Sus scrofa",
-    "342": "wild boar, boar, Sus scrofa",
-    "343": "warthog",
-    "344": "hippopotamus, hippo, river horse, Hippopotamus amphibius",
-    "345": "ox",
-    "346": "water buffalo, water ox, Asiatic buffalo, Bubalus bubalis",
-    "347": "bison",
-    "348": "ram, tup",
-    "349": "bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis",
-    "350": "ibex, Capra ibex",
-    "351": "hartebeest",
-    "352": "impala, Aepyceros melampus",
-    "353": "gazelle",
-    "354": "Arabian camel, dromedary, Camelus dromedarius",
-    "355": "llama",
-    "356": "weasel",
-    "357": "mink",
-    "358": "polecat, fitch, foulmart, foumart, Mustela putorius",
-    "359": "black-footed ferret, ferret, Mustela nigripes",
-    "360": "otter",
-    "361": "skunk, polecat, wood pussy",
-    "362": "badger",
-    "363": "armadillo",
-    "364": "three-toed sloth, ai, Bradypus tridactylus",
-    "365": "orangutan, orang, orangutang, Pongo pygmaeus",
-    "366": "gorilla, Gorilla gorilla",
-    "367": "chimpanzee, chimp, Pan troglodytes",
-    "368": "gibbon, Hylobates lar",
-    "369": "siamang, Hylobates syndactylus, Symphalangus syndactylus",
-    "370": "guenon, guenon monkey",
-    "371": "patas, hussar monkey, Erythrocebus patas",
-    "372": "baboon",
-    "373": "macaque",
-    "374": "langur",
-    "375": "colobus, colobus monkey",
-    "376": "proboscis monkey, Nasalis larvatus",
-    "377": "marmoset",
-    "378": "capuchin, ringtail, Cebus capucinus",
-    "379": "howler monkey, howler",
-    "380": "titi, titi monkey",
-    "381": "spider monkey, Ateles geoffroyi",
-    "382": "squirrel monkey, Saimiri sciureus",
-    "383": "Madagascar cat, ring-tailed lemur, Lemur catta",
-    "384": "indri, indris, Indri indri, Indri brevicaudatus",
-    "385": "Indian elephant, Elephas maximus",
-    "386": "African elephant, Loxodonta africana",
-    "387": "lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens",
-    "388": "giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca",
-    "389": "barracouta, snoek",
-    "390": "eel",
-    "391": "coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch",
-    "392": "rock beauty, Holocanthus tricolor",
-    "393": "anemone fish",
-    "394": "sturgeon",
-    "395": "gar, garfish, garpike, billfish, Lepisosteus osseus",
-    "396": "lionfish",
-    "397": "puffer, pufferfish, blowfish, globefish",
-    "398": "abacus",
-    "399": "abaya",
-    "400": "academic gown, academic robe, judge robe",
-    "401": "accordion, piano accordion, squeeze box",
-    "402": "acoustic guitar",
-    "403": "aircraft carrier, carrier, flattop, attack aircraft carrier",
-    "404": "airliner",
-    "405": "airship, dirigible",
-    "406": "altar",
-    "407": "ambulance",
-    "408": "amphibian, amphibious vehicle",
-    "409": "analog clock",
-    "410": "apiary, bee house",
-    "411": "apron",
-    "412": "ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin",
-    "413": "assault rifle, assault gun",
-    "414": "backpack, back pack, knapsack, packsack, rucksack, haversack",
-    "415": "bakery, bakeshop, bakehouse",
-    "416": "balance beam, beam",
-    "417": "balloon",
-    "418": "ballpoint, ballpoint pen, ballpen, Biro",
-    "419": "Band Aid",
-    "420": "banjo",
-    "421": "bannister, banister, balustrade, balusters, handrail",
-    "422": "barbell",
-    "423": "barber chair",
-    "424": "barbershop",
-    "425": "barn",
-    "426": "barometer",
-    "427": "barrel, cask",
-    "428": "barrow, garden cart, lawn cart, wheelbarrow",
-    "429": "baseball",
-    "430": "basketball",
-    "431": "bassinet",
-    "432": "bassoon",
-    "433": "bathing cap, swimming cap",
-    "434": "bath towel",
-    "435": "bathtub, bathing tub, bath, tub",
-    "436": "beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon",
-    "437": "beacon, lighthouse, beacon light, pharos",
-    "438": "beaker",
-    "439": "bearskin, busby, shako",
-    "440": "beer bottle",
-    "441": "beer glass",
-    "442": "bell cote, bell cot",
-    "443": "bib",
-    "444": "bicycle-built-for-two, tandem bicycle, tandem",
-    "445": "bikini, two-piece",
-    "446": "binder, ring-binder",
-    "447": "binoculars, field glasses, opera glasses",
-    "448": "birdhouse",
-    "449": "boathouse",
-    "450": "bobsled, bobsleigh, bob",
-    "451": "bolo tie, bolo, bola tie, bola",
-    "452": "bonnet, poke bonnet",
-    "453": "bookcase",
-    "454": "bookshop, bookstore, bookstall",
-    "455": "bottlecap",
-    "456": "bow",
-    "457": "bow tie, bow-tie, bowtie",
-    "458": "brass, memorial tablet, plaque",
-    "459": "brassiere, bra, bandeau",
-    "460": "breakwater, groin, groyne, mole, bulwark, seawall, jetty",
-    "461": "breastplate, aegis, egis",
-    "462": "broom",
-    "463": "bucket, pail",
-    "464": "buckle",
-    "465": "bulletproof vest",
-    "466": "bullet train, bullet",
-    "467": "butcher shop, meat market",
-    "468": "cab, hack, taxi, taxicab",
-    "469": "caldron, cauldron",
-    "470": "candle, taper, wax light",
-    "471": "cannon",
-    "472": "canoe",
-    "473": "can opener, tin opener",
-    "474": "cardigan",
-    "475": "car mirror",
-    "476": "carousel, carrousel, merry-go-round, roundabout, whirligig",
-    "477": "carpenters kit, tool kit",
-    "478": "carton",
-    "479": "car wheel",
-    "480": "cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM",
-    "481": "cassette",
-    "482": "cassette player",
-    "483": "castle",
-    "484": "catamaran",
-    "485": "CD player",
-    "486": "cello, violoncello",
-    "487": "cellular telephone, cellular phone, cellphone, cell, mobile phone",
-    "488": "chain",
-    "489": "chainlink fence",
-    "490": "chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour",
-    "491": "chain saw, chainsaw",
-    "492": "chest",
-    "493": "chiffonier, commode",
-    "494": "chime, bell, gong",
-    "495": "china cabinet, china closet",
-    "496": "Christmas stocking",
-    "497": "church, church building",
-    "498": "cinema, movie theater, movie theatre, movie house, picture palace",
-    "499": "cleaver, meat cleaver, chopper",
-    "500": "cliff dwelling",
-    "501": "cloak",
-    "502": "clog, geta, patten, sabot",
-    "503": "cocktail shaker",
-    "504": "coffee mug",
-    "505": "coffeepot",
-    "506": "coil, spiral, volute, whorl, helix",
-    "507": "combination lock",
-    "508": "computer keyboard, keypad",
-    "509": "confectionery, confectionary, candy store",
-    "510": "container ship, containership, container vessel",
-    "511": "convertible",
-    "512": "corkscrew, bottle screw",
-    "513": "cornet, horn, trumpet, trump",
-    "514": "cowboy boot",
-    "515": "cowboy hat, ten-gallon hat",
-    "516": "cradle",
-    "517": "crane",
-    "518": "crash helmet",
-    "519": "crate",
-    "520": "crib, cot",
-    "521": "Crock Pot",
-    "522": "croquet ball",
-    "523": "crutch",
-    "524": "cuirass",
-    "525": "dam, dike, dyke",
-    "526": "desk",
-    "527": "desktop computer",
-    "528": "dial telephone, dial phone",
-    "529": "diaper, nappy, napkin",
-    "530": "digital clock",
-    "531": "digital watch",
-    "532": "dining table, board",
-    "533": "dishrag, dishcloth",
-    "534": "dishwasher, dish washer, dishwashing machine",
-    "535": "disk brake, disc brake",
-    "536": "dock, dockage, docking facility",
-    "537": "dogsled, dog sled, dog sleigh",
-    "538": "dome",
-    "539": "doormat, welcome mat",
-    "540": "drilling platform, offshore rig",
-    "541": "drum, membranophone, tympan",
-    "542": "drumstick",
-    "543": "dumbbell",
-    "544": "Dutch oven",
-    "545": "electric fan, blower",
-    "546": "electric guitar",
-    "547": "electric locomotive",
-    "548": "entertainment center",
-    "549": "envelope",
-    "550": "espresso maker",
-    "551": "face powder",
-    "552": "feather boa, boa",
-    "553": "file, file cabinet, filing cabinet",
-    "554": "fireboat",
-    "555": "fire engine, fire truck",
-    "556": "fire screen, fireguard",
-    "557": "flagpole, flagstaff",
-    "558": "flute, transverse flute",
-    "559": "folding chair",
-    "560": "football helmet",
-    "561": "forklift",
-    "562": "fountain",
-    "563": "fountain pen",
-    "564": "four-poster",
-    "565": "freight car",
-    "566": "French horn, horn",
-    "567": "frying pan, frypan, skillet",
-    "568": "fur coat",
-    "569": "garbage truck, dustcart",
-    "570": "gasmask, respirator, gas helmet",
-    "571": "gas pump, gasoline pump, petrol pump, island dispenser",
-    "572": "goblet",
-    "573": "go-kart",
-    "574": "golf ball",
-    "575": "golfcart, golf cart",
-    "576": "gondola",
-    "577": "gong, tam-tam",
-    "578": "gown",
-    "579": "grand piano, grand",
-    "580": "greenhouse, nursery, glasshouse",
-    "581": "grille, radiator grille",
-    "582": "grocery store, grocery, food market, market",
-    "583": "guillotine",
-    "584": "hair slide",
-    "585": "hair spray",
-    "586": "half track",
-    "587": "hammer",
-    "588": "hamper",
-    "589": "hand blower, blow dryer, blow drier, hair dryer, hair drier",
-    "590": "hand-held computer, hand-held microcomputer",
-    "591": "handkerchief, hankie, hanky, hankey",
-    "592": "hard disc, hard disk, fixed disk",
-    "593": "harmonica, mouth organ, harp, mouth harp",
-    "594": "harp",
-    "595": "harvester, reaper",
-    "596": "hatchet",
-    "597": "holster",
-    "598": "home theater, home theatre",
-    "599": "honeycomb",
-    "600": "hook, claw",
-    "601": "hoopskirt, crinoline",
-    "602": "horizontal bar, high bar",
-    "603": "horse cart, horse-cart",
-    "604": "hourglass",
-    "605": "iPod",
-    "606": "iron, smoothing iron",
-    "607": "jack-o-lantern",
-    "608": "jean, blue jean, denim",
-    "609": "jeep, landrover",
-    "610": "jersey, T-shirt, tee shirt",
-    "611": "jigsaw puzzle",
-    "612": "jinrikisha, ricksha, rickshaw",
-    "613": "joystick",
-    "614": "kimono",
-    "615": "knee pad",
-    "616": "knot",
-    "617": "lab coat, laboratory coat",
-    "618": "ladle",
-    "619": "lampshade, lamp shade",
-    "620": "laptop, laptop computer",
-    "621": "lawn mower, mower",
-    "622": "lens cap, lens cover",
-    "623": "letter opener, paper knife, paperknife",
-    "624": "library",
-    "625": "lifeboat",
-    "626": "lighter, light, igniter, ignitor",
-    "627": "limousine, limo",
-    "628": "liner, ocean liner",
-    "629": "lipstick, lip rouge",
-    "630": "Loafer",
-    "631": "lotion",
-    "632": "loudspeaker, speaker, speaker unit, loudspeaker system, speaker system",
-    "633": "loupe, jewelers loupe",
-    "634": "lumbermill, sawmill",
-    "635": "magnetic compass",
-    "636": "mailbag, postbag",
-    "637": "mailbox, letter box",
-    "638": "maillot",
-    "639": "maillot, tank suit",
-    "640": "manhole cover",
-    "641": "maraca",
-    "642": "marimba, xylophone",
-    "643": "mask",
-    "644": "matchstick",
-    "645": "maypole",
-    "646": "maze, labyrinth",
-    "647": "measuring cup",
-    "648": "medicine chest, medicine cabinet",
-    "649": "megalith, megalithic structure",
-    "650": "microphone, mike",
-    "651": "microwave, microwave oven",
-    "652": "military uniform",
-    "653": "milk can",
-    "654": "minibus",
-    "655": "miniskirt, mini",
-    "656": "minivan",
-    "657": "missile",
-    "658": "mitten",
-    "659": "mixing bowl",
-    "660": "mobile home, manufactured home",
-    "661": "Model T",
-    "662": "modem",
-    "663": "monastery",
-    "664": "monitor",
-    "665": "moped",
-    "666": "mortar",
-    "667": "mortarboard",
-    "668": "mosque",
-    "669": "mosquito net",
-    "670": "motor scooter, scooter",
-    "671": "mountain bike, all-terrain bike, off-roader",
-    "672": "mountain tent",
-    "673": "mouse, computer mouse",
-    "674": "mousetrap",
-    "675": "moving van",
-    "676": "muzzle",
-    "677": "nail",
-    "678": "neck brace",
-    "679": "necklace",
-    "680": "nipple",
-    "681": "notebook, notebook computer",
-    "682": "obelisk",
-    "683": "oboe, hautboy, hautbois",
-    "684": "ocarina, sweet potato",
-    "685": "odometer, hodometer, mileometer, milometer",
-    "686": "oil filter",
-    "687": "organ, pipe organ",
-    "688": "oscilloscope, scope, cathode-ray oscilloscope, CRO",
-    "689": "overskirt",
-    "690": "oxcart",
-    "691": "oxygen mask",
-    "692": "packet",
-    "693": "paddle, boat paddle",
-    "694": "paddlewheel, paddle wheel",
-    "695": "padlock",
-    "696": "paintbrush",
-    "697": "pajama, pyjama, pjs, jammies",
-    "698": "palace",
-    "699": "panpipe, pandean pipe, syrinx",
-    "700": "paper towel",
-    "701": "parachute, chute",
-    "702": "parallel bars, bars",
-    "703": "park bench",
-    "704": "parking meter",
-    "705": "passenger car, coach, carriage",
-    "706": "patio, terrace",
-    "707": "pay-phone, pay-station",
-    "708": "pedestal, plinth, footstall",
-    "709": "pencil box, pencil case",
-    "710": "pencil sharpener",
-    "711": "perfume, essence",
-    "712": "Petri dish",
-    "713": "photocopier",
-    "714": "pick, plectrum, plectron",
-    "715": "pickelhaube",
-    "716": "picket fence, paling",
-    "717": "pickup, pickup truck",
-    "718": "pier",
-    "719": "piggy bank, penny bank",
-    "720": "pill bottle",
-    "721": "pillow",
-    "722": "ping-pong ball",
-    "723": "pinwheel",
-    "724": "pirate, pirate ship",
-    "725": "pitcher, ewer",
-    "726": "plane, carpenters plane, woodworking plane",
-    "727": "planetarium",
-    "728": "plastic bag",
-    "729": "plate rack",
-    "730": "plow, plough",
-    "731": "plunger, plumbers helper",
-    "732": "Polaroid camera, Polaroid Land camera",
-    "733": "pole",
-    "734": "police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria",
-    "735": "poncho",
-    "736": "pool table, billiard table, snooker table",
-    "737": "pop bottle, soda bottle",
-    "738": "pot, flowerpot",
-    "739": "potters wheel",
-    "740": "power drill",
-    "741": "prayer rug, prayer mat",
-    "742": "printer",
-    "743": "prison, prison house",
-    "744": "projectile, missile",
-    "745": "projector",
-    "746": "puck, hockey puck",
-    "747": "punching bag, punch bag, punching ball, punchball",
-    "748": "purse",
-    "749": "quill, quill pen",
-    "750": "quilt, comforter, comfort, puff",
-    "751": "racer, race car, racing car",
-    "752": "racket, racquet",
-    "753": "radiator",
-    "754": "radio, wireless",
-    "755": "radio telescope, radio reflector",
-    "756": "rain barrel",
-    "757": "recreational vehicle, RV, R.V.",
-    "758": "reel",
-    "759": "reflex camera",
-    "760": "refrigerator, icebox",
-    "761": "remote control, remote",
-    "762": "restaurant, eating house, eating place, eatery",
-    "763": "revolver, six-gun, six-shooter",
-    "764": "rifle",
-    "765": "rocking chair, rocker",
-    "766": "rotisserie",
-    "767": "rubber eraser, rubber, pencil eraser",
-    "768": "rugby ball",
-    "769": "rule, ruler",
-    "770": "running shoe",
-    "771": "safe",
-    "772": "safety pin",
-    "773": "saltshaker, salt shaker",
-    "774": "sandal",
-    "775": "sarong",
-    "776": "sax, saxophone",
-    "777": "scabbard",
-    "778": "scale, weighing machine",
-    "779": "school bus",
-    "780": "schooner",
-    "781": "scoreboard",
-    "782": "screen, CRT screen",
-    "783": "screw",
-    "784": "screwdriver",
-    "785": "seat belt, seatbelt",
-    "786": "sewing machine",
-    "787": "shield, buckler",
-    "788": "shoe shop, shoe-shop, shoe store",
-    "789": "shoji",
-    "790": "shopping basket",
-    "791": "shopping cart",
-    "792": "shovel",
-    "793": "shower cap",
-    "794": "shower curtain",
-    "795": "ski",
-    "796": "ski mask",
-    "797": "sleeping bag",
-    "798": "slide rule, slipstick",
-    "799": "sliding door",
-    "800": "slot, one-armed bandit",
-    "801": "snorkel",
-    "802": "snowmobile",
-    "803": "snowplow, snowplough",
-    "804": "soap dispenser",
-    "805": "soccer ball",
-    "806": "sock",
-    "807": "solar dish, solar collector, solar furnace",
-    "808": "sombrero",
-    "809": "soup bowl",
-    "810": "space bar",
-    "811": "space heater",
-    "812": "space shuttle",
-    "813": "spatula",
-    "814": "speedboat",
-    "815": "spider web, spiders web",
-    "816": "spindle",
-    "817": "sports car, sport car",
-    "818": "spotlight, spot",
-    "819": "stage",
-    "820": "steam locomotive",
-    "821": "steel arch bridge",
-    "822": "steel drum",
-    "823": "stethoscope",
-    "824": "stole",
-    "825": "stone wall",
-    "826": "stopwatch, stop watch",
-    "827": "stove",
-    "828": "strainer",
-    "829": "streetcar, tram, tramcar, trolley, trolley car",
-    "830": "stretcher",
-    "831": "studio couch, day bed",
-    "832": "stupa, tope",
-    "833": "submarine, pigboat, sub, U-boat",
-    "834": "suit, suit of clothes",
-    "835": "sundial",
-    "836": "sunglass",
-    "837": "sunglasses, dark glasses, shades",
-    "838": "sunscreen, sunblock, sun blocker",
-    "839": "suspension bridge",
-    "840": "swab, swob, mop",
-    "841": "sweatshirt",
-    "842": "swimming trunks, bathing trunks",
-    "843": "swing",
-    "844": "switch, electric switch, electrical switch",
-    "845": "syringe",
-    "846": "table lamp",
-    "847": "tank, army tank, armored combat vehicle, armoured combat vehicle",
-    "848": "tape player",
-    "849": "teapot",
-    "850": "teddy, teddy bear",
-    "851": "television, television system",
-    "852": "tennis ball",
-    "853": "thatch, thatched roof",
-    "854": "theater curtain, theatre curtain",
-    "855": "thimble",
-    "856": "thresher, thrasher, threshing machine",
-    "857": "throne",
-    "858": "tile roof",
-    "859": "toaster",
-    "860": "tobacco shop, tobacconist shop, tobacconist",
-    "861": "toilet seat",
-    "862": "torch",
-    "863": "totem pole",
-    "864": "tow truck, tow car, wrecker",
-    "865": "toyshop",
-    "866": "tractor",
-    "867": "trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi",
-    "868": "tray",
-    "869": "trench coat",
-    "870": "tricycle, trike, velocipede",
-    "871": "trimaran",
-    "872": "tripod",
-    "873": "triumphal arch",
-    "874": "trolleybus, trolley coach, trackless trolley",
-    "875": "trombone",
-    "876": "tub, vat",
-    "877": "turnstile",
-    "878": "typewriter keyboard",
-    "879": "umbrella",
-    "880": "unicycle, monocycle",
-    "881": "upright, upright piano",
-    "882": "vacuum, vacuum cleaner",
-    "883": "vase",
-    "884": "vault",
-    "885": "velvet",
-    "886": "vending machine",
-    "887": "vestment",
-    "888": "viaduct",
-    "889": "violin, fiddle",
-    "890": "volleyball",
-    "891": "waffle iron",
-    "892": "wall clock",
-    "893": "wallet, billfold, notecase, pocketbook",
-    "894": "wardrobe, closet, press",
-    "895": "warplane, military plane",
-    "896": "washbasin, handbasin, washbowl, lavabo, wash-hand basin",
-    "897": "washer, automatic washer, washing machine",
-    "898": "water bottle",
-    "899": "water jug",
-    "900": "water tower",
-    "901": "whiskey jug",
-    "902": "whistle",
-    "903": "wig",
-    "904": "window screen",
-    "905": "window shade",
-    "906": "Windsor tie",
-    "907": "wine bottle",
-    "908": "wing",
-    "909": "wok",
-    "910": "wooden spoon",
-    "911": "wool, woolen, woollen",
-    "912": "worm fence, snake fence, snake-rail fence, Virginia fence",
-    "913": "wreck",
-    "914": "yawl",
-    "915": "yurt",
-    "916": "web site, website, internet site, site",
-    "917": "comic book",
-    "918": "crossword puzzle, crossword",
-    "919": "street sign",
-    "920": "traffic light, traffic signal, stoplight",
-    "921": "book jacket, dust cover, dust jacket, dust wrapper",
-    "922": "menu",
-    "923": "plate",
-    "924": "guacamole",
-    "925": "consomme",
-    "926": "hot pot, hotpot",
-    "927": "trifle",
-    "928": "ice cream, icecream",
-    "929": "ice lolly, lolly, lollipop, popsicle",
-    "930": "French loaf",
-    "931": "bagel, beigel",
-    "932": "pretzel",
-    "933": "cheeseburger",
-    "934": "hotdog, hot dog, red hot",
-    "935": "mashed potato",
-    "936": "head cabbage",
-    "937": "broccoli",
-    "938": "cauliflower",
-    "939": "zucchini, courgette",
-    "940": "spaghetti squash",
-    "941": "acorn squash",
-    "942": "butternut squash",
-    "943": "cucumber, cuke",
-    "944": "artichoke, globe artichoke",
-    "945": "bell pepper",
-    "946": "cardoon",
-    "947": "mushroom",
-    "948": "Granny Smith",
-    "949": "strawberry",
-    "950": "orange",
-    "951": "lemon",
-    "952": "fig",
-    "953": "pineapple, ananas",
-    "954": "banana",
-    "955": "jackfruit, jak, jack",
-    "956": "custard apple",
-    "957": "pomegranate",
-    "958": "hay",
-    "959": "carbonara",
-    "960": "chocolate sauce, chocolate syrup",
-    "961": "dough",
-    "962": "meat loaf, meatloaf",
-    "963": "pizza, pizza pie",
-    "964": "potpie",
-    "965": "burrito",
-    "966": "red wine",
-    "967": "espresso",
-    "968": "cup",
-    "969": "eggnog",
-    "970": "alp",
-    "971": "bubble",
-    "972": "cliff, drop, drop-off",
-    "973": "coral reef",
-    "974": "geyser",
-    "975": "lakeside, lakeshore",
-    "976": "promontory, headland, head, foreland",
-    "977": "sandbar, sand bar",
-    "978": "seashore, coast, seacoast, sea-coast",
-    "979": "valley, vale",
-    "980": "volcano",
-    "981": "ballplayer, baseball player",
-    "982": "groom, bridegroom",
-    "983": "scuba diver",
-    "984": "rapeseed",
-    "985": "daisy",
-    "986": "yellow ladys slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum",
-    "987": "corn",
-    "988": "acorn",
-    "989": "hip, rose hip, rosehip",
-    "990": "buckeye, horse chestnut, conker",
-    "991": "coral fungus",
-    "992": "agaric",
-    "993": "gyromitra",
-    "994": "stinkhorn, carrion fungus",
-    "995": "earthstar",
-    "996": "hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa",
-    "997": "bolete",
-    "998": "ear, spike, capitulum",
-    "999": "toilet tissue, toilet paper, bathroom tissue"
-  },
-  "vae": [
-    "diffusers",
-    "AutoencoderKLFlux2"
-  ]
-}

JLT-B-1-256/pipeline.py DELETED Viewed

@@ -1,548 +0,0 @@
-"""Hub custom pipeline: JLTPipeline.
-Load with native Hugging Face diffusers and trust_remote_code=True.
-"""
-from __future__ import annotations
-import importlib
-import json
-import sys
-from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Union
-import numpy as np
-import torch
-from diffusers import AutoencoderKLFlux2
-from diffusers.pipelines.pipeline_utils import DiffusionPipeline, ImagePipelineOutput
-from diffusers.schedulers import FlowMatchEulerDiscreteScheduler, FlowMatchHeunDiscreteScheduler
-from diffusers.schedulers.scheduling_utils import SchedulerMixin
-from diffusers.utils.torch_utils import randn_tensor
-def configure_linear_flow_timesteps(
-    scheduler: SchedulerMixin,
-    num_inference_steps: int,
-    device: Union[str, torch.device, None] = None,
-) -> None:
-    if isinstance(scheduler, FlowMatchHeunDiscreteScheduler):
-        scheduler.num_inference_steps = num_inference_steps
-        sigmas = np.linspace(1.0, 0.0, num_inference_steps, dtype=np.float32)
-        sigmas_t = torch.from_numpy(sigmas).to(dtype=torch.float32, device=device)
-        shift = scheduler.config.shift
-        sigmas_t = shift * sigmas_t / (1 + (shift - 1) * sigmas_t)
-        timesteps = sigmas_t * scheduler.config.num_train_timesteps
-        timesteps = torch.cat([timesteps[:1], timesteps[1:].repeat_interleave(2)])
-        scheduler.timesteps = timesteps.to(device=device)
-        sigmas_t = torch.cat([sigmas_t, torch.zeros(1, device=sigmas_t.device)])
-        scheduler.sigmas = torch.cat([sigmas_t[:1], sigmas_t[1:-1].repeat_interleave(2), sigmas_t[-1:]])
-        scheduler._step_index = None
-        scheduler._begin_index = None
-        scheduler.prev_derivative = None
-        scheduler.dt = None
-        scheduler.sample = None
-        return
-    sigmas = np.linspace(1.0, 0.0, num_inference_steps, dtype=np.float32).tolist()
-    scheduler.set_timesteps(num_inference_steps, device=device, sigmas=sigmas)
-def velocity_from_prediction(
-    sample: torch.Tensor,
-    model_output: torch.Tensor,
-    timestep: Union[float, torch.Tensor],
-    *,
-    prediction_type: str = "sample",
-    t_eps: float = 5e-2,
-) -> torch.Tensor:
-    if prediction_type == "velocity":
-        return model_output
-    t = torch.as_tensor(timestep, device=sample.device, dtype=sample.dtype)
-    while t.ndim < sample.ndim:
-        t = t.unsqueeze(-1)
-    denom = (1.0 - t).clamp_min(t_eps)
-    return (model_output - sample) / denom
-def _unpatchify_latents(latents: torch.Tensor) -> torch.Tensor:
-    batch_size, num_channels_latents, height, width = latents.shape
-    latents = latents.reshape(batch_size, num_channels_latents // (2 * 2), 2, 2, height, width)
-    latents = latents.permute(0, 1, 4, 2, 5, 3)
-    return latents.reshape(batch_size, num_channels_latents // (2 * 2), height * 2, width * 2)
-def _flux2_bn_stats(vae: AutoencoderKLFlux2, ref: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
-    mean = vae.bn.running_mean.view(1, -1, 1, 1).to(ref.device, ref.dtype)
-    std = torch.sqrt(
-        vae.bn.running_var.view(1, -1, 1, 1).to(ref.device, ref.dtype) + vae.config.batch_norm_eps
-    )
-    return mean, std
-@torch.no_grad()
-def decode_flux2_latents(vae: AutoencoderKLFlux2, latents: torch.Tensor) -> torch.Tensor:
-    vae_param = next(vae.parameters())
-    latents = latents.to(device=vae_param.device, dtype=torch.float32)
-    mean, std = _flux2_bn_stats(vae, latents)
-    latents = latents * std + mean
-    latents = _unpatchify_latents(latents)
-    return vae.decode(latents.to(vae_param.dtype), return_dict=False)[0].float()
-_FLOW_SCHEDULERS = {
-    "heun": FlowMatchHeunDiscreteScheduler,
-    "euler": FlowMatchEulerDiscreteScheduler,
-}
-def _new_flow_scheduler(solver: str) -> SchedulerMixin:
-    if solver not in _FLOW_SCHEDULERS:
-        raise ValueError("solver must be one of: 'heun', 'euler'.")
-    return _FLOW_SCHEDULERS[solver]()
-def _solver_from_scheduler(scheduler: SchedulerMixin | None) -> str:
-    if isinstance(scheduler, FlowMatchHeunDiscreteScheduler):
-        return "heun"
-    if isinstance(scheduler, FlowMatchEulerDiscreteScheduler):
-        return "euler"
-    return "heun"
-class JLTPipeline(DiffusionPipeline):
-    r"""
-    Pipeline for class-conditional image generation with JLT (Clean-Latent JiT).
-    Latent models (`in_channels=128`) require a FLUX.2 VAE attached for `output_type="pil"`.
-    """
-    model_cpu_offload_seq = "transformer->vae"
-    _optional_components = ["vae"]
-    def __init__(
-        self,
-        transformer,
-        scheduler,
-        vae=None,
-        id2label=None,
-        prediction_type="sample",
-        t_eps=5e-2,
-        solver="heun",
-    ):
-        super().__init__()
-        if scheduler is None or isinstance(scheduler, list):
-            scheduler = _new_flow_scheduler(solver)
-        self.register_modules(
-            transformer=transformer,
-            scheduler=scheduler,
-            vae=vae,
-        )
-        self.prediction_type = prediction_type
-        self.t_eps = t_eps
-        self.solver = solver
-        self._id2label = self._normalize_id2label(id2label)
-        self.labels = self._build_label2id(self._id2label)
-        self._labels_loaded_from_model_index = bool(self._id2label)
-    @classmethod
-    def from_pretrained(cls, pretrained_model_name_or_path=None, subfolder=None, **kwargs):
-        repo_root = Path(__file__).resolve().parent
-        if pretrained_model_name_or_path in (None, "", "."):
-            variant = repo_root
-        else:
-            variant = Path(pretrained_model_name_or_path)
-            if not variant.is_absolute():
-                candidate = (Path.cwd() / variant).resolve()
-                variant = candidate if candidate.exists() else (repo_root / variant).resolve()
-            if subfolder:
-                variant = variant / subfolder
-        model_kwargs = dict(kwargs)
-        inserted: List[str] = []
-        def _load_transformer():
-            comp_dir = variant / "transformer"
-            module_path = comp_dir / "transformer_jlt.py"
-            if not module_path.exists() or not (comp_dir / "config.json").exists():
-                return None
-            comp_path = str(comp_dir)
-            if comp_path not in sys.path:
-                sys.path.insert(0, comp_path)
-                inserted.append(comp_path)
-            module = importlib.import_module("transformer_jlt")
-            transformer_cls = getattr(module, "JLTTransformer2DModel")
-            return transformer_cls.from_pretrained(str(comp_dir), **model_kwargs)
-        def _load_scheduler():
-            scheduler_dir = variant / "scheduler"
-            config_path = scheduler_dir / "scheduler_config.json"
-            if not config_path.exists():
-                return _new_flow_scheduler("heun")
-            scheduler_entry = None
-            model_index_path = variant / "model_index.json"
-            if model_index_path.exists():
-                scheduler_entry = json.loads(model_index_path.read_text(encoding="utf-8")).get("scheduler")
-            if scheduler_entry is None:
-                class_name = json.loads(config_path.read_text(encoding="utf-8")).get("_class_name")
-                scheduler_entry = ["diffusers", class_name]
-            module_name, class_name = scheduler_entry
-            if module_name == "diffusers":
-                import diffusers.schedulers as schedulers_pkg
-                scheduler_cls = getattr(schedulers_pkg, class_name)
-                return scheduler_cls.from_pretrained(str(scheduler_dir), **model_kwargs)
-            comp_path = str(scheduler_dir)
-            if comp_path not in sys.path:
-                sys.path.insert(0, comp_path)
-                inserted.append(comp_path)
-            module = importlib.import_module(module_name)
-            scheduler_cls = getattr(module, class_name)
-            return scheduler_cls.from_pretrained(str(scheduler_dir), **model_kwargs)
-        def _load_vae():
-            vae_dir = variant / "vae"
-            if vae_dir.exists() and (vae_dir / "config.json").exists():
-                return AutoencoderKLFlux2.from_pretrained(str(vae_dir), **model_kwargs)
-            return None
-        try:
-            transformer = _load_transformer()
-            if transformer is None:
-                raise ValueError(f"No loadable transformer found under {variant}")
-            scheduler = _load_scheduler()
-            vae = _load_vae()
-            id2label = cls._read_id2label_from_model_index(str(variant))
-            solver = _solver_from_scheduler(scheduler)
-            pipe = cls(
-                transformer=transformer,
-                scheduler=scheduler,
-                vae=vae,
-                id2label=id2label or None,
-                solver=solver,
-            )
-            if hasattr(pipe, "register_to_config"):
-                pipe.register_to_config(_name_or_path=str(variant))
-            return pipe
-        finally:
-            for comp_path in inserted:
-                if comp_path in sys.path:
-                    sys.path.remove(comp_path)
-    @staticmethod
-    def _normalize_id2label(id2label: Optional[Dict[Union[int, str], str]]) -> Dict[int, str]:
-        if not id2label:
-            return {}
-        return {int(key): value for key, value in id2label.items()}
-    @staticmethod
-    def _read_id2label_from_model_index(variant_path: Optional[str]) -> Dict[int, str]:
-        if not variant_path:
-            return {}
-        model_index_path = Path(variant_path).resolve() / "model_index.json"
-        if not model_index_path.exists():
-            return {}
-        raw = json.loads(model_index_path.read_text(encoding="utf-8"))
-        id2label = raw.get("id2label")
-        if not isinstance(id2label, dict):
-            return {}
-        return {int(key): value for key, value in id2label.items()}
-    @staticmethod
-    def _build_label2id(id2label: Dict[int, str]) -> Dict[str, int]:
-        label2id: Dict[str, int] = {}
-        for class_id, value in id2label.items():
-            for synonym in value.split(","):
-                synonym = synonym.strip()
-                if synonym:
-                    label2id[synonym] = int(class_id)
-        return dict(sorted(label2id.items()))
-    def _ensure_labels_loaded(self) -> None:
-        if self._labels_loaded_from_model_index:
-            return
-        loaded = self._read_id2label_from_model_index(getattr(self.config, "_name_or_path", None))
-        if loaded:
-            self._id2label = loaded
-            self.labels = self._build_label2id(self._id2label)
-        self._labels_loaded_from_model_index = True
-    @property
-    def id2label(self) -> Dict[int, str]:
-        self._ensure_labels_loaded()
-        return self._id2label
-    def get_label_ids(self, label: Union[str, List[str]]) -> List[int]:
-        self._ensure_labels_loaded()
-        if not self.labels:
-            raise ValueError("No labels loaded. Ensure `id2label` exists in model_index.json.")
-        if isinstance(label, str):
-            label = [label]
-        missing = [item for item in label if item not in self.labels]
-        if missing:
-            preview = ", ".join(list(self.labels.keys())[:8])
-            raise ValueError(f"Unknown label(s): {missing}. Examples: {preview}, ...")
-        return [self.labels[item] for item in label]
-    def _normalize_class_labels(self, class_labels: Union[int, str, List[Union[int, str]]]) -> List[int]:
-        if isinstance(class_labels, int):
-            return [class_labels]
-        if isinstance(class_labels, str):
-            return self.get_label_ids(class_labels)
-        if class_labels and isinstance(class_labels[0], str):
-            return self.get_label_ids(class_labels)
-        return list(class_labels)
-    def _sampling_dtype(self) -> torch.dtype:
-        model_dtype = self.transformer.dtype
-        if model_dtype in (torch.bfloat16, torch.float16):
-            return torch.float32
-        return model_dtype
-    def _predict_velocity_at_t(
-        self,
-        z_value: torch.Tensor,
-        t_jlt: Union[float, torch.Tensor],
-        class_labels: torch.Tensor,
-        class_null: torch.Tensor,
-        do_classifier_free_guidance: bool,
-        guidance_scale: float,
-        guidance_interval_min: float,
-        guidance_interval_max: float,
-    ) -> torch.Tensor:
-        t_jlt = torch.as_tensor(t_jlt, device=z_value.device, dtype=z_value.dtype)
-        if t_jlt.ndim == 0:
-            t_jlt = t_jlt.reshape(1)
-        if do_classifier_free_guidance:
-            z_in = torch.cat([z_value, z_value], dim=0)
-            labels = torch.cat([class_labels, class_null], dim=0)
-        else:
-            z_in = z_value
-            labels = class_labels
-        t_batch = t_jlt.flatten().expand(z_in.shape[0])
-        model_dtype = self.transformer.dtype
-        use_autocast = model_dtype != torch.float32 and z_value.is_cuda
-        if use_autocast:
-            with torch.autocast(device_type=z_value.device.type, dtype=model_dtype):
-                model_out = self.transformer(
-                    z_in.to(model_dtype),
-                    timestep=t_batch,
-                    class_labels=labels,
-                ).sample
-        else:
-            model_out = self.transformer(z_in, timestep=t_batch, class_labels=labels).sample
-        v = velocity_from_prediction(
-            z_in,
-            model_out.to(z_value.dtype),
-            t_jlt,
-            prediction_type=self.prediction_type,
-            t_eps=self.t_eps,
-        )
-        if not do_classifier_free_guidance:
-            return v
-        v_cond, v_uncond = v.chunk(2, dim=0)
-        interval_mask = t_jlt < guidance_interval_max
-        if guidance_interval_min != 0.0:
-            interval_mask = interval_mask & (t_jlt > guidance_interval_min)
-        scale = torch.where(
-            interval_mask,
-            torch.tensor(guidance_scale, device=z_value.device, dtype=z_value.dtype),
-            torch.tensor(1.0, device=z_value.device, dtype=z_value.dtype),
-        )
-        return v_uncond + scale * (v_cond - v_uncond)
-    def _euler_step(
-        self,
-        latents: torch.Tensor,
-        t_cur: torch.Tensor,
-        t_next: torch.Tensor,
-        class_labels: torch.Tensor,
-        class_null: torch.Tensor,
-        do_classifier_free_guidance: bool,
-        guidance_scale: float,
-        guidance_interval_min: float,
-        guidance_interval_max: float,
-    ) -> torch.Tensor:
-        dt = t_next - t_cur
-        velocity = self._predict_velocity_at_t(
-            latents,
-            t_cur,
-            class_labels,
-            class_null,
-            do_classifier_free_guidance,
-            guidance_scale,
-            guidance_interval_min,
-            guidance_interval_max,
-        )
-        return latents + dt * velocity
-    def _heun_step(
-        self,
-        latents: torch.Tensor,
-        t_cur: torch.Tensor,
-        t_next: torch.Tensor,
-        class_labels: torch.Tensor,
-        class_null: torch.Tensor,
-        do_classifier_free_guidance: bool,
-        guidance_scale: float,
-        guidance_interval_min: float,
-        guidance_interval_max: float,
-    ) -> torch.Tensor:
-        dt = t_next - t_cur
-        velocity_1 = self._predict_velocity_at_t(
-            latents,
-            t_cur,
-            class_labels,
-            class_null,
-            do_classifier_free_guidance,
-            guidance_scale,
-            guidance_interval_min,
-            guidance_interval_max,
-        )
-        velocity_2 = self._predict_velocity_at_t(
-            latents + dt * velocity_1,
-            t_next,
-            class_labels,
-            class_null,
-            do_classifier_free_guidance,
-            guidance_scale,
-            guidance_interval_min,
-            guidance_interval_max,
-        )
-        return latents + dt * 0.5 * (velocity_1 + velocity_2)
-    def _run_sampler(
-        self,
-        latents: torch.Tensor,
-        class_labels: torch.Tensor,
-        class_null: torch.Tensor,
-        num_inference_steps: int,
-        do_classifier_free_guidance: bool,
-        guidance_scale: float,
-        guidance_interval_min: float,
-        guidance_interval_max: float,
-    ) -> torch.Tensor:
-        solver = self.solver
-        if solver not in _FLOW_SCHEDULERS:
-            raise ValueError("pipeline solver must be one of: 'heun', 'euler'.")
-        device = latents.device
-        dtype = self._sampling_dtype()
-        latents = latents.to(dtype=dtype)
-        ts = torch.linspace(0.0, 1.0, num_inference_steps + 1, device=device, dtype=dtype)
-        step_kwargs = (
-            class_labels,
-            class_null,
-            do_classifier_free_guidance,
-            guidance_scale,
-            guidance_interval_min,
-            guidance_interval_max,
-        )
-        if solver == "heun":
-            for step_idx in self.progress_bar(range(num_inference_steps - 1)):
-                latents = self._heun_step(latents, ts[step_idx], ts[step_idx + 1], *step_kwargs)
-            latents = self._euler_step(latents, ts[-2], ts[-1], *step_kwargs)
-            return latents
-        for step_idx in self.progress_bar(range(num_inference_steps)):
-            latents = self._euler_step(latents, ts[step_idx], ts[step_idx + 1], *step_kwargs)
-        return latents
-    @torch.inference_mode()
-    def __call__(
-        self,
-        class_labels: Union[int, str, List[Union[int, str]]],
-        guidance_scale: Optional[float] = None,
-        guidance_interval_min: float = 0.1,
-        guidance_interval_max: float = 1.0,
-        noise_scale: float = 1.0,
-        t_eps: Optional[float] = None,
-        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
-        num_inference_steps: int = 50,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-    ) -> Union[ImagePipelineOutput, Tuple]:
-        if num_inference_steps < 2:
-            raise ValueError("num_inference_steps must be >= 2.")
-        if output_type not in {"pil", "np", "pt", "latent"}:
-            raise ValueError("output_type must be one of: 'pil', 'np', 'pt', 'latent'.")
-        if t_eps is not None:
-            self.t_eps = t_eps
-        class_label_ids = self._normalize_class_labels(class_labels)
-        do_classifier_free_guidance = guidance_scale is not None and guidance_scale > 1.0
-        batch_size = len(class_label_ids)
-        latent_size = int(self.transformer.config.sample_size)
-        channels = int(self.transformer.config.in_channels)
-        null_class_val = int(
-            getattr(self.transformer.config, "num_classes", getattr(self.transformer.config, "num_class_embeds", 1000))
-        )
-        if guidance_scale is None:
-            guidance_scale = 1.0
-        latents = randn_tensor(
-            shape=(batch_size, channels, latent_size, latent_size),
-            generator=generator,
-            device=self._execution_device,
-            dtype=self._sampling_dtype(),
-        ) * noise_scale
-        class_labels_t = torch.tensor(class_label_ids, device=self._execution_device, dtype=torch.long).reshape(-1)
-        class_labels_t = class_labels_t.clamp(0, null_class_val - 1)
-        class_null = torch.full_like(class_labels_t, null_class_val)
-        latents = self._run_sampler(
-            latents,
-            class_labels_t,
-            class_null,
-            num_inference_steps,
-            do_classifier_free_guidance,
-            guidance_scale,
-            guidance_interval_min,
-            guidance_interval_max,
-        )
-        if output_type == "latent":
-            if not return_dict:
-                return (latents,)
-            return ImagePipelineOutput(images=latents)
-        if self.vae is not None:
-            images_pt = decode_flux2_latents(self.vae, latents)
-        else:
-            images_pt = latents
-        if not torch.isfinite(images_pt).all():
-            raise RuntimeError(
-                "JLT generation produced non-finite values before image conversion. "
-                "Restart the notebook kernel and re-run the pipeline load cell."
-            )
-        images_pt = ((images_pt.float().clamp(-1, 1) + 1.0) / 2.0).cpu()
-        if output_type == "pt":
-            images = images_pt
-        elif output_type == "np":
-            images = images_pt.permute(0, 2, 3, 1).numpy()
-        else:
-            images = self.numpy_to_pil(images_pt.permute(0, 2, 3, 1).numpy())
-        self.maybe_free_model_hooks()
-        if not return_dict:
-            return (images,)
-        return ImagePipelineOutput(images=images)

JLT-B-1-256/scheduler/scheduler_config.json DELETED Viewed

@@ -1,6 +0,0 @@
-{
-  "_class_name": "FlowMatchHeunDiscreteScheduler",
-  "_diffusers_version": "0.38.0",
-  "num_train_timesteps": 1000,
-  "shift": 4.0
-}

JLT-B-1-256/transformer/config.json DELETED Viewed

@@ -1,21 +0,0 @@
-{
-  "_class_name": "JLTTransformer2DModel",
-  "_diffusers_version": "0.38.0",
-  "attention_dropout": 0.0,
-  "dropout": 0.0,
-  "hidden_size": 768,
-  "in_channels": 128,
-  "loop_count": 0,
-  "loop_indices": null,
-  "mask_prob": 0.0,
-  "mask_ratio": 0.0,
-  "mlp_ratio": 4.0,
-  "model_type": "JiT-B/1",
-  "norm_eps": 1e-06,
-  "num_attention_heads": 12,
-  "num_class_embeds": null,
-  "num_classes": 1000,
-  "num_layers": 12,
-  "patch_size": 1,
-  "sample_size": 16
-}

JLT-B-1-256/transformer/diffusion_pytorch_model.safetensors DELETED Viewed

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6bdf942f527a03aca3d5e9b07d94656cec350e9c45fbfcbc4c49e9b098f45e62
-size 522055144

JLT-B-1-256/transformer/transformer_jlt.py DELETED Viewed

@@ -1,639 +0,0 @@
-"""JLT (Clean-Latent) Transformer for diffusers."""
-from __future__ import annotations
-import argparse
-import math
-from collections.abc import Mapping
-from typing import Dict, List, Optional, Tuple
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from diffusers.configuration_utils import ConfigMixin, register_to_config
-from diffusers.models.modeling_outputs import Transformer2DModelOutput
-from diffusers.models.modeling_utils import ModelMixin
-from diffusers.models.normalization import RMSNorm
-from einops import rearrange, repeat
-try:
-    from flash_attn.cute import flash_attn_func as _flash_attn_func
-    _HAS_FLASH_ATTN = True
-except ImportError:
-    _HAS_FLASH_ATTN = False
-JLT_PRESET_CONFIGS: Dict[str, Dict[str, object]] = {
-    "JiT-B/1": {
-        "sample_size": 16,
-        "patch_size": 1,
-        "hidden_size": 768,
-        "num_layers": 12,
-        "num_attention_heads": 12,
-        "attention_dropout": 0.0,
-        "dropout": 0.0,
-    },
-    "JiT-B/2": {
-        "sample_size": 16,
-        "patch_size": 2,
-        "hidden_size": 768,
-        "num_layers": 12,
-        "num_attention_heads": 12,
-        "attention_dropout": 0.0,
-        "dropout": 0.0,
-    },
-    "JiT-B/16": {
-        "sample_size": 256,
-        "patch_size": 16,
-        "hidden_size": 768,
-        "num_layers": 12,
-        "num_attention_heads": 12,
-        "attention_dropout": 0.0,
-        "dropout": 0.0,
-    },
-    "JiT-B/32": {
-        "sample_size": 512,
-        "patch_size": 32,
-        "hidden_size": 768,
-        "num_layers": 12,
-        "num_attention_heads": 12,
-        "attention_dropout": 0.0,
-        "dropout": 0.0,
-    },
-    "JiT-L/16": {
-        "sample_size": 256,
-        "patch_size": 16,
-        "hidden_size": 1024,
-        "num_layers": 24,
-        "num_attention_heads": 16,
-        "attention_dropout": 0.0,
-        "dropout": 0.0,
-    },
-    "JiT-L/32": {
-        "sample_size": 512,
-        "patch_size": 32,
-        "hidden_size": 1024,
-        "num_layers": 24,
-        "num_attention_heads": 16,
-        "attention_dropout": 0.0,
-        "dropout": 0.0,
-    },
-    "JiT-H/16": {
-        "sample_size": 256,
-        "patch_size": 16,
-        "hidden_size": 1280,
-        "num_layers": 32,
-        "num_attention_heads": 16,
-        "attention_dropout": 0.0,
-        "dropout": 0.2,
-    },
-    "JiT-H/32": {
-        "sample_size": 512,
-        "patch_size": 32,
-        "hidden_size": 1280,
-        "num_layers": 32,
-        "num_attention_heads": 16,
-        "attention_dropout": 0.0,
-        "dropout": 0.2,
-    },
-}
-def remap_legacy_state_dict(state_dict: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]:
-    """Map legacy JLT/Denoiser checkpoint keys to native transformer keys."""
-    remapped: Dict[str, torch.Tensor] = {}
-    for key, value in state_dict.items():
-        new_key = key
-        for prefix in ("transformer.", "net."):
-            if new_key.startswith(prefix):
-                new_key = new_key[len(prefix) :]
-                break
-        if new_key.startswith("final_layer."):
-            new_key = new_key.replace("final_layer.norm_final", "norm_final")
-            new_key = new_key.replace("final_layer.linear", "linear_final")
-            new_key = new_key.replace("final_layer.adaLN_modulation", "adaLN_modulation_final")
-        remapped[new_key] = value
-    return remapped
-def config_from_legacy(config: Dict[str, object]) -> Dict[str, object]:
-    model_type = config.get("model_type") or config.get("model") or config.get("model_name")
-    if model_type not in JLT_PRESET_CONFIGS:
-        raise ValueError(f"Unknown JLT preset '{model_type}'. Known: {list(JLT_PRESET_CONFIGS)}")
-    preset = dict(JLT_PRESET_CONFIGS[model_type])
-    preset["num_classes"] = int(config.get("num_class_embeds") or config.get("num_classes") or config.get("class_num") or 1000)
-    if config.get("attn_dropout") is not None:
-        preset["attention_dropout"] = float(config["attn_dropout"])
-    if config.get("proj_dropout") is not None:
-        preset["dropout"] = float(config["proj_dropout"])
-    if config.get("sample_size") is not None:
-        preset["sample_size"] = int(config["sample_size"])
-    if config.get("img_size") is not None and config.get("patch_size") is not None:
-        preset["sample_size"] = int(config["img_size"]) // int(config.get("spatial_compression", 16))
-    preset["model_type"] = model_type
-    return preset
-def broadcat(tensors, dim=-1):
-    num_tensors = len(tensors)
-    shape_lens = {len(t.shape) for t in tensors}
-    if len(shape_lens) != 1:
-        raise ValueError("tensors must all have the same number of dimensions")
-    shape_len = list(shape_lens)[0]
-    dim = (dim + shape_len) if dim < 0 else dim
-    dims = list(zip(*(list(t.shape) for t in tensors)))
-    expandable_dims = [(i, val) for i, val in enumerate(dims) if i != dim]
-    if not all(len(set(t[1])) <= 2 for t in expandable_dims):
-        raise ValueError("invalid dimensions for broadcastable concatenation")
-    max_dims = [(t[0], max(t[1])) for t in expandable_dims]
-    expanded_dims = [(t[0], (t[1],) * num_tensors) for t in max_dims]
-    expanded_dims.insert(dim, (dim, dims[dim]))
-    expandable_shapes = list(zip(*(t[1] for t in expanded_dims)))
-    tensors = [t[0].expand(*t[1]) for t in zip(tensors, expandable_shapes)]
-    return torch.cat(tensors, dim=dim)
-def rotate_half(x):
-    x = rearrange(x, "... (d r) -> ... d r", r=2)
-    x1, x2 = x.unbind(dim=-1)
-    x = torch.stack((-x2, x1), dim=-1)
-    return rearrange(x, "... d r -> ... (d r)")
-class JLTRotaryEmbedding(nn.Module):
-    def __init__(self, dim, pt_seq_len=16, ft_seq_len=None, theta=10000, num_cls_token=0):
-        super().__init__()
-        freqs = 1.0 / (theta ** (torch.arange(0, dim, 2)[: (dim // 2)].float() / dim))
-        if ft_seq_len is None:
-            ft_seq_len = pt_seq_len
-        t = torch.arange(ft_seq_len) / ft_seq_len * pt_seq_len
-        freqs = torch.einsum("..., f -> ... f", t, freqs)
-        freqs = repeat(freqs, "... n -> ... (n r)", r=2)
-        freqs = broadcat((freqs[:, None, :], freqs[None, :, :]), dim=-1)
-        if num_cls_token > 0:
-            freqs_flat = freqs.view(-1, freqs.shape[-1])
-            cos_img = freqs_flat.cos()
-            sin_img = freqs_flat.sin()
-            _, dim_freq = cos_img.shape
-            cos_pad = torch.ones(num_cls_token, dim_freq, dtype=cos_img.dtype)
-            sin_pad = torch.zeros(num_cls_token, dim_freq, dtype=sin_img.dtype)
-            self.register_buffer("freqs_cos", torch.cat([cos_pad, cos_img], dim=0), persistent=False)
-            self.register_buffer("freqs_sin", torch.cat([sin_pad, sin_img], dim=0), persistent=False)
-        else:
-            self.register_buffer("freqs_cos", freqs.cos().view(-1, freqs.shape[-1]), persistent=False)
-            self.register_buffer("freqs_sin", freqs.sin().view(-1, freqs.shape[-1]), persistent=False)
-    def forward(self, tensor):
-        seq_len = tensor.shape[1] if tensor.ndim == 4 else tensor.shape[-2]
-        fc = self.freqs_cos[:seq_len].to(device=tensor.device, dtype=tensor.dtype)
-        fs = self.freqs_sin[:seq_len].to(device=tensor.device, dtype=tensor.dtype)
-        if tensor.ndim == 4:
-            return tensor * fc[:, None, :] + rotate_half(tensor) * fs[:, None, :]
-        return tensor * fc + rotate_half(tensor) * fs
-def modulate(x, shift, scale):
-    if shift.ndim == x.ndim - 1:
-        shift = shift.unsqueeze(1)
-        scale = scale.unsqueeze(1)
-    return x * (1 + scale) + shift
-class JLTPatchEmbed(nn.Module):
-    def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768, bias=True):
-        super().__init__()
-        img_size = (img_size, img_size)
-        patch_size = (patch_size, patch_size)
-        self.img_size = img_size
-        self.patch_size = patch_size
-        self.num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0])
-        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size, bias=bias)
-    def forward(self, x):
-        batch, _, height, width = x.shape
-        if height != self.img_size[0] or width != self.img_size[1]:
-            raise ValueError(
-                f"Input image size ({height}*{width}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})."
-            )
-        return self.proj(x).flatten(2).transpose(1, 2)
-class JLTTimestepEmbedder(nn.Module):
-    def __init__(self, hidden_size, frequency_embedding_size=256):
-        super().__init__()
-        self.mlp = nn.Sequential(
-            nn.Linear(frequency_embedding_size, hidden_size, bias=True),
-            nn.SiLU(),
-            nn.Linear(hidden_size, hidden_size, bias=True),
-        )
-        self.frequency_embedding_size = frequency_embedding_size
-    @staticmethod
-    def timestep_embedding(t, dim, max_period=10000):
-        half = dim // 2
-        freqs = torch.exp(
-            -math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32, device=t.device) / half
-        )
-        args = t.float().unsqueeze(-1) * freqs
-        embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
-        if dim % 2:
-            embedding = torch.cat([embedding, torch.zeros_like(embedding[..., :1])], dim=-1)
-        return embedding.to(t.dtype)
-    def forward(self, t, dtype=None):
-        t_freq = self.timestep_embedding(t, self.frequency_embedding_size)
-        if dtype is not None:
-            t_freq = t_freq.to(dtype=dtype)
-        return self.mlp(t_freq)
-class JLTLabelEmbedder(nn.Module):
-    def __init__(self, num_classes, hidden_size):
-        super().__init__()
-        self.embedding_table = nn.Embedding(num_classes + 1, hidden_size)
-        self.num_classes = num_classes
-    def forward(self, labels):
-        return self.embedding_table(labels)
-class JLTAttention(nn.Module):
-    def __init__(self, dim, num_heads=8, qkv_bias=True, qk_norm=True, attn_drop=0.0, proj_drop=0.0, eps=1e-6):
-        super().__init__()
-        self.num_heads = num_heads
-        head_dim = dim // num_heads
-        self.q_norm = RMSNorm(head_dim, eps=eps) if qk_norm else nn.Identity()
-        self.k_norm = RMSNorm(head_dim, eps=eps) if qk_norm else nn.Identity()
-        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
-        self.attn_drop = attn_drop
-        self.proj = nn.Linear(dim, dim)
-        self.proj_drop = nn.Dropout(proj_drop)
-    def forward(self, x, rope=None):
-        batch, num_tokens, channels = x.shape
-        qkv = self.qkv(x).reshape(batch, num_tokens, 3, self.num_heads, channels // self.num_heads).permute(2, 0, 3, 1, 4)
-        q, k, v = qkv[0], qkv[1], qkv[2]
-        q = self.q_norm(q)
-        k = self.k_norm(k)
-        if rope is not None:
-            q = q.transpose(1, 2)
-            k = k.transpose(1, 2)
-            q = rope(q)
-            k = rope(k)
-            q = q.transpose(1, 2)
-            k = k.transpose(1, 2)
-        if _HAS_FLASH_ATTN:
-            attn_dtype = q.dtype if q.dtype in (torch.float16, torch.bfloat16) else torch.bfloat16
-            q = q.transpose(1, 2).contiguous().to(attn_dtype)
-            k = k.transpose(1, 2).contiguous().to(attn_dtype)
-            v = v.transpose(1, 2).contiguous().to(attn_dtype)
-            x, _ = _flash_attn_func(q, k, v, causal=False)
-            x = x.reshape(batch, num_tokens, channels)
-        else:
-            dropout_p = self.attn_drop if self.training else 0.0
-            x = F.scaled_dot_product_attention(q, k, v, dropout_p=dropout_p)
-            x = x.transpose(1, 2).reshape(batch, num_tokens, channels)
-        x = self.proj(x)
-        return self.proj_drop(x)
-class JLTSwiGLUFFN(nn.Module):
-    def __init__(self, dim: int, hidden_dim: int, drop=0.0, bias=True) -> None:
-        super().__init__()
-        hidden_dim = int(hidden_dim * 2 / 3)
-        self.w12 = nn.Linear(dim, 2 * hidden_dim, bias=bias)
-        self.w3 = nn.Linear(hidden_dim, dim, bias=bias)
-        self.ffn_dropout = nn.Dropout(drop)
-    def forward(self, x):
-        x12 = self.w12(x)
-        x1, x2 = x12.chunk(2, dim=-1)
-        return self.w3(self.ffn_dropout(F.silu(x1) * x2))
-class JLTBlock(nn.Module):
-    def __init__(self, hidden_size, num_heads, mlp_ratio=4.0, attn_drop=0.0, proj_drop=0.0, eps=1e-6):
-        super().__init__()
-        self.norm1 = RMSNorm(hidden_size, eps=eps)
-        self.attn = JLTAttention(
-            hidden_size,
-            num_heads=num_heads,
-            qkv_bias=True,
-            qk_norm=True,
-            attn_drop=attn_drop,
-            proj_drop=proj_drop,
-            eps=eps,
-        )
-        self.norm2 = RMSNorm(hidden_size, eps=eps)
-        self.mlp = JLTSwiGLUFFN(hidden_size, int(hidden_size * mlp_ratio), drop=proj_drop)
-        self.adaLN_modulation = nn.Sequential(
-            nn.SiLU(),
-            nn.Linear(hidden_size, 6 * hidden_size, bias=True),
-        )
-    def forward(self, x, c, feat_rope=None):
-        shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.adaLN_modulation(c).chunk(6, dim=-1)
-        if gate_msa.ndim == x.ndim - 1:
-            gate_msa = gate_msa.unsqueeze(1)
-            gate_mlp = gate_mlp.unsqueeze(1)
-        x = x + gate_msa * self.attn(modulate(self.norm1(x), shift_msa, scale_msa), rope=feat_rope)
-        x = x + gate_mlp * self.mlp(modulate(self.norm2(x), shift_mlp, scale_mlp))
-        return x
-class JLTTransformer2DModel(ModelMixin, ConfigMixin):
-    _supports_gradient_checkpointing = True
-    @register_to_config
-    def __init__(
-        self,
-        sample_size: int = 16,
-        patch_size: int = 1,
-        in_channels: int = 128,
-        hidden_size: int = 768,
-        num_layers: int = 12,
-        num_attention_heads: int = 12,
-        mlp_ratio: float = 4.0,
-        attention_dropout: float = 0.0,
-        dropout: float = 0.0,
-        num_classes: int = 1000,
-        norm_eps: float = 1e-6,
-        model_type: str | None = None,
-        num_class_embeds: int | None = None,
-        mask_prob: float = 0.0,
-        mask_ratio: float = 0.0,
-        loop_indices: Optional[List[int]] = None,
-        loop_count: int = 0,
-    ):
-        super().__init__()
-        if num_class_embeds is not None:
-            num_classes = int(num_class_embeds)
-        if model_type in JLT_PRESET_CONFIGS:
-            preset = JLT_PRESET_CONFIGS[model_type]
-            sample_size = int(preset["sample_size"])
-            patch_size = int(preset["patch_size"])
-            hidden_size = int(preset["hidden_size"])
-            num_layers = int(preset["num_layers"])
-            num_attention_heads = int(preset["num_attention_heads"])
-            if attention_dropout == 0.0:
-                attention_dropout = float(preset["attention_dropout"])
-            if dropout == 0.0:
-                dropout = float(preset["dropout"])
-        self.sample_size = sample_size
-        self.patch_size = patch_size
-        self.in_channels = in_channels
-        self.out_channels = in_channels
-        self.hidden_size = hidden_size
-        self.num_layers = num_layers
-        self.num_attention_heads = num_attention_heads
-        self.mask_prob = float(mask_prob)
-        self.mask_ratio = float(mask_ratio)
-        self.loop_count = int(loop_count)
-        self.gradient_checkpointing = False
-        self.mask_token = nn.Parameter(torch.zeros(1, 1, hidden_size))
-        nn.init.normal_(self.mask_token, std=0.02)
-        self.loop_indices: Optional[Tuple[int, ...]] = None
-        if loop_indices and self.loop_count > 0:
-            sorted_idx = sorted(int(x) for x in loop_indices)
-            if len(set(sorted_idx)) != len(sorted_idx):
-                raise ValueError(f"loop_indices must be unique, got {loop_indices}.")
-            for i in range(1, len(sorted_idx)):
-                if sorted_idx[i] != sorted_idx[i - 1] + 1:
-                    raise ValueError(f"loop_indices must be consecutive integers, got {sorted_idx}.")
-            if sorted_idx[0] < 0 or sorted_idx[-1] >= num_layers:
-                raise ValueError(f"loop_indices must lie in [0, {num_layers}), got {sorted_idx}.")
-            self.loop_indices = tuple(sorted_idx)
-        self.t_embedder = JLTTimestepEmbedder(hidden_size)
-        self.y_embedder = JLTLabelEmbedder(num_classes, hidden_size)
-        self.x_embedder = JLTPatchEmbed(sample_size, patch_size, in_channels, hidden_size, bias=True)
-        half_head_dim = hidden_size // num_attention_heads // 2
-        hw_seq_len = sample_size // patch_size
-        self.feat_rope = JLTRotaryEmbedding(dim=half_head_dim, pt_seq_len=hw_seq_len, num_cls_token=0)
-        self.blocks = nn.ModuleList(
-            [
-                JLTBlock(
-                    hidden_size,
-                    num_attention_heads,
-                    mlp_ratio=mlp_ratio,
-                    attn_drop=attention_dropout if (num_layers // 4 * 3 > i >= num_layers // 4) else 0.0,
-                    proj_drop=dropout if (num_layers // 4 * 3 > i >= num_layers // 4) else 0.0,
-                    eps=norm_eps,
-                )
-                for i in range(num_layers)
-            ]
-        )
-        self.norm_final = RMSNorm(hidden_size, eps=norm_eps)
-        self.linear_final = nn.Linear(hidden_size, patch_size * patch_size * self.out_channels, bias=True)
-        self.adaLN_modulation_final = nn.Sequential(
-            nn.SiLU(),
-            nn.Linear(hidden_size, 2 * hidden_size, bias=True),
-        )
-        self.initialize_weights()
-    def initialize_weights(self):
-        def _basic_init(module):
-            if isinstance(module, nn.Linear):
-                torch.nn.init.xavier_uniform_(module.weight)
-                if module.bias is not None:
-                    nn.init.constant_(module.bias, 0)
-        self.apply(_basic_init)
-        w = self.x_embedder.proj.weight.data
-        nn.init.xavier_uniform_(w.view([w.shape[0], -1]))
-        nn.init.constant_(self.x_embedder.proj.bias, 0)
-        nn.init.normal_(self.y_embedder.embedding_table.weight, std=0.02)
-        nn.init.normal_(self.t_embedder.mlp[0].weight, std=0.02)
-        nn.init.normal_(self.t_embedder.mlp[2].weight, std=0.02)
-        for block in self.blocks:
-            nn.init.constant_(block.adaLN_modulation[-1].weight, 0)
-            nn.init.constant_(block.adaLN_modulation[-1].bias, 0)
-        nn.init.constant_(self.adaLN_modulation_final[-1].weight, 0)
-        nn.init.constant_(self.adaLN_modulation_final[-1].bias, 0)
-        nn.init.constant_(self.linear_final.weight, 0)
-        nn.init.constant_(self.linear_final.bias, 0)
-    def _block_schedule(self) -> List[int]:
-        if self.loop_indices is not None and self.loop_count > 0:
-            a, b = self.loop_indices[0], self.loop_indices[-1]
-            return list(range(0, a)) + list(range(a, b + 1)) * self.loop_count + list(range(b + 1, len(self.blocks)))
-        return list(range(len(self.blocks)))
-    def forward(
-        self,
-        sample: torch.Tensor,
-        timestep: torch.Tensor,
-        class_labels: torch.Tensor,
-        return_dict: bool = True,
-        return_features: bool = False,
-        feature_layers: Optional[List[int]] = None,
-    ):
-        t = torch.as_tensor(timestep, device=sample.device)
-        if t.ndim == 0:
-            t = t.repeat(sample.shape[0])
-        elif t.ndim == 1 and t.shape[0] == 1 and sample.shape[0] > 1:
-            t = t.repeat(sample.shape[0])
-        t_emb = self.t_embedder(t, dtype=sample.dtype)
-        y_emb = self.y_embedder(class_labels).to(dtype=sample.dtype)
-        if t_emb.ndim == 3:
-            y_emb = y_emb.unsqueeze(1)
-        c = t_emb + y_emb
-        x = self.x_embedder(sample)
-        if self.training and self.mask_prob > 0.0 and self.mask_ratio > 0.0:
-            batch, num_tokens, _ = x.shape
-            s_mask = torch.rand(batch, device=x.device) < self.mask_prob
-            t_mask = torch.rand(batch, num_tokens, device=x.device) < self.mask_ratio
-            mask = (s_mask.unsqueeze(1) & t_mask).unsqueeze(-1)
-            x = torch.where(mask, self.mask_token.to(x.dtype), x)
-        target_layers = set(feature_layers or [])
-        features = {} if return_features else None
-        for layer_idx in self._block_schedule():
-            if self.training and self.gradient_checkpointing:
-                x = torch.utils.checkpoint.checkpoint(
-                    self.blocks[layer_idx], x, c, self.feat_rope, use_reentrant=False
-                )
-            else:
-                x = self.blocks[layer_idx](x, c, self.feat_rope)
-            if return_features and layer_idx in target_layers:
-                features[layer_idx] = x
-        shift, scale = self.adaLN_modulation_final(c).chunk(2, dim=-1)
-        x = modulate(self.norm_final(x), shift, scale)
-        x = self.linear_final(x)
-        height = width = int(x.shape[1] ** 0.5)
-        x = x.reshape(x.shape[0], height, width, self.patch_size, self.patch_size, self.out_channels)
-        x = torch.einsum("nhwpqc->nchpwq", x)
-        output = x.reshape(x.shape[0], self.out_channels, height * self.patch_size, width * self.patch_size)
-        if return_features:
-            if not return_dict:
-                return (output, features)
-            return Transformer2DModelOutput(sample=output), features
-        if not return_dict:
-            return (output,)
-        return Transformer2DModelOutput(sample=output)
-    @classmethod
-    def from_jlt_checkpoint(
-        cls,
-        checkpoint_path: str,
-        weights: str = "ema1",
-        map_location: str = "cpu",
-        strict: bool = True,
-        in_channels: int | None = None,
-    ) -> Tuple["JLTTransformer2DModel", Dict[str, object]]:
-        checkpoint = torch.load(checkpoint_path, map_location=map_location, weights_only=False)
-        if "args" not in checkpoint:
-            raise ValueError("Checkpoint is missing 'args', cannot infer JLT architecture config.")
-        ckpt_args = checkpoint["args"]
-        if isinstance(ckpt_args, argparse.Namespace):
-            args_dict = vars(ckpt_args)
-        elif isinstance(ckpt_args, Mapping):
-            args_dict = dict(ckpt_args)
-        else:
-            raise TypeError(f"Unsupported checkpoint args type: {type(ckpt_args)}")
-        model_type = args_dict.get("model") or args_dict.get("model_name") or args_dict.get("model_type")
-        if model_type not in JLT_PRESET_CONFIGS:
-            raise ValueError(f"Unknown JLT preset '{model_type}'.")
-        config = dict(JLT_PRESET_CONFIGS[model_type])
-        config["num_classes"] = int(args_dict.get("class_num") or args_dict.get("num_classes") or 1000)
-        config["model_type"] = model_type
-        config["attention_dropout"] = float(
-            args_dict.get("attn_dropout", args_dict.get("attention_dropout", config["attention_dropout"]))
-        )
-        config["dropout"] = float(args_dict.get("proj_dropout", args_dict.get("dropout", config["dropout"])))
-        if in_channels is not None:
-            config["in_channels"] = in_channels
-        elif args_dict.get("vae_type") == "flux2":
-            config["in_channels"] = 128
-        if args_dict.get("img_size") and args_dict.get("vae_type") == "flux2":
-            spatial_compression = 16
-            config["sample_size"] = int(args_dict["img_size"]) // spatial_compression
-        mask_prob = float(args_dict.get("mask_prob", 0.0) or 0.0)
-        if mask_prob > 0.0:
-            config["mask_prob"] = mask_prob
-            config["mask_ratio"] = float(args_dict.get("mask_ratio", 0.0) or 0.0)
-        loop_count = int(args_dict.get("loop_count", 0) or 0)
-        if loop_count > 0:
-            loop_indices_raw = str(args_dict.get("loop_indices", "") or "")
-            loop_indices = [int(x) for x in loop_indices_raw.split(",") if x.strip()]
-            if loop_indices:
-                config["loop_indices"] = loop_indices
-                config["loop_count"] = loop_count
-        model = cls(**config)
-        if weights == "model":
-            key = "model"
-        else:
-            key = f"model_{weights}" if weights in {"ema1", "ema2"} else "model"
-        if key not in checkpoint:
-            raise ValueError(f"Checkpoint key '{key}' not found. Available keys: {list(checkpoint.keys())}")
-        state_dict = remap_legacy_state_dict(checkpoint[key])
-        model.load_state_dict(state_dict, strict=strict)
-        metadata = {
-            "checkpoint_path": checkpoint_path,
-            "weights": weights,
-            "epoch": checkpoint.get("epoch"),
-            "model_type": model_type,
-            "source_args": checkpoint.get("args"),
-        }
-        return model, metadata
-    def to_jlt_checkpoint(
-        self,
-        ema_mode: str = "copy_to_both",
-        prefix: str = "net.",
-    ) -> Dict[str, object]:
-        base_state: Dict[str, torch.Tensor] = {}
-        for key, value in self.state_dict().items():
-            legacy_key = key
-            if legacy_key.startswith("norm_final"):
-                legacy_key = legacy_key.replace("norm_final", "final_layer.norm_final", 1)
-            if legacy_key.startswith("linear_final"):
-                legacy_key = legacy_key.replace("linear_final", "final_layer.linear", 1)
-            if legacy_key.startswith("adaLN_modulation_final"):
-                legacy_key = legacy_key.replace("adaLN_modulation_final", "final_layer.adaLN_modulation", 1)
-            legacy_key = legacy_key.replace(".adaLN_modulation.", ".adaLN_modulation.1.")
-            base_state[f"{prefix}{legacy_key}"] = value.detach().cpu()
-        checkpoint = {"model": base_state}
-        if ema_mode == "copy_to_both":
-            checkpoint["model_ema1"] = {k: v.clone() for k, v in base_state.items()}
-            checkpoint["model_ema2"] = {k: v.clone() for k, v in base_state.items()}
-        elif ema_mode != "none":
-            raise ValueError(f"Unsupported ema_mode='{ema_mode}'.")
-        return checkpoint

JLT-B-1-256/vae/config.json DELETED Viewed

@@ -1,40 +0,0 @@
-{
-  "_class_name": "AutoencoderKLFlux2",
-  "_diffusers_version": "0.37.0.dev0",
-  "_name_or_path": "black-forest-labs/FLUX.2-dev",
-  "act_fn": "silu",
-  "batch_norm_eps": 0.0001,
-  "batch_norm_momentum": 0.1,
-  "block_out_channels": [
-    128,
-    256,
-    512,
-    512
-  ],
-  "down_block_types": [
-    "DownEncoderBlock2D",
-    "DownEncoderBlock2D",
-    "DownEncoderBlock2D",
-    "DownEncoderBlock2D"
-  ],
-  "force_upcast": true,
-  "in_channels": 3,
-  "latent_channels": 32,
-  "layers_per_block": 2,
-  "mid_block_add_attention": true,
-  "norm_num_groups": 32,
-  "out_channels": 3,
-  "patch_size": [
-    2,
-    2
-  ],
-  "sample_size": 1024,
-  "up_block_types": [
-    "UpDecoderBlock2D",
-    "UpDecoderBlock2D",
-    "UpDecoderBlock2D",
-    "UpDecoderBlock2D"
-  ],
-  "use_post_quant_conv": true,
-  "use_quant_conv": true
-}

JLT-B-1-256/vae/diffusion_pytorch_model.safetensors DELETED Viewed

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ca70d2202afe6415bdbcb8793ba8cd99fd159cfe6192381504d6c4d3036e0f04
-size 168120878

JLT-H-1-256/model_index.json DELETED Viewed

@@ -1,1021 +0,0 @@
-{
-  "_class_name": [
-    "pipeline",
-    "JLTPipeline"
-  ],
-  "_diffusers_version": "0.36.0",
-  "transformer": [
-    "transformer_jlt",
-    "JLTTransformer2DModel"
-  ],
-  "scheduler": [
-    "diffusers",
-    "FlowMatchHeunDiscreteScheduler"
-  ],
-  "vae": [
-    "diffusers",
-    "AutoencoderKLFlux2"
-  ],
-  "id2label": {
-    "0": "tench, Tinca tinca",
-    "1": "goldfish, Carassius auratus",
-    "2": "great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias",
-    "3": "tiger shark, Galeocerdo cuvieri",
-    "4": "hammerhead, hammerhead shark",
-    "5": "electric ray, crampfish, numbfish, torpedo",
-    "6": "stingray",
-    "7": "cock",
-    "8": "hen",
-    "9": "ostrich, Struthio camelus",
-    "10": "brambling, Fringilla montifringilla",
-    "11": "goldfinch, Carduelis carduelis",
-    "12": "house finch, linnet, Carpodacus mexicanus",
-    "13": "junco, snowbird",
-    "14": "indigo bunting, indigo finch, indigo bird, Passerina cyanea",
-    "15": "robin, American robin, Turdus migratorius",
-    "16": "bulbul",
-    "17": "jay",
-    "18": "magpie",
-    "19": "chickadee",
-    "20": "water ouzel, dipper",
-    "21": "kite",
-    "22": "bald eagle, American eagle, Haliaeetus leucocephalus",
-    "23": "vulture",
-    "24": "great grey owl, great gray owl, Strix nebulosa",
-    "25": "European fire salamander, Salamandra salamandra",
-    "26": "common newt, Triturus vulgaris",
-    "27": "eft",
-    "28": "spotted salamander, Ambystoma maculatum",
-    "29": "axolotl, mud puppy, Ambystoma mexicanum",
-    "30": "bullfrog, Rana catesbeiana",
-    "31": "tree frog, tree-frog",
-    "32": "tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui",
-    "33": "loggerhead, loggerhead turtle, Caretta caretta",
-    "34": "leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea",
-    "35": "mud turtle",
-    "36": "terrapin",
-    "37": "box turtle, box tortoise",
-    "38": "banded gecko",
-    "39": "common iguana, iguana, Iguana iguana",
-    "40": "American chameleon, anole, Anolis carolinensis",
-    "41": "whiptail, whiptail lizard",
-    "42": "agama",
-    "43": "frilled lizard, Chlamydosaurus kingi",
-    "44": "alligator lizard",
-    "45": "Gila monster, Heloderma suspectum",
-    "46": "green lizard, Lacerta viridis",
-    "47": "African chameleon, Chamaeleo chamaeleon",
-    "48": "Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis",
-    "49": "African crocodile, Nile crocodile, Crocodylus niloticus",
-    "50": "American alligator, Alligator mississipiensis",
-    "51": "triceratops",
-    "52": "thunder snake, worm snake, Carphophis amoenus",
-    "53": "ringneck snake, ring-necked snake, ring snake",
-    "54": "hognose snake, puff adder, sand viper",
-    "55": "green snake, grass snake",
-    "56": "king snake, kingsnake",
-    "57": "garter snake, grass snake",
-    "58": "water snake",
-    "59": "vine snake",
-    "60": "night snake, Hypsiglena torquata",
-    "61": "boa constrictor, Constrictor constrictor",
-    "62": "rock python, rock snake, Python sebae",
-    "63": "Indian cobra, Naja naja",
-    "64": "green mamba",
-    "65": "sea snake",
-    "66": "horned viper, cerastes, sand viper, horned asp, Cerastes cornutus",
-    "67": "diamondback, diamondback rattlesnake, Crotalus adamanteus",
-    "68": "sidewinder, horned rattlesnake, Crotalus cerastes",
-    "69": "trilobite",
-    "70": "harvestman, daddy longlegs, Phalangium opilio",
-    "71": "scorpion",
-    "72": "black and gold garden spider, Argiope aurantia",
-    "73": "barn spider, Araneus cavaticus",
-    "74": "garden spider, Aranea diademata",
-    "75": "black widow, Latrodectus mactans",
-    "76": "tarantula",
-    "77": "wolf spider, hunting spider",
-    "78": "tick",
-    "79": "centipede",
-    "80": "black grouse",
-    "81": "ptarmigan",
-    "82": "ruffed grouse, partridge, Bonasa umbellus",
-    "83": "prairie chicken, prairie grouse, prairie fowl",
-    "84": "peacock",
-    "85": "quail",
-    "86": "partridge",
-    "87": "African grey, African gray, Psittacus erithacus",
-    "88": "macaw",
-    "89": "sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita",
-    "90": "lorikeet",
-    "91": "coucal",
-    "92": "bee eater",
-    "93": "hornbill",
-    "94": "hummingbird",
-    "95": "jacamar",
-    "96": "toucan",
-    "97": "drake",
-    "98": "red-breasted merganser, Mergus serrator",
-    "99": "goose",
-    "100": "black swan, Cygnus atratus",
-    "101": "tusker",
-    "102": "echidna, spiny anteater, anteater",
-    "103": "platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus",
-    "104": "wallaby, brush kangaroo",
-    "105": "koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus",
-    "106": "wombat",
-    "107": "jellyfish",
-    "108": "sea anemone, anemone",
-    "109": "brain coral",
-    "110": "flatworm, platyhelminth",
-    "111": "nematode, nematode worm, roundworm",
-    "112": "conch",
-    "113": "snail",
-    "114": "slug",
-    "115": "sea slug, nudibranch",
-    "116": "chiton, coat-of-mail shell, sea cradle, polyplacophore",
-    "117": "chambered nautilus, pearly nautilus, nautilus",
-    "118": "Dungeness crab, Cancer magister",
-    "119": "rock crab, Cancer irroratus",
-    "120": "fiddler crab",
-    "121": "king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica",
-    "122": "American lobster, Northern lobster, Maine lobster, Homarus americanus",
-    "123": "spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish",
-    "124": "crayfish, crawfish, crawdad, crawdaddy",
-    "125": "hermit crab",
-    "126": "isopod",
-    "127": "white stork, Ciconia ciconia",
-    "128": "black stork, Ciconia nigra",
-    "129": "spoonbill",
-    "130": "flamingo",
-    "131": "little blue heron, Egretta caerulea",
-    "132": "American egret, great white heron, Egretta albus",
-    "133": "bittern",
-    "134": "crane",
-    "135": "limpkin, Aramus pictus",
-    "136": "European gallinule, Porphyrio porphyrio",
-    "137": "American coot, marsh hen, mud hen, water hen, Fulica americana",
-    "138": "bustard",
-    "139": "ruddy turnstone, Arenaria interpres",
-    "140": "red-backed sandpiper, dunlin, Erolia alpina",
-    "141": "redshank, Tringa totanus",
-    "142": "dowitcher",
-    "143": "oystercatcher, oyster catcher",
-    "144": "pelican",
-    "145": "king penguin, Aptenodytes patagonica",
-    "146": "albatross, mollymawk",
-    "147": "grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus",
-    "148": "killer whale, killer, orca, grampus, sea wolf, Orcinus orca",
-    "149": "dugong, Dugong dugon",
-    "150": "sea lion",
-    "151": "Chihuahua",
-    "152": "Japanese spaniel",
-    "153": "Maltese dog, Maltese terrier, Maltese",
-    "154": "Pekinese, Pekingese, Peke",
-    "155": "Shih-Tzu",
-    "156": "Blenheim spaniel",
-    "157": "papillon",
-    "158": "toy terrier",
-    "159": "Rhodesian ridgeback",
-    "160": "Afghan hound, Afghan",
-    "161": "basset, basset hound",
-    "162": "beagle",
-    "163": "bloodhound, sleuthhound",
-    "164": "bluetick",
-    "165": "black-and-tan coonhound",
-    "166": "Walker hound, Walker foxhound",
-    "167": "English foxhound",
-    "168": "redbone",
-    "169": "borzoi, Russian wolfhound",
-    "170": "Irish wolfhound",
-    "171": "Italian greyhound",
-    "172": "whippet",
-    "173": "Ibizan hound, Ibizan Podenco",
-    "174": "Norwegian elkhound, elkhound",
-    "175": "otterhound, otter hound",
-    "176": "Saluki, gazelle hound",
-    "177": "Scottish deerhound, deerhound",
-    "178": "Weimaraner",
-    "179": "Staffordshire bullterrier, Staffordshire bull terrier",
-    "180": "American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier",
-    "181": "Bedlington terrier",
-    "182": "Border terrier",
-    "183": "Kerry blue terrier",
-    "184": "Irish terrier",
-    "185": "Norfolk terrier",
-    "186": "Norwich terrier",
-    "187": "Yorkshire terrier",
-    "188": "wire-haired fox terrier",
-    "189": "Lakeland terrier",
-    "190": "Sealyham terrier, Sealyham",
-    "191": "Airedale, Airedale terrier",
-    "192": "cairn, cairn terrier",
-    "193": "Australian terrier",
-    "194": "Dandie Dinmont, Dandie Dinmont terrier",
-    "195": "Boston bull, Boston terrier",
-    "196": "miniature schnauzer",
-    "197": "giant schnauzer",
-    "198": "standard schnauzer",
-    "199": "Scotch terrier, Scottish terrier, Scottie",
-    "200": "Tibetan terrier, chrysanthemum dog",
-    "201": "silky terrier, Sydney silky",
-    "202": "soft-coated wheaten terrier",
-    "203": "West Highland white terrier",
-    "204": "Lhasa, Lhasa apso",
-    "205": "flat-coated retriever",
-    "206": "curly-coated retriever",
-    "207": "golden retriever",
-    "208": "Labrador retriever",
-    "209": "Chesapeake Bay retriever",
-    "210": "German short-haired pointer",
-    "211": "vizsla, Hungarian pointer",
-    "212": "English setter",
-    "213": "Irish setter, red setter",
-    "214": "Gordon setter",
-    "215": "Brittany spaniel",
-    "216": "clumber, clumber spaniel",
-    "217": "English springer, English springer spaniel",
-    "218": "Welsh springer spaniel",
-    "219": "cocker spaniel, English cocker spaniel, cocker",
-    "220": "Sussex spaniel",
-    "221": "Irish water spaniel",
-    "222": "kuvasz",
-    "223": "schipperke",
-    "224": "groenendael",
-    "225": "malinois",
-    "226": "briard",
-    "227": "kelpie",
-    "228": "komondor",
-    "229": "Old English sheepdog, bobtail",
-    "230": "Shetland sheepdog, Shetland sheep dog, Shetland",
-    "231": "collie",
-    "232": "Border collie",
-    "233": "Bouvier des Flandres, Bouviers des Flandres",
-    "234": "Rottweiler",
-    "235": "German shepherd, German shepherd dog, German police dog, alsatian",
-    "236": "Doberman, Doberman pinscher",
-    "237": "miniature pinscher",
-    "238": "Greater Swiss Mountain dog",
-    "239": "Bernese mountain dog",
-    "240": "Appenzeller",
-    "241": "EntleBucher",
-    "242": "boxer",
-    "243": "bull mastiff",
-    "244": "Tibetan mastiff",
-    "245": "French bulldog",
-    "246": "Great Dane",
-    "247": "Saint Bernard, St Bernard",
-    "248": "Eskimo dog, husky",
-    "249": "malamute, malemute, Alaskan malamute",
-    "250": "Siberian husky",
-    "251": "dalmatian, coach dog, carriage dog",
-    "252": "affenpinscher, monkey pinscher, monkey dog",
-    "253": "basenji",
-    "254": "pug, pug-dog",
-    "255": "Leonberg",
-    "256": "Newfoundland, Newfoundland dog",
-    "257": "Great Pyrenees",
-    "258": "Samoyed, Samoyede",
-    "259": "Pomeranian",
-    "260": "chow, chow chow",
-    "261": "keeshond",
-    "262": "Brabancon griffon",
-    "263": "Pembroke, Pembroke Welsh corgi",
-    "264": "Cardigan, Cardigan Welsh corgi",
-    "265": "toy poodle",
-    "266": "miniature poodle",
-    "267": "standard poodle",
-    "268": "Mexican hairless",
-    "269": "timber wolf, grey wolf, gray wolf, Canis lupus",
-    "270": "white wolf, Arctic wolf, Canis lupus tundrarum",
-    "271": "red wolf, maned wolf, Canis rufus, Canis niger",
-    "272": "coyote, prairie wolf, brush wolf, Canis latrans",
-    "273": "dingo, warrigal, warragal, Canis dingo",
-    "274": "dhole, Cuon alpinus",
-    "275": "African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus",
-    "276": "hyena, hyaena",
-    "277": "red fox, Vulpes vulpes",
-    "278": "kit fox, Vulpes macrotis",
-    "279": "Arctic fox, white fox, Alopex lagopus",
-    "280": "grey fox, gray fox, Urocyon cinereoargenteus",
-    "281": "tabby, tabby cat",
-    "282": "tiger cat",
-    "283": "Persian cat",
-    "284": "Siamese cat, Siamese",
-    "285": "Egyptian cat",
-    "286": "cougar, puma, catamount, mountain lion, painter, panther, Felis concolor",
-    "287": "lynx, catamount",
-    "288": "leopard, Panthera pardus",
-    "289": "snow leopard, ounce, Panthera uncia",
-    "290": "jaguar, panther, Panthera onca, Felis onca",
-    "291": "lion, king of beasts, Panthera leo",
-    "292": "tiger, Panthera tigris",
-    "293": "cheetah, chetah, Acinonyx jubatus",
-    "294": "brown bear, bruin, Ursus arctos",
-    "295": "American black bear, black bear, Ursus americanus, Euarctos americanus",
-    "296": "ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus",
-    "297": "sloth bear, Melursus ursinus, Ursus ursinus",
-    "298": "mongoose",
-    "299": "meerkat, mierkat",
-    "300": "tiger beetle",
-    "301": "ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle",
-    "302": "ground beetle, carabid beetle",
-    "303": "long-horned beetle, longicorn, longicorn beetle",
-    "304": "leaf beetle, chrysomelid",
-    "305": "dung beetle",
-    "306": "rhinoceros beetle",
-    "307": "weevil",
-    "308": "fly",
-    "309": "bee",
-    "310": "ant, emmet, pismire",
-    "311": "grasshopper, hopper",
-    "312": "cricket",
-    "313": "walking stick, walkingstick, stick insect",
-    "314": "cockroach, roach",
-    "315": "mantis, mantid",
-    "316": "cicada, cicala",
-    "317": "leafhopper",
-    "318": "lacewing, lacewing fly",
-    "319": "dragonfly, darning needle, devils darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk",
-    "320": "damselfly",
-    "321": "admiral",
-    "322": "ringlet, ringlet butterfly",
-    "323": "monarch, monarch butterfly, milkweed butterfly, Danaus plexippus",
-    "324": "cabbage butterfly",
-    "325": "sulphur butterfly, sulfur butterfly",
-    "326": "lycaenid, lycaenid butterfly",
-    "327": "starfish, sea star",
-    "328": "sea urchin",
-    "329": "sea cucumber, holothurian",
-    "330": "wood rabbit, cottontail, cottontail rabbit",
-    "331": "hare",
-    "332": "Angora, Angora rabbit",
-    "333": "hamster",
-    "334": "porcupine, hedgehog",
-    "335": "fox squirrel, eastern fox squirrel, Sciurus niger",
-    "336": "marmot",
-    "337": "beaver",
-    "338": "guinea pig, Cavia cobaya",
-    "339": "sorrel",
-    "340": "zebra",
-    "341": "hog, pig, grunter, squealer, Sus scrofa",
-    "342": "wild boar, boar, Sus scrofa",
-    "343": "warthog",
-    "344": "hippopotamus, hippo, river horse, Hippopotamus amphibius",
-    "345": "ox",
-    "346": "water buffalo, water ox, Asiatic buffalo, Bubalus bubalis",
-    "347": "bison",
-    "348": "ram, tup",
-    "349": "bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis",
-    "350": "ibex, Capra ibex",
-    "351": "hartebeest",
-    "352": "impala, Aepyceros melampus",
-    "353": "gazelle",
-    "354": "Arabian camel, dromedary, Camelus dromedarius",
-    "355": "llama",
-    "356": "weasel",
-    "357": "mink",
-    "358": "polecat, fitch, foulmart, foumart, Mustela putorius",
-    "359": "black-footed ferret, ferret, Mustela nigripes",
-    "360": "otter",
-    "361": "skunk, polecat, wood pussy",
-    "362": "badger",
-    "363": "armadillo",
-    "364": "three-toed sloth, ai, Bradypus tridactylus",
-    "365": "orangutan, orang, orangutang, Pongo pygmaeus",
-    "366": "gorilla, Gorilla gorilla",
-    "367": "chimpanzee, chimp, Pan troglodytes",
-    "368": "gibbon, Hylobates lar",
-    "369": "siamang, Hylobates syndactylus, Symphalangus syndactylus",
-    "370": "guenon, guenon monkey",
-    "371": "patas, hussar monkey, Erythrocebus patas",
-    "372": "baboon",
-    "373": "macaque",
-    "374": "langur",
-    "375": "colobus, colobus monkey",
-    "376": "proboscis monkey, Nasalis larvatus",
-    "377": "marmoset",
-    "378": "capuchin, ringtail, Cebus capucinus",
-    "379": "howler monkey, howler",
-    "380": "titi, titi monkey",
-    "381": "spider monkey, Ateles geoffroyi",
-    "382": "squirrel monkey, Saimiri sciureus",
-    "383": "Madagascar cat, ring-tailed lemur, Lemur catta",
-    "384": "indri, indris, Indri indri, Indri brevicaudatus",
-    "385": "Indian elephant, Elephas maximus",
-    "386": "African elephant, Loxodonta africana",
-    "387": "lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens",
-    "388": "giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca",
-    "389": "barracouta, snoek",
-    "390": "eel",
-    "391": "coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch",
-    "392": "rock beauty, Holocanthus tricolor",
-    "393": "anemone fish",
-    "394": "sturgeon",
-    "395": "gar, garfish, garpike, billfish, Lepisosteus osseus",
-    "396": "lionfish",
-    "397": "puffer, pufferfish, blowfish, globefish",
-    "398": "abacus",
-    "399": "abaya",
-    "400": "academic gown, academic robe, judge robe",
-    "401": "accordion, piano accordion, squeeze box",
-    "402": "acoustic guitar",
-    "403": "aircraft carrier, carrier, flattop, attack aircraft carrier",
-    "404": "airliner",
-    "405": "airship, dirigible",
-    "406": "altar",
-    "407": "ambulance",
-    "408": "amphibian, amphibious vehicle",
-    "409": "analog clock",
-    "410": "apiary, bee house",
-    "411": "apron",
-    "412": "ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin",
-    "413": "assault rifle, assault gun",
-    "414": "backpack, back pack, knapsack, packsack, rucksack, haversack",
-    "415": "bakery, bakeshop, bakehouse",
-    "416": "balance beam, beam",
-    "417": "balloon",
-    "418": "ballpoint, ballpoint pen, ballpen, Biro",
-    "419": "Band Aid",
-    "420": "banjo",
-    "421": "bannister, banister, balustrade, balusters, handrail",
-    "422": "barbell",
-    "423": "barber chair",
-    "424": "barbershop",
-    "425": "barn",
-    "426": "barometer",
-    "427": "barrel, cask",
-    "428": "barrow, garden cart, lawn cart, wheelbarrow",
-    "429": "baseball",
-    "430": "basketball",
-    "431": "bassinet",
-    "432": "bassoon",
-    "433": "bathing cap, swimming cap",
-    "434": "bath towel",
-    "435": "bathtub, bathing tub, bath, tub",
-    "436": "beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon",
-    "437": "beacon, lighthouse, beacon light, pharos",
-    "438": "beaker",
-    "439": "bearskin, busby, shako",
-    "440": "beer bottle",
-    "441": "beer glass",
-    "442": "bell cote, bell cot",
-    "443": "bib",
-    "444": "bicycle-built-for-two, tandem bicycle, tandem",
-    "445": "bikini, two-piece",
-    "446": "binder, ring-binder",
-    "447": "binoculars, field glasses, opera glasses",
-    "448": "birdhouse",
-    "449": "boathouse",
-    "450": "bobsled, bobsleigh, bob",
-    "451": "bolo tie, bolo, bola tie, bola",
-    "452": "bonnet, poke bonnet",
-    "453": "bookcase",
-    "454": "bookshop, bookstore, bookstall",
-    "455": "bottlecap",
-    "456": "bow",
-    "457": "bow tie, bow-tie, bowtie",
-    "458": "brass, memorial tablet, plaque",
-    "459": "brassiere, bra, bandeau",
-    "460": "breakwater, groin, groyne, mole, bulwark, seawall, jetty",
-    "461": "breastplate, aegis, egis",
-    "462": "broom",
-    "463": "bucket, pail",
-    "464": "buckle",
-    "465": "bulletproof vest",
-    "466": "bullet train, bullet",
-    "467": "butcher shop, meat market",
-    "468": "cab, hack, taxi, taxicab",
-    "469": "caldron, cauldron",
-    "470": "candle, taper, wax light",
-    "471": "cannon",
-    "472": "canoe",
-    "473": "can opener, tin opener",
-    "474": "cardigan",
-    "475": "car mirror",
-    "476": "carousel, carrousel, merry-go-round, roundabout, whirligig",
-    "477": "carpenters kit, tool kit",
-    "478": "carton",
-    "479": "car wheel",
-    "480": "cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM",
-    "481": "cassette",
-    "482": "cassette player",
-    "483": "castle",
-    "484": "catamaran",
-    "485": "CD player",
-    "486": "cello, violoncello",
-    "487": "cellular telephone, cellular phone, cellphone, cell, mobile phone",
-    "488": "chain",
-    "489": "chainlink fence",
-    "490": "chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour",
-    "491": "chain saw, chainsaw",
-    "492": "chest",
-    "493": "chiffonier, commode",
-    "494": "chime, bell, gong",
-    "495": "china cabinet, china closet",
-    "496": "Christmas stocking",
-    "497": "church, church building",
-    "498": "cinema, movie theater, movie theatre, movie house, picture palace",
-    "499": "cleaver, meat cleaver, chopper",
-    "500": "cliff dwelling",
-    "501": "cloak",
-    "502": "clog, geta, patten, sabot",
-    "503": "cocktail shaker",
-    "504": "coffee mug",
-    "505": "coffeepot",
-    "506": "coil, spiral, volute, whorl, helix",
-    "507": "combination lock",
-    "508": "computer keyboard, keypad",
-    "509": "confectionery, confectionary, candy store",
-    "510": "container ship, containership, container vessel",
-    "511": "convertible",
-    "512": "corkscrew, bottle screw",
-    "513": "cornet, horn, trumpet, trump",
-    "514": "cowboy boot",
-    "515": "cowboy hat, ten-gallon hat",
-    "516": "cradle",
-    "517": "crane",
-    "518": "crash helmet",
-    "519": "crate",
-    "520": "crib, cot",
-    "521": "Crock Pot",
-    "522": "croquet ball",
-    "523": "crutch",
-    "524": "cuirass",
-    "525": "dam, dike, dyke",
-    "526": "desk",
-    "527": "desktop computer",
-    "528": "dial telephone, dial phone",
-    "529": "diaper, nappy, napkin",
-    "530": "digital clock",
-    "531": "digital watch",
-    "532": "dining table, board",
-    "533": "dishrag, dishcloth",
-    "534": "dishwasher, dish washer, dishwashing machine",
-    "535": "disk brake, disc brake",
-    "536": "dock, dockage, docking facility",
-    "537": "dogsled, dog sled, dog sleigh",
-    "538": "dome",
-    "539": "doormat, welcome mat",
-    "540": "drilling platform, offshore rig",
-    "541": "drum, membranophone, tympan",
-    "542": "drumstick",
-    "543": "dumbbell",
-    "544": "Dutch oven",
-    "545": "electric fan, blower",
-    "546": "electric guitar",
-    "547": "electric locomotive",
-    "548": "entertainment center",
-    "549": "envelope",
-    "550": "espresso maker",
-    "551": "face powder",
-    "552": "feather boa, boa",
-    "553": "file, file cabinet, filing cabinet",
-    "554": "fireboat",
-    "555": "fire engine, fire truck",
-    "556": "fire screen, fireguard",
-    "557": "flagpole, flagstaff",
-    "558": "flute, transverse flute",
-    "559": "folding chair",
-    "560": "football helmet",
-    "561": "forklift",
-    "562": "fountain",
-    "563": "fountain pen",
-    "564": "four-poster",
-    "565": "freight car",
-    "566": "French horn, horn",
-    "567": "frying pan, frypan, skillet",
-    "568": "fur coat",
-    "569": "garbage truck, dustcart",
-    "570": "gasmask, respirator, gas helmet",
-    "571": "gas pump, gasoline pump, petrol pump, island dispenser",
-    "572": "goblet",
-    "573": "go-kart",
-    "574": "golf ball",
-    "575": "golfcart, golf cart",
-    "576": "gondola",
-    "577": "gong, tam-tam",
-    "578": "gown",
-    "579": "grand piano, grand",
-    "580": "greenhouse, nursery, glasshouse",
-    "581": "grille, radiator grille",
-    "582": "grocery store, grocery, food market, market",
-    "583": "guillotine",
-    "584": "hair slide",
-    "585": "hair spray",
-    "586": "half track",
-    "587": "hammer",
-    "588": "hamper",
-    "589": "hand blower, blow dryer, blow drier, hair dryer, hair drier",
-    "590": "hand-held computer, hand-held microcomputer",
-    "591": "handkerchief, hankie, hanky, hankey",
-    "592": "hard disc, hard disk, fixed disk",
-    "593": "harmonica, mouth organ, harp, mouth harp",
-    "594": "harp",
-    "595": "harvester, reaper",
-    "596": "hatchet",
-    "597": "holster",
-    "598": "home theater, home theatre",
-    "599": "honeycomb",
-    "600": "hook, claw",
-    "601": "hoopskirt, crinoline",
-    "602": "horizontal bar, high bar",
-    "603": "horse cart, horse-cart",
-    "604": "hourglass",
-    "605": "iPod",
-    "606": "iron, smoothing iron",
-    "607": "jack-o-lantern",
-    "608": "jean, blue jean, denim",
-    "609": "jeep, landrover",
-    "610": "jersey, T-shirt, tee shirt",
-    "611": "jigsaw puzzle",
-    "612": "jinrikisha, ricksha, rickshaw",
-    "613": "joystick",
-    "614": "kimono",
-    "615": "knee pad",
-    "616": "knot",
-    "617": "lab coat, laboratory coat",
-    "618": "ladle",
-    "619": "lampshade, lamp shade",
-    "620": "laptop, laptop computer",
-    "621": "lawn mower, mower",
-    "622": "lens cap, lens cover",
-    "623": "letter opener, paper knife, paperknife",
-    "624": "library",
-    "625": "lifeboat",
-    "626": "lighter, light, igniter, ignitor",
-    "627": "limousine, limo",
-    "628": "liner, ocean liner",
-    "629": "lipstick, lip rouge",
-    "630": "Loafer",
-    "631": "lotion",
-    "632": "loudspeaker, speaker, speaker unit, loudspeaker system, speaker system",
-    "633": "loupe, jewelers loupe",
-    "634": "lumbermill, sawmill",
-    "635": "magnetic compass",
-    "636": "mailbag, postbag",
-    "637": "mailbox, letter box",
-    "638": "maillot",
-    "639": "maillot, tank suit",
-    "640": "manhole cover",
-    "641": "maraca",
-    "642": "marimba, xylophone",
-    "643": "mask",
-    "644": "matchstick",
-    "645": "maypole",
-    "646": "maze, labyrinth",
-    "647": "measuring cup",
-    "648": "medicine chest, medicine cabinet",
-    "649": "megalith, megalithic structure",
-    "650": "microphone, mike",
-    "651": "microwave, microwave oven",
-    "652": "military uniform",
-    "653": "milk can",
-    "654": "minibus",
-    "655": "miniskirt, mini",
-    "656": "minivan",
-    "657": "missile",
-    "658": "mitten",
-    "659": "mixing bowl",
-    "660": "mobile home, manufactured home",
-    "661": "Model T",
-    "662": "modem",
-    "663": "monastery",
-    "664": "monitor",
-    "665": "moped",
-    "666": "mortar",
-    "667": "mortarboard",
-    "668": "mosque",
-    "669": "mosquito net",
-    "670": "motor scooter, scooter",
-    "671": "mountain bike, all-terrain bike, off-roader",
-    "672": "mountain tent",
-    "673": "mouse, computer mouse",
-    "674": "mousetrap",
-    "675": "moving van",
-    "676": "muzzle",
-    "677": "nail",
-    "678": "neck brace",
-    "679": "necklace",
-    "680": "nipple",
-    "681": "notebook, notebook computer",
-    "682": "obelisk",
-    "683": "oboe, hautboy, hautbois",
-    "684": "ocarina, sweet potato",
-    "685": "odometer, hodometer, mileometer, milometer",
-    "686": "oil filter",
-    "687": "organ, pipe organ",
-    "688": "oscilloscope, scope, cathode-ray oscilloscope, CRO",
-    "689": "overskirt",
-    "690": "oxcart",
-    "691": "oxygen mask",
-    "692": "packet",
-    "693": "paddle, boat paddle",
-    "694": "paddlewheel, paddle wheel",
-    "695": "padlock",
-    "696": "paintbrush",
-    "697": "pajama, pyjama, pjs, jammies",
-    "698": "palace",
-    "699": "panpipe, pandean pipe, syrinx",
-    "700": "paper towel",
-    "701": "parachute, chute",
-    "702": "parallel bars, bars",
-    "703": "park bench",
-    "704": "parking meter",
-    "705": "passenger car, coach, carriage",
-    "706": "patio, terrace",
-    "707": "pay-phone, pay-station",
-    "708": "pedestal, plinth, footstall",
-    "709": "pencil box, pencil case",
-    "710": "pencil sharpener",
-    "711": "perfume, essence",
-    "712": "Petri dish",
-    "713": "photocopier",
-    "714": "pick, plectrum, plectron",
-    "715": "pickelhaube",
-    "716": "picket fence, paling",
-    "717": "pickup, pickup truck",
-    "718": "pier",
-    "719": "piggy bank, penny bank",
-    "720": "pill bottle",
-    "721": "pillow",
-    "722": "ping-pong ball",
-    "723": "pinwheel",
-    "724": "pirate, pirate ship",
-    "725": "pitcher, ewer",
-    "726": "plane, carpenters plane, woodworking plane",
-    "727": "planetarium",
-    "728": "plastic bag",
-    "729": "plate rack",
-    "730": "plow, plough",
-    "731": "plunger, plumbers helper",
-    "732": "Polaroid camera, Polaroid Land camera",
-    "733": "pole",
-    "734": "police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria",
-    "735": "poncho",
-    "736": "pool table, billiard table, snooker table",
-    "737": "pop bottle, soda bottle",
-    "738": "pot, flowerpot",
-    "739": "potters wheel",
-    "740": "power drill",
-    "741": "prayer rug, prayer mat",
-    "742": "printer",
-    "743": "prison, prison house",
-    "744": "projectile, missile",
-    "745": "projector",
-    "746": "puck, hockey puck",
-    "747": "punching bag, punch bag, punching ball, punchball",
-    "748": "purse",
-    "749": "quill, quill pen",
-    "750": "quilt, comforter, comfort, puff",
-    "751": "racer, race car, racing car",
-    "752": "racket, racquet",
-    "753": "radiator",
-    "754": "radio, wireless",
-    "755": "radio telescope, radio reflector",
-    "756": "rain barrel",
-    "757": "recreational vehicle, RV, R.V.",
-    "758": "reel",
-    "759": "reflex camera",
-    "760": "refrigerator, icebox",
-    "761": "remote control, remote",
-    "762": "restaurant, eating house, eating place, eatery",
-    "763": "revolver, six-gun, six-shooter",
-    "764": "rifle",
-    "765": "rocking chair, rocker",
-    "766": "rotisserie",
-    "767": "rubber eraser, rubber, pencil eraser",
-    "768": "rugby ball",
-    "769": "rule, ruler",
-    "770": "running shoe",
-    "771": "safe",
-    "772": "safety pin",
-    "773": "saltshaker, salt shaker",
-    "774": "sandal",
-    "775": "sarong",
-    "776": "sax, saxophone",
-    "777": "scabbard",
-    "778": "scale, weighing machine",
-    "779": "school bus",
-    "780": "schooner",
-    "781": "scoreboard",
-    "782": "screen, CRT screen",
-    "783": "screw",
-    "784": "screwdriver",
-    "785": "seat belt, seatbelt",
-    "786": "sewing machine",
-    "787": "shield, buckler",
-    "788": "shoe shop, shoe-shop, shoe store",
-    "789": "shoji",
-    "790": "shopping basket",
-    "791": "shopping cart",
-    "792": "shovel",
-    "793": "shower cap",
-    "794": "shower curtain",
-    "795": "ski",
-    "796": "ski mask",
-    "797": "sleeping bag",
-    "798": "slide rule, slipstick",
-    "799": "sliding door",
-    "800": "slot, one-armed bandit",
-    "801": "snorkel",
-    "802": "snowmobile",
-    "803": "snowplow, snowplough",
-    "804": "soap dispenser",
-    "805": "soccer ball",
-    "806": "sock",
-    "807": "solar dish, solar collector, solar furnace",
-    "808": "sombrero",
-    "809": "soup bowl",
-    "810": "space bar",
-    "811": "space heater",
-    "812": "space shuttle",
-    "813": "spatula",
-    "814": "speedboat",
-    "815": "spider web, spiders web",
-    "816": "spindle",
-    "817": "sports car, sport car",
-    "818": "spotlight, spot",
-    "819": "stage",
-    "820": "steam locomotive",
-    "821": "steel arch bridge",
-    "822": "steel drum",
-    "823": "stethoscope",
-    "824": "stole",
-    "825": "stone wall",
-    "826": "stopwatch, stop watch",
-    "827": "stove",
-    "828": "strainer",
-    "829": "streetcar, tram, tramcar, trolley, trolley car",
-    "830": "stretcher",
-    "831": "studio couch, day bed",
-    "832": "stupa, tope",
-    "833": "submarine, pigboat, sub, U-boat",
-    "834": "suit, suit of clothes",
-    "835": "sundial",
-    "836": "sunglass",
-    "837": "sunglasses, dark glasses, shades",
-    "838": "sunscreen, sunblock, sun blocker",
-    "839": "suspension bridge",
-    "840": "swab, swob, mop",
-    "841": "sweatshirt",
-    "842": "swimming trunks, bathing trunks",
-    "843": "swing",
-    "844": "switch, electric switch, electrical switch",
-    "845": "syringe",
-    "846": "table lamp",
-    "847": "tank, army tank, armored combat vehicle, armoured combat vehicle",
-    "848": "tape player",
-    "849": "teapot",
-    "850": "teddy, teddy bear",
-    "851": "television, television system",
-    "852": "tennis ball",
-    "853": "thatch, thatched roof",
-    "854": "theater curtain, theatre curtain",
-    "855": "thimble",
-    "856": "thresher, thrasher, threshing machine",
-    "857": "throne",
-    "858": "tile roof",
-    "859": "toaster",
-    "860": "tobacco shop, tobacconist shop, tobacconist",
-    "861": "toilet seat",
-    "862": "torch",
-    "863": "totem pole",
-    "864": "tow truck, tow car, wrecker",
-    "865": "toyshop",
-    "866": "tractor",
-    "867": "trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi",
-    "868": "tray",
-    "869": "trench coat",
-    "870": "tricycle, trike, velocipede",
-    "871": "trimaran",
-    "872": "tripod",
-    "873": "triumphal arch",
-    "874": "trolleybus, trolley coach, trackless trolley",
-    "875": "trombone",
-    "876": "tub, vat",
-    "877": "turnstile",
-    "878": "typewriter keyboard",
-    "879": "umbrella",
-    "880": "unicycle, monocycle",
-    "881": "upright, upright piano",
-    "882": "vacuum, vacuum cleaner",
-    "883": "vase",
-    "884": "vault",
-    "885": "velvet",
-    "886": "vending machine",
-    "887": "vestment",
-    "888": "viaduct",
-    "889": "violin, fiddle",
-    "890": "volleyball",
-    "891": "waffle iron",
-    "892": "wall clock",
-    "893": "wallet, billfold, notecase, pocketbook",
-    "894": "wardrobe, closet, press",
-    "895": "warplane, military plane",
-    "896": "washbasin, handbasin, washbowl, lavabo, wash-hand basin",
-    "897": "washer, automatic washer, washing machine",
-    "898": "water bottle",
-    "899": "water jug",
-    "900": "water tower",
-    "901": "whiskey jug",
-    "902": "whistle",
-    "903": "wig",
-    "904": "window screen",
-    "905": "window shade",
-    "906": "Windsor tie",
-    "907": "wine bottle",
-    "908": "wing",
-    "909": "wok",
-    "910": "wooden spoon",
-    "911": "wool, woolen, woollen",
-    "912": "worm fence, snake fence, snake-rail fence, Virginia fence",
-    "913": "wreck",
-    "914": "yawl",
-    "915": "yurt",
-    "916": "web site, website, internet site, site",
-    "917": "comic book",
-    "918": "crossword puzzle, crossword",
-    "919": "street sign",
-    "920": "traffic light, traffic signal, stoplight",
-    "921": "book jacket, dust cover, dust jacket, dust wrapper",
-    "922": "menu",
-    "923": "plate",
-    "924": "guacamole",
-    "925": "consomme",
-    "926": "hot pot, hotpot",
-    "927": "trifle",
-    "928": "ice cream, icecream",
-    "929": "ice lolly, lolly, lollipop, popsicle",
-    "930": "French loaf",
-    "931": "bagel, beigel",
-    "932": "pretzel",
-    "933": "cheeseburger",
-    "934": "hotdog, hot dog, red hot",
-    "935": "mashed potato",
-    "936": "head cabbage",
-    "937": "broccoli",
-    "938": "cauliflower",
-    "939": "zucchini, courgette",
-    "940": "spaghetti squash",
-    "941": "acorn squash",
-    "942": "butternut squash",
-    "943": "cucumber, cuke",
-    "944": "artichoke, globe artichoke",
-    "945": "bell pepper",
-    "946": "cardoon",
-    "947": "mushroom",
-    "948": "Granny Smith",
-    "949": "strawberry",
-    "950": "orange",
-    "951": "lemon",
-    "952": "fig",
-    "953": "pineapple, ananas",
-    "954": "banana",
-    "955": "jackfruit, jak, jack",
-    "956": "custard apple",
-    "957": "pomegranate",
-    "958": "hay",
-    "959": "carbonara",
-    "960": "chocolate sauce, chocolate syrup",
-    "961": "dough",
-    "962": "meat loaf, meatloaf",
-    "963": "pizza, pizza pie",
-    "964": "potpie",
-    "965": "burrito",
-    "966": "red wine",
-    "967": "espresso",
-    "968": "cup",
-    "969": "eggnog",
-    "970": "alp",
-    "971": "bubble",
-    "972": "cliff, drop, drop-off",
-    "973": "coral reef",
-    "974": "geyser",
-    "975": "lakeside, lakeshore",
-    "976": "promontory, headland, head, foreland",
-    "977": "sandbar, sand bar",
-    "978": "seashore, coast, seacoast, sea-coast",
-    "979": "valley, vale",
-    "980": "volcano",
-    "981": "ballplayer, baseball player",
-    "982": "groom, bridegroom",
-    "983": "scuba diver",
-    "984": "rapeseed",
-    "985": "daisy",
-    "986": "yellow ladys slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum",
-    "987": "corn",
-    "988": "acorn",
-    "989": "hip, rose hip, rosehip",
-    "990": "buckeye, horse chestnut, conker",
-    "991": "coral fungus",
-    "992": "agaric",
-    "993": "gyromitra",
-    "994": "stinkhorn, carrion fungus",
-    "995": "earthstar",
-    "996": "hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa",
-    "997": "bolete",
-    "998": "ear, spike, capitulum",
-    "999": "toilet tissue, toilet paper, bathroom tissue"
-  }
-}

JLT-H-1-256/pipeline.py DELETED Viewed

@@ -1,548 +0,0 @@
-"""Hub custom pipeline: JLTPipeline.
-Load with native Hugging Face diffusers and trust_remote_code=True.
-"""
-from __future__ import annotations
-import importlib
-import json
-import sys
-from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Union
-import numpy as np
-import torch
-from diffusers import AutoencoderKLFlux2
-from diffusers.pipelines.pipeline_utils import DiffusionPipeline, ImagePipelineOutput
-from diffusers.schedulers import FlowMatchEulerDiscreteScheduler, FlowMatchHeunDiscreteScheduler
-from diffusers.schedulers.scheduling_utils import SchedulerMixin
-from diffusers.utils.torch_utils import randn_tensor
-def configure_linear_flow_timesteps(
-    scheduler: SchedulerMixin,
-    num_inference_steps: int,
-    device: Union[str, torch.device, None] = None,
-) -> None:
-    if isinstance(scheduler, FlowMatchHeunDiscreteScheduler):
-        scheduler.num_inference_steps = num_inference_steps
-        sigmas = np.linspace(1.0, 0.0, num_inference_steps, dtype=np.float32)
-        sigmas_t = torch.from_numpy(sigmas).to(dtype=torch.float32, device=device)
-        shift = scheduler.config.shift
-        sigmas_t = shift * sigmas_t / (1 + (shift - 1) * sigmas_t)
-        timesteps = sigmas_t * scheduler.config.num_train_timesteps
-        timesteps = torch.cat([timesteps[:1], timesteps[1:].repeat_interleave(2)])
-        scheduler.timesteps = timesteps.to(device=device)
-        sigmas_t = torch.cat([sigmas_t, torch.zeros(1, device=sigmas_t.device)])
-        scheduler.sigmas = torch.cat([sigmas_t[:1], sigmas_t[1:-1].repeat_interleave(2), sigmas_t[-1:]])
-        scheduler._step_index = None
-        scheduler._begin_index = None
-        scheduler.prev_derivative = None
-        scheduler.dt = None
-        scheduler.sample = None
-        return
-    sigmas = np.linspace(1.0, 0.0, num_inference_steps, dtype=np.float32).tolist()
-    scheduler.set_timesteps(num_inference_steps, device=device, sigmas=sigmas)
-def velocity_from_prediction(
-    sample: torch.Tensor,
-    model_output: torch.Tensor,
-    timestep: Union[float, torch.Tensor],
-    *,
-    prediction_type: str = "sample",
-    t_eps: float = 5e-2,
-) -> torch.Tensor:
-    if prediction_type == "velocity":
-        return model_output
-    t = torch.as_tensor(timestep, device=sample.device, dtype=sample.dtype)
-    while t.ndim < sample.ndim:
-        t = t.unsqueeze(-1)
-    denom = (1.0 - t).clamp_min(t_eps)
-    return (model_output - sample) / denom
-def _unpatchify_latents(latents: torch.Tensor) -> torch.Tensor:
-    batch_size, num_channels_latents, height, width = latents.shape
-    latents = latents.reshape(batch_size, num_channels_latents // (2 * 2), 2, 2, height, width)
-    latents = latents.permute(0, 1, 4, 2, 5, 3)
-    return latents.reshape(batch_size, num_channels_latents // (2 * 2), height * 2, width * 2)
-def _flux2_bn_stats(vae: AutoencoderKLFlux2, ref: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
-    mean = vae.bn.running_mean.view(1, -1, 1, 1).to(ref.device, ref.dtype)
-    std = torch.sqrt(
-        vae.bn.running_var.view(1, -1, 1, 1).to(ref.device, ref.dtype) + vae.config.batch_norm_eps
-    )
-    return mean, std
-@torch.no_grad()
-def decode_flux2_latents(vae: AutoencoderKLFlux2, latents: torch.Tensor) -> torch.Tensor:
-    vae_param = next(vae.parameters())
-    latents = latents.to(device=vae_param.device, dtype=torch.float32)
-    mean, std = _flux2_bn_stats(vae, latents)
-    latents = latents * std + mean
-    latents = _unpatchify_latents(latents)
-    return vae.decode(latents.to(vae_param.dtype), return_dict=False)[0].float()
-_FLOW_SCHEDULERS = {
-    "heun": FlowMatchHeunDiscreteScheduler,
-    "euler": FlowMatchEulerDiscreteScheduler,
-}
-def _new_flow_scheduler(solver: str) -> SchedulerMixin:
-    if solver not in _FLOW_SCHEDULERS:
-        raise ValueError("solver must be one of: 'heun', 'euler'.")
-    return _FLOW_SCHEDULERS[solver]()
-def _solver_from_scheduler(scheduler: SchedulerMixin | None) -> str:
-    if isinstance(scheduler, FlowMatchHeunDiscreteScheduler):
-        return "heun"
-    if isinstance(scheduler, FlowMatchEulerDiscreteScheduler):
-        return "euler"
-    return "heun"
-class JLTPipeline(DiffusionPipeline):
-    r"""
-    Pipeline for class-conditional image generation with JLT (Clean-Latent JiT).
-    Latent models (`in_channels=128`) require a FLUX.2 VAE attached for `output_type="pil"`.
-    """
-    model_cpu_offload_seq = "transformer->vae"
-    _optional_components = ["vae"]
-    def __init__(
-        self,
-        transformer,
-        scheduler,
-        vae=None,
-        id2label=None,
-        prediction_type="sample",
-        t_eps=5e-2,
-        solver="heun",
-    ):
-        super().__init__()
-        if scheduler is None or isinstance(scheduler, list):
-            scheduler = _new_flow_scheduler(solver)
-        self.register_modules(
-            transformer=transformer,
-            scheduler=scheduler,
-            vae=vae,
-        )
-        self.prediction_type = prediction_type
-        self.t_eps = t_eps
-        self.solver = solver
-        self._id2label = self._normalize_id2label(id2label)
-        self.labels = self._build_label2id(self._id2label)
-        self._labels_loaded_from_model_index = bool(self._id2label)
-    @classmethod
-    def from_pretrained(cls, pretrained_model_name_or_path=None, subfolder=None, **kwargs):
-        repo_root = Path(__file__).resolve().parent
-        if pretrained_model_name_or_path in (None, "", "."):
-            variant = repo_root
-        else:
-            variant = Path(pretrained_model_name_or_path)
-            if not variant.is_absolute():
-                candidate = (Path.cwd() / variant).resolve()
-                variant = candidate if candidate.exists() else (repo_root / variant).resolve()
-            if subfolder:
-                variant = variant / subfolder
-        model_kwargs = dict(kwargs)
-        inserted: List[str] = []
-        def _load_transformer():
-            comp_dir = variant / "transformer"
-            module_path = comp_dir / "transformer_jlt.py"
-            if not module_path.exists() or not (comp_dir / "config.json").exists():
-                return None
-            comp_path = str(comp_dir)
-            if comp_path not in sys.path:
-                sys.path.insert(0, comp_path)
-                inserted.append(comp_path)
-            module = importlib.import_module("transformer_jlt")
-            transformer_cls = getattr(module, "JLTTransformer2DModel")
-            return transformer_cls.from_pretrained(str(comp_dir), **model_kwargs)
-        def _load_scheduler():
-            scheduler_dir = variant / "scheduler"
-            config_path = scheduler_dir / "scheduler_config.json"
-            if not config_path.exists():
-                return _new_flow_scheduler("heun")
-            scheduler_entry = None
-            model_index_path = variant / "model_index.json"
-            if model_index_path.exists():
-                scheduler_entry = json.loads(model_index_path.read_text(encoding="utf-8")).get("scheduler")
-            if scheduler_entry is None:
-                class_name = json.loads(config_path.read_text(encoding="utf-8")).get("_class_name")
-                scheduler_entry = ["diffusers", class_name]
-            module_name, class_name = scheduler_entry
-            if module_name == "diffusers":
-                import diffusers.schedulers as schedulers_pkg
-                scheduler_cls = getattr(schedulers_pkg, class_name)
-                return scheduler_cls.from_pretrained(str(scheduler_dir), **model_kwargs)
-            comp_path = str(scheduler_dir)
-            if comp_path not in sys.path:
-                sys.path.insert(0, comp_path)
-                inserted.append(comp_path)
-            module = importlib.import_module(module_name)
-            scheduler_cls = getattr(module, class_name)
-            return scheduler_cls.from_pretrained(str(scheduler_dir), **model_kwargs)
-        def _load_vae():
-            vae_dir = variant / "vae"
-            if vae_dir.exists() and (vae_dir / "config.json").exists():
-                return AutoencoderKLFlux2.from_pretrained(str(vae_dir), **model_kwargs)
-            return None
-        try:
-            transformer = _load_transformer()
-            if transformer is None:
-                raise ValueError(f"No loadable transformer found under {variant}")
-            scheduler = _load_scheduler()
-            vae = _load_vae()
-            id2label = cls._read_id2label_from_model_index(str(variant))
-            solver = _solver_from_scheduler(scheduler)
-            pipe = cls(
-                transformer=transformer,
-                scheduler=scheduler,
-                vae=vae,
-                id2label=id2label or None,
-                solver=solver,
-            )
-            if hasattr(pipe, "register_to_config"):
-                pipe.register_to_config(_name_or_path=str(variant))
-            return pipe
-        finally:
-            for comp_path in inserted:
-                if comp_path in sys.path:
-                    sys.path.remove(comp_path)
-    @staticmethod
-    def _normalize_id2label(id2label: Optional[Dict[Union[int, str], str]]) -> Dict[int, str]:
-        if not id2label:
-            return {}
-        return {int(key): value for key, value in id2label.items()}
-    @staticmethod
-    def _read_id2label_from_model_index(variant_path: Optional[str]) -> Dict[int, str]:
-        if not variant_path:
-            return {}
-        model_index_path = Path(variant_path).resolve() / "model_index.json"
-        if not model_index_path.exists():
-            return {}
-        raw = json.loads(model_index_path.read_text(encoding="utf-8"))
-        id2label = raw.get("id2label")
-        if not isinstance(id2label, dict):
-            return {}
-        return {int(key): value for key, value in id2label.items()}
-    @staticmethod
-    def _build_label2id(id2label: Dict[int, str]) -> Dict[str, int]:
-        label2id: Dict[str, int] = {}
-        for class_id, value in id2label.items():
-            for synonym in value.split(","):
-                synonym = synonym.strip()
-                if synonym:
-                    label2id[synonym] = int(class_id)
-        return dict(sorted(label2id.items()))
-    def _ensure_labels_loaded(self) -> None:
-        if self._labels_loaded_from_model_index:
-            return
-        loaded = self._read_id2label_from_model_index(getattr(self.config, "_name_or_path", None))
-        if loaded:
-            self._id2label = loaded
-            self.labels = self._build_label2id(self._id2label)
-        self._labels_loaded_from_model_index = True
-    @property
-    def id2label(self) -> Dict[int, str]:
-        self._ensure_labels_loaded()
-        return self._id2label
-    def get_label_ids(self, label: Union[str, List[str]]) -> List[int]:
-        self._ensure_labels_loaded()
-        if not self.labels:
-            raise ValueError("No labels loaded. Ensure `id2label` exists in model_index.json.")
-        if isinstance(label, str):
-            label = [label]
-        missing = [item for item in label if item not in self.labels]
-        if missing:
-            preview = ", ".join(list(self.labels.keys())[:8])
-            raise ValueError(f"Unknown label(s): {missing}. Examples: {preview}, ...")
-        return [self.labels[item] for item in label]
-    def _normalize_class_labels(self, class_labels: Union[int, str, List[Union[int, str]]]) -> List[int]:
-        if isinstance(class_labels, int):
-            return [class_labels]
-        if isinstance(class_labels, str):
-            return self.get_label_ids(class_labels)
-        if class_labels and isinstance(class_labels[0], str):
-            return self.get_label_ids(class_labels)
-        return list(class_labels)
-    def _sampling_dtype(self) -> torch.dtype:
-        model_dtype = self.transformer.dtype
-        if model_dtype in (torch.bfloat16, torch.float16):
-            return torch.float32
-        return model_dtype
-    def _predict_velocity_at_t(
-        self,
-        z_value: torch.Tensor,
-        t_jlt: Union[float, torch.Tensor],
-        class_labels: torch.Tensor,
-        class_null: torch.Tensor,
-        do_classifier_free_guidance: bool,
-        guidance_scale: float,
-        guidance_interval_min: float,
-        guidance_interval_max: float,
-    ) -> torch.Tensor:
-        t_jlt = torch.as_tensor(t_jlt, device=z_value.device, dtype=z_value.dtype)
-        if t_jlt.ndim == 0:
-            t_jlt = t_jlt.reshape(1)
-        if do_classifier_free_guidance:
-            z_in = torch.cat([z_value, z_value], dim=0)
-            labels = torch.cat([class_labels, class_null], dim=0)
-        else:
-            z_in = z_value
-            labels = class_labels
-        t_batch = t_jlt.flatten().expand(z_in.shape[0])
-        model_dtype = self.transformer.dtype
-        use_autocast = model_dtype != torch.float32 and z_value.is_cuda
-        if use_autocast:
-            with torch.autocast(device_type=z_value.device.type, dtype=model_dtype):
-                model_out = self.transformer(
-                    z_in.to(model_dtype),
-                    timestep=t_batch,
-                    class_labels=labels,
-                ).sample
-        else:
-            model_out = self.transformer(z_in, timestep=t_batch, class_labels=labels).sample
-        v = velocity_from_prediction(
-            z_in,
-            model_out.to(z_value.dtype),
-            t_jlt,
-            prediction_type=self.prediction_type,
-            t_eps=self.t_eps,
-        )
-        if not do_classifier_free_guidance:
-            return v
-        v_cond, v_uncond = v.chunk(2, dim=0)
-        interval_mask = t_jlt < guidance_interval_max
-        if guidance_interval_min != 0.0:
-            interval_mask = interval_mask & (t_jlt > guidance_interval_min)
-        scale = torch.where(
-            interval_mask,
-            torch.tensor(guidance_scale, device=z_value.device, dtype=z_value.dtype),
-            torch.tensor(1.0, device=z_value.device, dtype=z_value.dtype),
-        )
-        return v_uncond + scale * (v_cond - v_uncond)
-    def _euler_step(
-        self,
-        latents: torch.Tensor,
-        t_cur: torch.Tensor,
-        t_next: torch.Tensor,
-        class_labels: torch.Tensor,
-        class_null: torch.Tensor,
-        do_classifier_free_guidance: bool,
-        guidance_scale: float,
-        guidance_interval_min: float,
-        guidance_interval_max: float,
-    ) -> torch.Tensor:
-        dt = t_next - t_cur
-        velocity = self._predict_velocity_at_t(
-            latents,
-            t_cur,
-            class_labels,
-            class_null,
-            do_classifier_free_guidance,
-            guidance_scale,
-            guidance_interval_min,
-            guidance_interval_max,
-        )
-        return latents + dt * velocity
-    def _heun_step(
-        self,
-        latents: torch.Tensor,
-        t_cur: torch.Tensor,
-        t_next: torch.Tensor,
-        class_labels: torch.Tensor,
-        class_null: torch.Tensor,
-        do_classifier_free_guidance: bool,
-        guidance_scale: float,
-        guidance_interval_min: float,
-        guidance_interval_max: float,
-    ) -> torch.Tensor:
-        dt = t_next - t_cur
-        velocity_1 = self._predict_velocity_at_t(
-            latents,
-            t_cur,
-            class_labels,
-            class_null,
-            do_classifier_free_guidance,
-            guidance_scale,
-            guidance_interval_min,
-            guidance_interval_max,
-        )
-        velocity_2 = self._predict_velocity_at_t(
-            latents + dt * velocity_1,
-            t_next,
-            class_labels,
-            class_null,
-            do_classifier_free_guidance,
-            guidance_scale,
-            guidance_interval_min,
-            guidance_interval_max,
-        )
-        return latents + dt * 0.5 * (velocity_1 + velocity_2)
-    def _run_sampler(
-        self,
-        latents: torch.Tensor,
-        class_labels: torch.Tensor,
-        class_null: torch.Tensor,
-        num_inference_steps: int,
-        do_classifier_free_guidance: bool,
-        guidance_scale: float,
-        guidance_interval_min: float,
-        guidance_interval_max: float,
-    ) -> torch.Tensor:
-        solver = self.solver
-        if solver not in _FLOW_SCHEDULERS:
-            raise ValueError("pipeline solver must be one of: 'heun', 'euler'.")
-        device = latents.device
-        dtype = self._sampling_dtype()
-        latents = latents.to(dtype=dtype)
-        ts = torch.linspace(0.0, 1.0, num_inference_steps + 1, device=device, dtype=dtype)
-        step_kwargs = (
-            class_labels,
-            class_null,
-            do_classifier_free_guidance,
-            guidance_scale,
-            guidance_interval_min,
-            guidance_interval_max,
-        )
-        if solver == "heun":
-            for step_idx in self.progress_bar(range(num_inference_steps - 1)):
-                latents = self._heun_step(latents, ts[step_idx], ts[step_idx + 1], *step_kwargs)
-            latents = self._euler_step(latents, ts[-2], ts[-1], *step_kwargs)
-            return latents
-        for step_idx in self.progress_bar(range(num_inference_steps)):
-            latents = self._euler_step(latents, ts[step_idx], ts[step_idx + 1], *step_kwargs)
-        return latents
-    @torch.inference_mode()
-    def __call__(
-        self,
-        class_labels: Union[int, str, List[Union[int, str]]],
-        guidance_scale: Optional[float] = None,
-        guidance_interval_min: float = 0.1,
-        guidance_interval_max: float = 1.0,
-        noise_scale: float = 1.0,
-        t_eps: Optional[float] = None,
-        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
-        num_inference_steps: int = 50,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-    ) -> Union[ImagePipelineOutput, Tuple]:
-        if num_inference_steps < 2:
-            raise ValueError("num_inference_steps must be >= 2.")
-        if output_type not in {"pil", "np", "pt", "latent"}:
-            raise ValueError("output_type must be one of: 'pil', 'np', 'pt', 'latent'.")
-        if t_eps is not None:
-            self.t_eps = t_eps
-        class_label_ids = self._normalize_class_labels(class_labels)
-        do_classifier_free_guidance = guidance_scale is not None and guidance_scale > 1.0
-        batch_size = len(class_label_ids)
-        latent_size = int(self.transformer.config.sample_size)
-        channels = int(self.transformer.config.in_channels)
-        null_class_val = int(
-            getattr(self.transformer.config, "num_classes", getattr(self.transformer.config, "num_class_embeds", 1000))
-        )
-        if guidance_scale is None:
-            guidance_scale = 1.0
-        latents = randn_tensor(
-            shape=(batch_size, channels, latent_size, latent_size),
-            generator=generator,
-            device=self._execution_device,
-            dtype=self._sampling_dtype(),
-        ) * noise_scale
-        class_labels_t = torch.tensor(class_label_ids, device=self._execution_device, dtype=torch.long).reshape(-1)
-        class_labels_t = class_labels_t.clamp(0, null_class_val - 1)
-        class_null = torch.full_like(class_labels_t, null_class_val)
-        latents = self._run_sampler(
-            latents,
-            class_labels_t,
-            class_null,
-            num_inference_steps,
-            do_classifier_free_guidance,
-            guidance_scale,
-            guidance_interval_min,
-            guidance_interval_max,
-        )
-        if output_type == "latent":
-            if not return_dict:
-                return (latents,)
-            return ImagePipelineOutput(images=latents)
-        if self.vae is not None:
-            images_pt = decode_flux2_latents(self.vae, latents)
-        else:
-            images_pt = latents
-        if not torch.isfinite(images_pt).all():
-            raise RuntimeError(
-                "JLT generation produced non-finite values before image conversion. "
-                "Restart the notebook kernel and re-run the pipeline load cell."
-            )
-        images_pt = ((images_pt.float().clamp(-1, 1) + 1.0) / 2.0).cpu()
-        if output_type == "pt":
-            images = images_pt
-        elif output_type == "np":
-            images = images_pt.permute(0, 2, 3, 1).numpy()
-        else:
-            images = self.numpy_to_pil(images_pt.permute(0, 2, 3, 1).numpy())
-        self.maybe_free_model_hooks()
-        if not return_dict:
-            return (images,)
-        return ImagePipelineOutput(images=images)

JLT-H-1-256/scheduler/scheduler_config.json DELETED Viewed

@@ -1,6 +0,0 @@
-{
-  "_class_name": "FlowMatchHeunDiscreteScheduler",
-  "_diffusers_version": "0.38.0",
-  "num_train_timesteps": 1000,
-  "shift": 4.0
-}

JLT-H-1-256/transformer/__pycache__/transformer_jlt.cpython-312.pyc DELETED Viewed

Binary file (38.5 kB)

JLT-H-1-256/transformer/config.json DELETED Viewed

@@ -1,21 +0,0 @@
-{
-  "_class_name": "JLTTransformer2DModel",
-  "_diffusers_version": "0.38.0",
-  "attention_dropout": 0.0,
-  "dropout": 0.0,
-  "hidden_size": 1280,
-  "in_channels": 128,
-  "loop_count": 0,
-  "loop_indices": null,
-  "mask_prob": 0.0,
-  "mask_ratio": 0.0,
-  "mlp_ratio": 4.0,
-  "model_type": "JiT-H/1",
-  "norm_eps": 1e-06,
-  "num_attention_heads": 20,
-  "num_class_embeds": null,
-  "num_classes": 1000,
-  "num_layers": 32,
-  "patch_size": 1,
-  "sample_size": 16
-}

JLT-H-1-256/transformer/diffusion_pytorch_model.safetensors DELETED Viewed

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:dd1463bd2ac82d085c2c951be3e1a95bd44d8a8439588b541d3f244a4cd036ea
-size 3805219168

JLT-H-1-256/transformer/transformer_jlt.py DELETED Viewed

@@ -1,648 +0,0 @@
-"""JLT (Clean-Latent) Transformer for diffusers."""
-from __future__ import annotations
-import argparse
-import math
-from collections.abc import Mapping
-from typing import Dict, List, Optional, Tuple
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from diffusers.configuration_utils import ConfigMixin, register_to_config
-from diffusers.models.modeling_outputs import Transformer2DModelOutput
-from diffusers.models.modeling_utils import ModelMixin
-from diffusers.models.normalization import RMSNorm
-from einops import rearrange, repeat
-try:
-    from flash_attn.cute import flash_attn_func as _flash_attn_func
-    _HAS_FLASH_ATTN = True
-except ImportError:
-    _HAS_FLASH_ATTN = False
-JLT_PRESET_CONFIGS: Dict[str, Dict[str, object]] = {
-    "JiT-B/1": {
-        "sample_size": 16,
-        "patch_size": 1,
-        "hidden_size": 768,
-        "num_layers": 12,
-        "num_attention_heads": 12,
-        "attention_dropout": 0.0,
-        "dropout": 0.0,
-    },
-    "JiT-B/2": {
-        "sample_size": 16,
-        "patch_size": 2,
-        "hidden_size": 768,
-        "num_layers": 12,
-        "num_attention_heads": 12,
-        "attention_dropout": 0.0,
-        "dropout": 0.0,
-    },
-    "JiT-B/16": {
-        "sample_size": 256,
-        "patch_size": 16,
-        "hidden_size": 768,
-        "num_layers": 12,
-        "num_attention_heads": 12,
-        "attention_dropout": 0.0,
-        "dropout": 0.0,
-    },
-    "JiT-B/32": {
-        "sample_size": 512,
-        "patch_size": 32,
-        "hidden_size": 768,
-        "num_layers": 12,
-        "num_attention_heads": 12,
-        "attention_dropout": 0.0,
-        "dropout": 0.0,
-    },
-    "JiT-L/16": {
-        "sample_size": 256,
-        "patch_size": 16,
-        "hidden_size": 1024,
-        "num_layers": 24,
-        "num_attention_heads": 16,
-        "attention_dropout": 0.0,
-        "dropout": 0.0,
-    },
-    "JiT-L/32": {
-        "sample_size": 512,
-        "patch_size": 32,
-        "hidden_size": 1024,
-        "num_layers": 24,
-        "num_attention_heads": 16,
-        "attention_dropout": 0.0,
-        "dropout": 0.0,
-    },
-    "JiT-H/1": {
-        "sample_size": 16,
-        "patch_size": 1,
-        "hidden_size": 1280,
-        "num_layers": 32,
-        "num_attention_heads": 20,
-        "attention_dropout": 0.0,
-        "dropout": 0.2,
-    },
-    "JiT-H/16": {
-        "sample_size": 256,
-        "patch_size": 16,
-        "hidden_size": 1280,
-        "num_layers": 32,
-        "num_attention_heads": 16,
-        "attention_dropout": 0.0,
-        "dropout": 0.2,
-    },
-    "JiT-H/32": {
-        "sample_size": 512,
-        "patch_size": 32,
-        "hidden_size": 1280,
-        "num_layers": 32,
-        "num_attention_heads": 16,
-        "attention_dropout": 0.0,
-        "dropout": 0.2,
-    },
-}
-def remap_legacy_state_dict(state_dict: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]:
-    """Map legacy JLT/Denoiser checkpoint keys to native transformer keys."""
-    remapped: Dict[str, torch.Tensor] = {}
-    for key, value in state_dict.items():
-        new_key = key
-        for prefix in ("transformer.", "net."):
-            if new_key.startswith(prefix):
-                new_key = new_key[len(prefix) :]
-                break
-        if new_key.startswith("final_layer."):
-            new_key = new_key.replace("final_layer.norm_final", "norm_final")
-            new_key = new_key.replace("final_layer.linear", "linear_final")
-            new_key = new_key.replace("final_layer.adaLN_modulation", "adaLN_modulation_final")
-        remapped[new_key] = value
-    return remapped
-def config_from_legacy(config: Dict[str, object]) -> Dict[str, object]:
-    model_type = config.get("model_type") or config.get("model") or config.get("model_name")
-    if model_type not in JLT_PRESET_CONFIGS:
-        raise ValueError(f"Unknown JLT preset '{model_type}'. Known: {list(JLT_PRESET_CONFIGS)}")
-    preset = dict(JLT_PRESET_CONFIGS[model_type])
-    preset["num_classes"] = int(config.get("num_class_embeds") or config.get("num_classes") or config.get("class_num") or 1000)
-    if config.get("attn_dropout") is not None:
-        preset["attention_dropout"] = float(config["attn_dropout"])
-    if config.get("proj_dropout") is not None:
-        preset["dropout"] = float(config["proj_dropout"])
-    if config.get("sample_size") is not None:
-        preset["sample_size"] = int(config["sample_size"])
-    if config.get("img_size") is not None and config.get("patch_size") is not None:
-        preset["sample_size"] = int(config["img_size"]) // int(config.get("spatial_compression", 16))
-    preset["model_type"] = model_type
-    return preset
-def broadcat(tensors, dim=-1):
-    num_tensors = len(tensors)
-    shape_lens = {len(t.shape) for t in tensors}
-    if len(shape_lens) != 1:
-        raise ValueError("tensors must all have the same number of dimensions")
-    shape_len = list(shape_lens)[0]
-    dim = (dim + shape_len) if dim < 0 else dim
-    dims = list(zip(*(list(t.shape) for t in tensors)))
-    expandable_dims = [(i, val) for i, val in enumerate(dims) if i != dim]
-    if not all(len(set(t[1])) <= 2 for t in expandable_dims):
-        raise ValueError("invalid dimensions for broadcastable concatenation")
-    max_dims = [(t[0], max(t[1])) for t in expandable_dims]
-    expanded_dims = [(t[0], (t[1],) * num_tensors) for t in max_dims]
-    expanded_dims.insert(dim, (dim, dims[dim]))
-    expandable_shapes = list(zip(*(t[1] for t in expanded_dims)))
-    tensors = [t[0].expand(*t[1]) for t in zip(tensors, expandable_shapes)]
-    return torch.cat(tensors, dim=dim)
-def rotate_half(x):
-    x = rearrange(x, "... (d r) -> ... d r", r=2)
-    x1, x2 = x.unbind(dim=-1)
-    x = torch.stack((-x2, x1), dim=-1)
-    return rearrange(x, "... d r -> ... (d r)")
-class JLTRotaryEmbedding(nn.Module):
-    def __init__(self, dim, pt_seq_len=16, ft_seq_len=None, theta=10000, num_cls_token=0):
-        super().__init__()
-        freqs = 1.0 / (theta ** (torch.arange(0, dim, 2)[: (dim // 2)].float() / dim))
-        if ft_seq_len is None:
-            ft_seq_len = pt_seq_len
-        t = torch.arange(ft_seq_len) / ft_seq_len * pt_seq_len
-        freqs = torch.einsum("..., f -> ... f", t, freqs)
-        freqs = repeat(freqs, "... n -> ... (n r)", r=2)
-        freqs = broadcat((freqs[:, None, :], freqs[None, :, :]), dim=-1)
-        if num_cls_token > 0:
-            freqs_flat = freqs.view(-1, freqs.shape[-1])
-            cos_img = freqs_flat.cos()
-            sin_img = freqs_flat.sin()
-            _, dim_freq = cos_img.shape
-            cos_pad = torch.ones(num_cls_token, dim_freq, dtype=cos_img.dtype)
-            sin_pad = torch.zeros(num_cls_token, dim_freq, dtype=sin_img.dtype)
-            self.register_buffer("freqs_cos", torch.cat([cos_pad, cos_img], dim=0), persistent=False)
-            self.register_buffer("freqs_sin", torch.cat([sin_pad, sin_img], dim=0), persistent=False)
-        else:
-            self.register_buffer("freqs_cos", freqs.cos().view(-1, freqs.shape[-1]), persistent=False)
-            self.register_buffer("freqs_sin", freqs.sin().view(-1, freqs.shape[-1]), persistent=False)
-    def forward(self, tensor):
-        seq_len = tensor.shape[1] if tensor.ndim == 4 else tensor.shape[-2]
-        fc = self.freqs_cos[:seq_len].to(device=tensor.device, dtype=tensor.dtype)
-        fs = self.freqs_sin[:seq_len].to(device=tensor.device, dtype=tensor.dtype)
-        if tensor.ndim == 4:
-            return tensor * fc[:, None, :] + rotate_half(tensor) * fs[:, None, :]
-        return tensor * fc + rotate_half(tensor) * fs
-def modulate(x, shift, scale):
-    if shift.ndim == x.ndim - 1:
-        shift = shift.unsqueeze(1)
-        scale = scale.unsqueeze(1)
-    return x * (1 + scale) + shift
-class JLTPatchEmbed(nn.Module):
-    def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768, bias=True):
-        super().__init__()
-        img_size = (img_size, img_size)
-        patch_size = (patch_size, patch_size)
-        self.img_size = img_size
-        self.patch_size = patch_size
-        self.num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0])
-        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size, bias=bias)
-    def forward(self, x):
-        batch, _, height, width = x.shape
-        if height != self.img_size[0] or width != self.img_size[1]:
-            raise ValueError(
-                f"Input image size ({height}*{width}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})."
-            )
-        return self.proj(x).flatten(2).transpose(1, 2)
-class JLTTimestepEmbedder(nn.Module):
-    def __init__(self, hidden_size, frequency_embedding_size=256):
-        super().__init__()
-        self.mlp = nn.Sequential(
-            nn.Linear(frequency_embedding_size, hidden_size, bias=True),
-            nn.SiLU(),
-            nn.Linear(hidden_size, hidden_size, bias=True),
-        )
-        self.frequency_embedding_size = frequency_embedding_size
-    @staticmethod
-    def timestep_embedding(t, dim, max_period=10000):
-        half = dim // 2
-        freqs = torch.exp(
-            -math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32, device=t.device) / half
-        )
-        args = t.float().unsqueeze(-1) * freqs
-        embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
-        if dim % 2:
-            embedding = torch.cat([embedding, torch.zeros_like(embedding[..., :1])], dim=-1)
-        return embedding.to(t.dtype)
-    def forward(self, t, dtype=None):
-        t_freq = self.timestep_embedding(t, self.frequency_embedding_size)
-        if dtype is not None:
-            t_freq = t_freq.to(dtype=dtype)
-        return self.mlp(t_freq)
-class JLTLabelEmbedder(nn.Module):
-    def __init__(self, num_classes, hidden_size):
-        super().__init__()
-        self.embedding_table = nn.Embedding(num_classes + 1, hidden_size)
-        self.num_classes = num_classes
-    def forward(self, labels):
-        return self.embedding_table(labels)
-class JLTAttention(nn.Module):
-    def __init__(self, dim, num_heads=8, qkv_bias=True, qk_norm=True, attn_drop=0.0, proj_drop=0.0, eps=1e-6):
-        super().__init__()
-        self.num_heads = num_heads
-        head_dim = dim // num_heads
-        self.q_norm = RMSNorm(head_dim, eps=eps) if qk_norm else nn.Identity()
-        self.k_norm = RMSNorm(head_dim, eps=eps) if qk_norm else nn.Identity()
-        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
-        self.attn_drop = attn_drop
-        self.proj = nn.Linear(dim, dim)
-        self.proj_drop = nn.Dropout(proj_drop)
-    def forward(self, x, rope=None):
-        batch, num_tokens, channels = x.shape
-        qkv = self.qkv(x).reshape(batch, num_tokens, 3, self.num_heads, channels // self.num_heads).permute(2, 0, 3, 1, 4)
-        q, k, v = qkv[0], qkv[1], qkv[2]
-        q = self.q_norm(q)
-        k = self.k_norm(k)
-        if rope is not None:
-            q = q.transpose(1, 2)
-            k = k.transpose(1, 2)
-            q = rope(q)
-            k = rope(k)
-            q = q.transpose(1, 2)
-            k = k.transpose(1, 2)
-        if _HAS_FLASH_ATTN:
-            attn_dtype = q.dtype if q.dtype in (torch.float16, torch.bfloat16) else torch.bfloat16
-            q = q.transpose(1, 2).contiguous().to(attn_dtype)
-            k = k.transpose(1, 2).contiguous().to(attn_dtype)
-            v = v.transpose(1, 2).contiguous().to(attn_dtype)
-            x, _ = _flash_attn_func(q, k, v, causal=False)
-            x = x.reshape(batch, num_tokens, channels)
-        else:
-            dropout_p = self.attn_drop if self.training else 0.0
-            x = F.scaled_dot_product_attention(q, k, v, dropout_p=dropout_p)
-            x = x.transpose(1, 2).reshape(batch, num_tokens, channels)
-        x = self.proj(x)
-        return self.proj_drop(x)
-class JLTSwiGLUFFN(nn.Module):
-    def __init__(self, dim: int, hidden_dim: int, drop=0.0, bias=True) -> None:
-        super().__init__()
-        hidden_dim = int(hidden_dim * 2 / 3)
-        self.w12 = nn.Linear(dim, 2 * hidden_dim, bias=bias)
-        self.w3 = nn.Linear(hidden_dim, dim, bias=bias)
-        self.ffn_dropout = nn.Dropout(drop)
-    def forward(self, x):
-        x12 = self.w12(x)
-        x1, x2 = x12.chunk(2, dim=-1)
-        return self.w3(self.ffn_dropout(F.silu(x1) * x2))
-class JLTBlock(nn.Module):
-    def __init__(self, hidden_size, num_heads, mlp_ratio=4.0, attn_drop=0.0, proj_drop=0.0, eps=1e-6):
-        super().__init__()
-        self.norm1 = RMSNorm(hidden_size, eps=eps)
-        self.attn = JLTAttention(
-            hidden_size,
-            num_heads=num_heads,
-            qkv_bias=True,
-            qk_norm=True,
-            attn_drop=attn_drop,
-            proj_drop=proj_drop,
-            eps=eps,
-        )
-        self.norm2 = RMSNorm(hidden_size, eps=eps)
-        self.mlp = JLTSwiGLUFFN(hidden_size, int(hidden_size * mlp_ratio), drop=proj_drop)
-        self.adaLN_modulation = nn.Sequential(
-            nn.SiLU(),
-            nn.Linear(hidden_size, 6 * hidden_size, bias=True),
-        )
-    def forward(self, x, c, feat_rope=None):
-        shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.adaLN_modulation(c).chunk(6, dim=-1)
-        if gate_msa.ndim == x.ndim - 1:
-            gate_msa = gate_msa.unsqueeze(1)
-            gate_mlp = gate_mlp.unsqueeze(1)
-        x = x + gate_msa * self.attn(modulate(self.norm1(x), shift_msa, scale_msa), rope=feat_rope)
-        x = x + gate_mlp * self.mlp(modulate(self.norm2(x), shift_mlp, scale_mlp))
-        return x
-class JLTTransformer2DModel(ModelMixin, ConfigMixin):
-    _supports_gradient_checkpointing = True
-    @register_to_config
-    def __init__(
-        self,
-        sample_size: int = 16,
-        patch_size: int = 1,
-        in_channels: int = 128,
-        hidden_size: int = 768,
-        num_layers: int = 12,
-        num_attention_heads: int = 12,
-        mlp_ratio: float = 4.0,
-        attention_dropout: float = 0.0,
-        dropout: float = 0.0,
-        num_classes: int = 1000,
-        norm_eps: float = 1e-6,
-        model_type: str | None = None,
-        num_class_embeds: int | None = None,
-        mask_prob: float = 0.0,
-        mask_ratio: float = 0.0,
-        loop_indices: Optional[List[int]] = None,
-        loop_count: int = 0,
-    ):
-        super().__init__()
-        if num_class_embeds is not None:
-            num_classes = int(num_class_embeds)
-        if model_type in JLT_PRESET_CONFIGS:
-            preset = JLT_PRESET_CONFIGS[model_type]
-            sample_size = int(preset["sample_size"])
-            patch_size = int(preset["patch_size"])
-            hidden_size = int(preset["hidden_size"])
-            num_layers = int(preset["num_layers"])
-            num_attention_heads = int(preset["num_attention_heads"])
-            if attention_dropout == 0.0:
-                attention_dropout = float(preset["attention_dropout"])
-            if dropout == 0.0:
-                dropout = float(preset["dropout"])
-        self.sample_size = sample_size
-        self.patch_size = patch_size
-        self.in_channels = in_channels
-        self.out_channels = in_channels
-        self.hidden_size = hidden_size
-        self.num_layers = num_layers
-        self.num_attention_heads = num_attention_heads
-        self.mask_prob = float(mask_prob)
-        self.mask_ratio = float(mask_ratio)
-        self.loop_count = int(loop_count)
-        self.gradient_checkpointing = False
-        self.mask_token = nn.Parameter(torch.zeros(1, 1, hidden_size))
-        nn.init.normal_(self.mask_token, std=0.02)
-        self.loop_indices: Optional[Tuple[int, ...]] = None
-        if loop_indices and self.loop_count > 0:
-            sorted_idx = sorted(int(x) for x in loop_indices)
-            if len(set(sorted_idx)) != len(sorted_idx):
-                raise ValueError(f"loop_indices must be unique, got {loop_indices}.")
-            for i in range(1, len(sorted_idx)):
-                if sorted_idx[i] != sorted_idx[i - 1] + 1:
-                    raise ValueError(f"loop_indices must be consecutive integers, got {sorted_idx}.")
-            if sorted_idx[0] < 0 or sorted_idx[-1] >= num_layers:
-                raise ValueError(f"loop_indices must lie in [0, {num_layers}), got {sorted_idx}.")
-            self.loop_indices = tuple(sorted_idx)
-        self.t_embedder = JLTTimestepEmbedder(hidden_size)
-        self.y_embedder = JLTLabelEmbedder(num_classes, hidden_size)
-        self.x_embedder = JLTPatchEmbed(sample_size, patch_size, in_channels, hidden_size, bias=True)
-        half_head_dim = hidden_size // num_attention_heads // 2
-        hw_seq_len = sample_size // patch_size
-        self.feat_rope = JLTRotaryEmbedding(dim=half_head_dim, pt_seq_len=hw_seq_len, num_cls_token=0)
-        self.blocks = nn.ModuleList(
-            [
-                JLTBlock(
-                    hidden_size,
-                    num_attention_heads,
-                    mlp_ratio=mlp_ratio,
-                    attn_drop=attention_dropout if (num_layers // 4 * 3 > i >= num_layers // 4) else 0.0,
-                    proj_drop=dropout if (num_layers // 4 * 3 > i >= num_layers // 4) else 0.0,
-                    eps=norm_eps,
-                )
-                for i in range(num_layers)
-            ]
-        )
-        self.norm_final = RMSNorm(hidden_size, eps=norm_eps)
-        self.linear_final = nn.Linear(hidden_size, patch_size * patch_size * self.out_channels, bias=True)
-        self.adaLN_modulation_final = nn.Sequential(
-            nn.SiLU(),
-            nn.Linear(hidden_size, 2 * hidden_size, bias=True),
-        )
-        self.initialize_weights()
-    def initialize_weights(self):
-        def _basic_init(module):
-            if isinstance(module, nn.Linear):
-                torch.nn.init.xavier_uniform_(module.weight)
-                if module.bias is not None:
-                    nn.init.constant_(module.bias, 0)
-        self.apply(_basic_init)
-        w = self.x_embedder.proj.weight.data
-        nn.init.xavier_uniform_(w.view([w.shape[0], -1]))
-        nn.init.constant_(self.x_embedder.proj.bias, 0)
-        nn.init.normal_(self.y_embedder.embedding_table.weight, std=0.02)
-        nn.init.normal_(self.t_embedder.mlp[0].weight, std=0.02)
-        nn.init.normal_(self.t_embedder.mlp[2].weight, std=0.02)
-        for block in self.blocks:
-            nn.init.constant_(block.adaLN_modulation[-1].weight, 0)
-            nn.init.constant_(block.adaLN_modulation[-1].bias, 0)
-        nn.init.constant_(self.adaLN_modulation_final[-1].weight, 0)
-        nn.init.constant_(self.adaLN_modulation_final[-1].bias, 0)
-        nn.init.constant_(self.linear_final.weight, 0)
-        nn.init.constant_(self.linear_final.bias, 0)
-    def _block_schedule(self) -> List[int]:
-        if self.loop_indices is not None and self.loop_count > 0:
-            a, b = self.loop_indices[0], self.loop_indices[-1]
-            return list(range(0, a)) + list(range(a, b + 1)) * self.loop_count + list(range(b + 1, len(self.blocks)))
-        return list(range(len(self.blocks)))
-    def forward(
-        self,
-        sample: torch.Tensor,
-        timestep: torch.Tensor,
-        class_labels: torch.Tensor,
-        return_dict: bool = True,
-        return_features: bool = False,
-        feature_layers: Optional[List[int]] = None,
-    ):
-        t = torch.as_tensor(timestep, device=sample.device)
-        if t.ndim == 0:
-            t = t.repeat(sample.shape[0])
-        elif t.ndim == 1 and t.shape[0] == 1 and sample.shape[0] > 1:
-            t = t.repeat(sample.shape[0])
-        t_emb = self.t_embedder(t, dtype=sample.dtype)
-        y_emb = self.y_embedder(class_labels).to(dtype=sample.dtype)
-        if t_emb.ndim == 3:
-            y_emb = y_emb.unsqueeze(1)
-        c = t_emb + y_emb
-        x = self.x_embedder(sample)
-        if self.training and self.mask_prob > 0.0 and self.mask_ratio > 0.0:
-            batch, num_tokens, _ = x.shape
-            s_mask = torch.rand(batch, device=x.device) < self.mask_prob
-            t_mask = torch.rand(batch, num_tokens, device=x.device) < self.mask_ratio
-            mask = (s_mask.unsqueeze(1) & t_mask).unsqueeze(-1)
-            x = torch.where(mask, self.mask_token.to(x.dtype), x)
-        target_layers = set(feature_layers or [])
-        features = {} if return_features else None
-        for layer_idx in self._block_schedule():
-            if self.training and self.gradient_checkpointing:
-                x = torch.utils.checkpoint.checkpoint(
-                    self.blocks[layer_idx], x, c, self.feat_rope, use_reentrant=False
-                )
-            else:
-                x = self.blocks[layer_idx](x, c, self.feat_rope)
-            if return_features and layer_idx in target_layers:
-                features[layer_idx] = x
-        shift, scale = self.adaLN_modulation_final(c).chunk(2, dim=-1)
-        x = modulate(self.norm_final(x), shift, scale)
-        x = self.linear_final(x)
-        height = width = int(x.shape[1] ** 0.5)
-        x = x.reshape(x.shape[0], height, width, self.patch_size, self.patch_size, self.out_channels)
-        x = torch.einsum("nhwpqc->nchpwq", x)
-        output = x.reshape(x.shape[0], self.out_channels, height * self.patch_size, width * self.patch_size)
-        if return_features:
-            if not return_dict:
-                return (output, features)
-            return Transformer2DModelOutput(sample=output), features
-        if not return_dict:
-            return (output,)
-        return Transformer2DModelOutput(sample=output)
-    @classmethod
-    def from_jlt_checkpoint(
-        cls,
-        checkpoint_path: str,
-        weights: str = "ema1",
-        map_location: str = "cpu",
-        strict: bool = True,
-        in_channels: int | None = None,
-    ) -> Tuple["JLTTransformer2DModel", Dict[str, object]]:
-        checkpoint = torch.load(checkpoint_path, map_location=map_location, weights_only=False)
-        if "args" not in checkpoint:
-            raise ValueError("Checkpoint is missing 'args', cannot infer JLT architecture config.")
-        ckpt_args = checkpoint["args"]
-        if isinstance(ckpt_args, argparse.Namespace):
-            args_dict = vars(ckpt_args)
-        elif isinstance(ckpt_args, Mapping):
-            args_dict = dict(ckpt_args)
-        else:
-            raise TypeError(f"Unsupported checkpoint args type: {type(ckpt_args)}")
-        model_type = args_dict.get("model") or args_dict.get("model_name") or args_dict.get("model_type")
-        if model_type not in JLT_PRESET_CONFIGS:
-            raise ValueError(f"Unknown JLT preset '{model_type}'.")
-        config = dict(JLT_PRESET_CONFIGS[model_type])
-        config["num_classes"] = int(args_dict.get("class_num") or args_dict.get("num_classes") or 1000)
-        config["model_type"] = model_type
-        config["attention_dropout"] = float(
-            args_dict.get("attn_dropout", args_dict.get("attention_dropout", config["attention_dropout"]))
-        )
-        config["dropout"] = float(args_dict.get("proj_dropout", args_dict.get("dropout", config["dropout"])))
-        if in_channels is not None:
-            config["in_channels"] = in_channels
-        elif args_dict.get("vae_type") == "flux2":
-            config["in_channels"] = 128
-        if args_dict.get("img_size") and args_dict.get("vae_type") == "flux2":
-            spatial_compression = 16
-            config["sample_size"] = int(args_dict["img_size"]) // spatial_compression
-        mask_prob = float(args_dict.get("mask_prob", 0.0) or 0.0)
-        if mask_prob > 0.0:
-            config["mask_prob"] = mask_prob
-            config["mask_ratio"] = float(args_dict.get("mask_ratio", 0.0) or 0.0)
-        loop_count = int(args_dict.get("loop_count", 0) or 0)
-        if loop_count > 0:
-            loop_indices_raw = str(args_dict.get("loop_indices", "") or "")
-            loop_indices = [int(x) for x in loop_indices_raw.split(",") if x.strip()]
-            if loop_indices:
-                config["loop_indices"] = loop_indices
-                config["loop_count"] = loop_count
-        model = cls(**config)
-        if weights == "model":
-            key = "model"
-        else:
-            key = f"model_{weights}" if weights in {"ema1", "ema2"} else "model"
-        if key not in checkpoint:
-            raise ValueError(f"Checkpoint key '{key}' not found. Available keys: {list(checkpoint.keys())}")
-        state_dict = remap_legacy_state_dict(checkpoint[key])
-        model.load_state_dict(state_dict, strict=strict)
-        metadata = {
-            "checkpoint_path": checkpoint_path,
-            "weights": weights,
-            "epoch": checkpoint.get("epoch"),
-            "model_type": model_type,
-            "source_args": checkpoint.get("args"),
-        }
-        return model, metadata
-    def to_jlt_checkpoint(
-        self,
-        ema_mode: str = "copy_to_both",
-        prefix: str = "net.",
-    ) -> Dict[str, object]:
-        base_state: Dict[str, torch.Tensor] = {}
-        for key, value in self.state_dict().items():
-            legacy_key = key
-            if legacy_key.startswith("norm_final"):
-                legacy_key = legacy_key.replace("norm_final", "final_layer.norm_final", 1)
-            if legacy_key.startswith("linear_final"):
-                legacy_key = legacy_key.replace("linear_final", "final_layer.linear", 1)
-            if legacy_key.startswith("adaLN_modulation_final"):
-                legacy_key = legacy_key.replace("adaLN_modulation_final", "final_layer.adaLN_modulation", 1)
-            legacy_key = legacy_key.replace(".adaLN_modulation.", ".adaLN_modulation.1.")
-            base_state[f"{prefix}{legacy_key}"] = value.detach().cpu()
-        checkpoint = {"model": base_state}
-        if ema_mode == "copy_to_both":
-            checkpoint["model_ema1"] = {k: v.clone() for k, v in base_state.items()}
-            checkpoint["model_ema2"] = {k: v.clone() for k, v in base_state.items()}
-        elif ema_mode != "none":
-            raise ValueError(f"Unsupported ema_mode='{ema_mode}'.")
-        return checkpoint

JLT-H-1-256/vae/config.json DELETED Viewed

@@ -1,40 +0,0 @@
-{
-  "_class_name": "AutoencoderKLFlux2",
-  "_diffusers_version": "0.37.0.dev0",
-  "_name_or_path": "black-forest-labs/FLUX.2-dev",
-  "act_fn": "silu",
-  "batch_norm_eps": 0.0001,
-  "batch_norm_momentum": 0.1,
-  "block_out_channels": [
-    128,
-    256,
-    512,
-    512
-  ],
-  "down_block_types": [
-    "DownEncoderBlock2D",
-    "DownEncoderBlock2D",
-    "DownEncoderBlock2D",
-    "DownEncoderBlock2D"
-  ],
-  "force_upcast": true,
-  "in_channels": 3,
-  "latent_channels": 32,
-  "layers_per_block": 2,
-  "mid_block_add_attention": true,
-  "norm_num_groups": 32,
-  "out_channels": 3,
-  "patch_size": [
-    2,
-    2
-  ],
-  "sample_size": 1024,
-  "up_block_types": [
-    "UpDecoderBlock2D",
-    "UpDecoderBlock2D",
-    "UpDecoderBlock2D",
-    "UpDecoderBlock2D"
-  ],
-  "use_post_quant_conv": true,
-  "use_quant_conv": true
-}

JLT-H-1-256/vae/diffusion_pytorch_model.safetensors DELETED Viewed

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ca70d2202afe6415bdbcb8793ba8cd99fd159cfe6192381504d6c4d3036e0f04
-size 168120878