Add files using upload-large-folder tool

Helios/_DEV/example/prompt.txt

@@ -0,0 +1,11 @@
+A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement.
+An extreme close-up of an gray-haired man with a beard in his 60s, he is deep in thought pondering the history of the universe as he sits at a cafe in Paris, his eyes focus on people offscreen as they walk as he sits mostly motionless, he is dressed in a wool coat suit coat with a button-down shirt , he wears a brown beret and glasses and has a very professorial appearance, and the end he offers a subtle closed-mouth smile as if he found the answer to the mystery of life, the lighting is very cinematic with the golden light and the Parisian streets and city in the background, depth of field, cinematic 35mm film.
+A handheld tracking shot following a red balloon floating above the ground in an abandoned street. The balloon drifts gracefully, its bright red color contrasting sharply against the decaying urban backdrop. The street is littered with debris and graffiti-covered walls, with broken windows and rusted cars scattered about. Shadows dance across the scene as sunlight filters through gaps in the buildings. The camera moves fluidly, capturing the balloon's gentle ascent and descent, emphasizing its playful motion. A close-up of the balloon transitions to a wider shot, showcasing the desolate environment.
+The camera follows behind a white vintage SUV with a black roof rack as it speeds up a steep dirt road surrounded by pine trees on a steep mountain slope, dust kicks up from it's tires, the sunlight shines on the SUV as it speeds along the dirt road, casting a warm glow over the scene. The dirt road curves gently into the distance, with no other cars or vehicles in sight. The trees on either side of the road are redwoods, with patches of greenery scattered throughout. The car is seen from the rear following the curve with ease, making it seem as if it is on a rugged drive through the rugged terrain. The dirt road itself is surrounded by steep hills and mountains, with a clear blue sky above with wispy clouds.
+A drone camera circles around a beautiful historic church built on a rocky outcropping along the Amalfi Coast, the view showcases historic and magnificent architectural details and tiered pathways and patios, waves are seen crashing against the rocks below as the view overlooks the horizon of the coastal waters and hilly landscapes of the Amalfi Coast Italy, several distant people are seen walking and enjoying vistas on patios of the dramatic ocean views, the warm glow of the afternoon sun creates a magical and romantic feeling to the scene, the view is stunning captured with beautiful photography.
+A large orange octopus is seen resting on the bottom of the ocean floor, blending in with the sandy and rocky terrain. Its tentacles are spread out around its body, and its eyes are closed. The octopus is unaware of a king crab that is crawling towards it from behind a rock, its claws raised and ready to attack. The crab is brown and spiny, with long legs and antennae. The scene is captured from a wide angle, showing the vastness and depth of the ocean. The water is clear and blue, with rays of sunlight filtering through. The shot is sharp and crisp, with a high dynamic range. The octopus and the crab are in focus, while the background is slightly blurred, creating a depth of field effect.
+A vibrant tropical fish glides gracefully through colorful ocean reefs, surrounded by swaying coral, shimmering schools of tiny fish, and beams of sunlight filtering down from the water’s surface. The scene feels alive with movement, as bubbles rise gently and the reef glows in vivid shades of blue, orange, and pink, creating a tranquil yet dynamic underwater atmosphere.
+Cinematic closeup and detailed portrait of a reindeer in a snowy forest at sunset. The lighting is cinematic and gorgeous and soft and sun-kissed, with golden backlight and dreamy bokeh and lens flares. The color grade is cinematic and magical.
+3D animation of a small, round, fluffy creature with big, expressive eyes explores a vibrant, enchanted forest. The creature, a whimsical blend of a rabbit and a squirrel, has soft blue fur and a bushy, striped tail. It hops along a sparkling stream, its eyes wide with wonder. The forest is alive with magical elements: flowers that glow and change colors, trees with leaves in shades of purple and silver, and small floating lights that resemble fireflies. The creature stops to interact playfully with a group of tiny, fairy-like beings dancing around a mushroom ring. The creature looks up in awe at a large, glowing tree that seems to be the heart of the forest.
+A dynamic time-lapse video showing the rapidly moving scenery from the window of a speeding train. The camera captures various elements such as lush green fields, towering trees, quaint countryside houses, and distant mountain ranges passing by quickly. The train window frames the view, adding a sense of speed and motion as the landscape rushes past. The camera remains static but emphasizes the fast-paced movement outside. The overall atmosphere is serene yet exhilarating, capturing the essence of travel and exploration. Medium shot focusing on the train window and the rushing scenery beyond.
+

Helios/_DEV/example/prompt_interactive_helios.csv

@@ -0,0 +1,54 @@
+id,prompt_index,prompt
+6,0,"Underwater tornado affecting the ocean floor in a dramatic and chaotic scene. The water is murky, swirling violently, carrying debris and marine life into the vortex. Schools of fish scatter in panic, trying to avoid the powerful currents. Coral reefs and rocks are uprooted and tossed around, creating a tumultuous environment. In the background, large schools of fish swim away from the chaos, while smaller organisms cling to whatever they can find for safety. The camera remains stationary, capturing the intensity of the underwater tornado as it disrupts the serene ocean floor. Close-up shot emphasizing the turbulent motion and destruction."
+6,1,"The underwater vortex intensifies its grip on the seabed, pulling a rusted, barnacle-encrusted anchor from the sand. The heavy iron object spins lethargically at first before being whipped upward into the murky funnel, smashing through floating debris with violent force. Sediment billows in thick clouds around the base of the tornado, obscuring the terrified marine life darting through the gloom. The chaotic currents tear at the ocean floor, exposing deeper layers of rock and silt as the destruction mounts. Close-up shot emphasizing the turbulent motion and destruction."
+6,2,"The underwater tornado rages with unrelenting fury, now dislodging a massive, ancient shipwreck rib from the sediment. The curved wooden beam, blackened by time, groans silently as it is wrenched free and sucked into the spiraling column of water. Murky currents thrash wildly, tossing the heavy timber like a twig amidst the swirling sand and uprooted coral. Smaller debris clatters against the rotating wood, adding to the visual chaos of the deep-sea storm. The vortex dominates the frame, a terrifying engine of nature reshaping the seabed. Close-up shot emphasizing the turbulent motion and destruction."
+6,3,"The violent vortex now ensnares a large, glowing jellyfish, dragging its long, bioluminescent tentacles into the chaotic spiral. The delicate creature spins helplessly, its translucent bell pulsing rapidly against the crushing force of the murky water. Swirling currents rip through the surrounding gloom, tossing sand and fragmented shells in every direction as the tornado dominates the seabed. The glowing blue light of the jellyfish streaks through the darkness, creating a ghostly blur within the churning debris field. Close-up shot emphasizing the turbulent motion and destruction."
+6,4,"The swirling underwater vortex now seizes a heavy, encrusted treasure chest, its lid flapping open as it is torn from the ocean floor. Gold coins and silver trinkets spill out, glittering briefly in the murky water before being swept instantly into the violent funnel. The heavy wooden box tumbles end over end, colliding with floating rocks and adding to the debris field. Swirling sediment and bubbles surround the spilling fortune, highlighting the chaotic power of the storm as it ravages the seabed. Close-up shot emphasizing the turbulent motion and destruction."
+6,5,"The violent underwater tornado continues its rampage, now ripping a massive, stone tiki statue from its resting place on the ocean floor. The carved face of the heavy idol spins wildly as it is sucked into the murky vortex, colliding with swirling rocks and sand. Debris crashes against the stone surface, chipping away at its ancient features while the chaotic currents drag it higher into the funnel. The surrounding water remains thick with sediment, obscuring the background as the heavy statue becomes another victim of the deep-sea storm. Close-up shot emphasizing the turbulent motion and destruction."
+8,1,"A medium close-up of a serene, young East Asian woman with long pink hair, wearing a simple white gown that flows softly around her. She stands amidst gently falling sakura petals, which swirl around her, partially obscuring her figure in a dreamy, ethereal haze. Her delicate features are calm and tranquil as she gazes off into the distance. The background is blurred, featuring a soft pink and white sky with faint outlines of cherry blossom branches. The scene is bathed in a gentle, diffused light, creating a soft, dreamlike atmosphere."
+8,2,"In a serene, still environment, a woman gently lifts her hand towards a delicate flower petal, her fingertips barely touching the wisps of smoke floating nearby. She has a soft, contemplative expression on her face, and her hand moves slowly and gracefully. The scene is captured from a medium close-up angle, focusing on her hand and the petal, with the subtle movement and interaction emphasized. The background is blurred, creating a gentle focus on the main action. The lighting is soft and diffused, adding to the tranquil atmosphere."
+8,3,"A gentle breeze rustles through the air, causing cherry blossom petals to dance gracefully around a young woman's outstretched hand. She stands with a serene expression, wearing a traditional hanfu gown with flowing sleeves. The background showcases a tranquil garden with a winding path and blooming cherry trees. Soft sunlight filters through the leaves, casting dappled shadows on the ground. The scene is captured in a medium close-up, focusing on her hand and the swirling petals, with a slow pan to reveal the beautiful surroundings."
+8,4,"A serene woman with closed eyes and soft, resting eyelashes, exuding a sense of tranquility and peace. She sits gracefully with her hands gently folded in her lap, wearing a flowing, pastel-colored dress that complements her calm demeanor. The lighting is soft and diffused, casting a gentle glow over her face. The background is a blurred, natural setting with hints of greenery and a tranquil atmosphere. The camera focuses closely on her face, capturing the subtle rise and fall of her breath as she maintains a peaceful composure. Close-up shot, emphasizing her serene expression and the gentle movement of her body."
+8,5,"A serene nature scene where a young woman with flowing hair and a gentle expression steps forward gracefully on a grassy meadow. In the background, a small bird flutters and lands on a nearby tree branch. The woman's soft movements contrast with the bird's quick flight, creating a peaceful and harmonious atmosphere. The camera follows her as she moves, capturing the delicate interplay between the woman and the natural world in a medium close-up. The lighting is soft and natural, casting a warm glow over the scene."
+8,6,"A serene moment captured in a magical realism style, where a graceful bird perches delicately on the outstretched finger of a woman. The bird has vibrant plumage and a calm demeanor. Pink and faint cyan-blue smoke begins to swirl and thicken around them, gently enveloping the scene in a soft, misty haze. The woman stands gracefully, her hand extended, with a serene expression. The background is a dimly lit, cozy room with warm wooden elements and soft lighting, adding to the enchanting atmosphere. Medium close-up shot focusing on the interaction between the woman and the bird, with the smoke swirling in the foreground."
+11,1,"In a serene autumn clearing bathed in the warm, golden hues of late afternoon sunlight filtering through tall maple trees, a carpet of vibrant red and orange leaves blankets the ground. A rustic wooden footbridge arches gracefully over a gently trickling stream. Center frame, a sleek silver-gray house cat trots briskly across the leaf-strewn ground, its tail flicking energetically. As a cool breeze stirs, more leaves swirl and dance across the lens, adding a dynamic motion to the tranquil scene. Medium shot capturing the cat in motion against the backdrop of falling leaves."
+11,2,"In a lush forest setting, a playful house cat bounds towards the treeline, leaping gracefully over a fallen log. Mid-stride, the cat transforms into a sleek, smoky brown wildcat with tufted ears and lean, powerful muscles. It continues to run swiftly through the drifting autumn leaves, propelled by its agility and strength. The camera follows the wildcat in a smooth tracking shot, capturing the dynamic motion and the rich, vibrant colors of the forest floor."
+11,3,"In the warm golden hour, a wildcat leaps gracefully across a sparkling stream. As it runs, its body broadens and its fur transforms from its original color to a deep russet tone, morphing seamlessly into a sleek red fox. The fox's bushy, vibrant plume tail catches the sunlight, illuminating its swift movement as it dashes forward. The scene is captured from a dynamic tracking shot, emphasizing the fluid transition and the natural beauty of the changing landscape. Close-up and mid-shot transitions highlight the transformation and the glowing amber sky."
+11,4,"In twilight, a red fox races across an old stone bridge, its chest heaving and coat gradually graying as it transforms into a majestic gray wolf mid-jump. The wolf then gallops through an open forest clearing, leaping over a babbling stream, and continues up the hillside. The sky transitions from orange to deep purple, with stars beginning to twinkle overhead. The camera follows the wolf's swift movement, starting from a medium shot on the bridge and zooming out to a wide-angle view of the wolf bounding towards the hillside under the fading light."
+11,5,"In a serene moonlit forest, the transformation of a wolf into an antelope unfolds gracefully. Initially, the wolf's limbs elongate and refine, its fur shortening from its dense winter coat to a sleek, tawny color. As it shifts, small horns begin to emerge from its forehead. The antelope then swiftly bounds between trees, leaping over obstacles with ease, and finally clearing a tranquil stream in a single graceful leap. The camera captures this magical metamorphosis with smooth tracking shots and close-ups, emphasizing the fluidity and beauty of the change."
+11,6,"In a mystical scene under the bright moonlight, an antelope gradually transforms into a powerful horse. Initially, the antelope has a slender frame with a rich chestnut coat. As the transformation progresses, it grows taller and heavier, developing the muscular build and sturdy legs of a horse. The horse then begins to gallop majestically towards the horizon, its mane flowing freely in the wind. Its hooves rhythmically ring against the leaf-strewn ground, seamlessly completing the metamorphosis from cat-like agility to equine power. The scene is captured in a sweeping aerial shot, emphasizing the fluidity and grace of the transformation."
+14,1,"Close-up from the left side of a forest clearing, focus on a little girl in a light pink tulle dress with long flowing brown hair. She gazes slightly upward with a gentle, serene expression. The ground is covered in green grass and scattered wildflowers, with light mist creating an ethereal atmosphere. Sunbeams filter through the tall tree branches, casting dappled light. The scene is rendered in fantasy realism with soft, dreamy lighting, emphasizing the magical quality of the forest."
+14,2,"A slow pullback reveals a glowing magical stone appearing on the right side of the frame. In the center, a young girl remains stationary, her expression serene and focused. Sunbeams filter through the clouds, shifting slightly as the camera moves backward, casting gentle shadows across the scene. The background gradually comes into view, showcasing a mystical forest with tall trees and vibrant greenery. The camera captures the magic and wonder of the moment in a medium-wide shot."
+14,3,"Start with a close-up of a young boy in a blue robe adorned with a light tulle cloak as he enters from the right side of the frame. As he stops, the camera slowly pulls back to reveal a girl watching him intently from a few feet away. In the background, a large stone statue remains stationary, adding a sense of permanence and stillness to the scene. The environment is a dimly lit, ancient-looking room with stone walls and pillars. The camera movement emphasizes the interaction between the characters and their surroundings, capturing their expressions and body language clearly. Medium to wide shot transition."
+14,4,"A slight pan and pullback reveal a young boy nodding his head, his face showing a mixture of curiosity and determination. In response, a young girl raises her hand in acknowledgment, her expression serene and focused. Both children stand near a luminous stone that continues to emit a soft, warm glow, casting gentle light over the surrounding area. The scene takes place in a dimly lit forest clearing, with tall trees and dense undergrowth visible in the background. Medium shot transitioning to wide shot."
+14,5,"In a serene forest clearing, a young woman with flowing blonde hair turns towards a young man standing beside her. As the camera pulls to a medium shot, the couple's intimate moment is revealed against a backdrop of vibrant wildflowers and wisps of mist gently hovering above the ground. The environment is bathed in soft, natural light, enhancing the romantic atmosphere. The camera movement smoothly captures the subtle shift in their positions, bringing the entire scene into clear focus."
+14,6,"Wide shot: A young boy in a casual outfit walks out to the right, while a girl stays stationary to the left. In the middle of a fully lit forest clearing, a luminous stone emits a warm glow, surrounded by drifting mist and soft sunbeams filtering through the canopy. The camera pans slowly to follow the boy as he moves, capturing the serene beauty of the misty landscape and the mystical ambiance created by the glowing stone."
+20,0,"A majestic lion named Leo stands regally in the heart of a dense jungle, embodying the essence of a king. Leo has a golden mane that flows gracefully around his broad shoulders, and his piercing amber eyes survey the landscape with confidence and authority. He is positioned on a rocky outcrop, towering over the lush greenery below. The background showcases a vibrant jungle scene with tall trees, cascading vines, and dappled sunlight filtering through the canopy. Leo's posture is proud and commanding, with his tail held high. The scene is captured from a medium close-up perspective, emphasizing Leo’s powerful stance and the regal aura surrounding him."
+20,1,"Leo shifts his powerful weight slightly on the rocky outcrop, his golden mane rippling as he does so. Suddenly, he opens his massive jaws to release a deep, resonant roar that vibrates through the humid air, revealing his formidable white teeth. The dappled sunlight filtering through the canopy dances across his fur as his chest expands with the effort. The vibrant jungle remains lush and green around him, with tall trees and cascading vines framing his commanding figure. A medium close-up perspective emphasizing Leo’s powerful stance and the regal aura surrounding him."
+20,2,"Leo maintains his regal position on the rocky outcrop as the humid jungle air settles around his broad shoulders. He suddenly lowers his massive head to sniff a vibrant blue butterfly that has fluttered near his nose, his piercing amber eyes momentarily softening with curiosity. The dappled sunlight continues to filter through the tall trees and cascading vines, illuminating the golden hues of his mane against the lush green background. His tail remains held high, a symbol of his enduring authority over the landscape. A medium close-up perspective emphasizing Leo’s powerful stance and the regal aura surrounding him."
+20,3,"Leo stands tall on the rocky outcrop in the heart of the dense jungle, his golden mane glowing in the dappled sunlight. He lifts a massive paw to swipe gently at a low-hanging vine that dangles just within his reach, testing its texture with sharp claws. His piercing amber eyes remain alert, scanning the lush greenery and tall trees that surround him. The vibrant background of cascading vines and filtered light frames his regal form perfectly. A medium close-up perspective emphasizing Leo’s powerful stance and the regal aura surrounding him."
+20,4,"Leo remains on the rocky outcrop in the heart of the dense jungle, his golden mane catching the filtered light. He suddenly turns his head sharply to the left, his ears twitching as he focuses on a brightly colored parrot that lands on a nearby branch. His piercing amber eyes lock onto the bird with intense focus, analyzing the new arrival amidst the tall trees and cascading vines. The lush greenery provides a vibrant backdrop as he stands with authority, his posture commanding and proud. A medium close-up perspective emphasizing Leo’s powerful stance and the regal aura surrounding him."
+20,5,"Leo stands regally on the rocky outcrop in the heart of the dense jungle, his golden mane flowing around his broad shoulders. He dips his head low to lap cool water from a small, clear puddle that has formed in a crevice of the stone, his rough tongue splashing gently. His piercing amber eyes briefly close in satisfaction before reopening to survey the lush greenery, tall trees, and cascading vines. The dappled sunlight filters through the canopy, highlighting the wet fur on his muzzle. A medium close-up perspective emphasizing Leo’s powerful stance and the regal aura surrounding him."
+153,0,"90s VHS-style The Weather Channel scene, featuring a weatherman standing in front of a green screen with a large map of storm systems behind him. The weatherman, dressed in a casual but professional outfit, points emphatically at the rapidly moving storms on the map. His face shows concern and urgency as he speaks directly to the camera. The background map displays swirling patterns indicating severe weather conditions. The overall scene has a vintage, grainy texture with the characteristic noise and color palette of old VHS recordings. Medium close-up shot focusing on the weatherman's gestures and expressions."
+153,1,"The weatherman now reaches into his pocket and pulls out a chunky black walkie-talkie, pressing it against his ear with a sudden look of intense focus. He nods sharply while listening to an urgent update, his brow furrowing deeper under the studio lights. The green screen map behind him flickers slightly as the swirling storm systems intensify in color, shifting from red to deep purple. The vintage VHS grain distorts the edges of his suit jacket as he lowers the device and turns back to address the viewers with renewed alarm. Medium close-up shot focusing on the weatherman's gestures and expressions."
+153,2,"The weatherman suddenly unrolls a large, paper topographic map across a small stand that appears from the side, smoothing out the creases with frantic energy. He traces a specific mountain range with his finger, highlighting a dangerous path the storm is taking, his eyes wide with genuine fear. The digital map behind him glitches momentarily, syncing with his analogue demonstration as the VHS static rolls vertically across the frame. The studio lights reflect off the glossy paper surface as he taps a specific valley location repeatedly. Medium close-up shot focusing on the weatherman's gestures and expressions."
+153,3,"The weatherman abruptly grabs a bright red marker pen from the desk edge and begins circling a specific coastal city directly on the camera lens itself. He draws a jagged, erratic line across the glass to simulate the storm's unpredictable path, his hand shaking slightly with adrenaline. The ink squeaks audibly against the surface as the green screen map behind him pulses with warning icons. The VHS static buzzes louder, momentarily distorting his face as he caps the marker and stares intensely through his red drawings. Medium close-up shot focusing on the weatherman's gestures and expressions."
+153,4,"The weatherman now lifts a large, distinct ""Hurricane Warning"" sign made of heavy cardboard, holding it up beside his face for the audience to see clearly. The blocky red letters on the sign contrast sharply with his beige suit as he taps the edge of the board for emphasis. Behind him, the digital map swirls violently, the green screen effects blending slightly with the edges of the physical prop. The VHS tracking lines jitter horizontally across the bottom of the frame, enhancing the retro aesthetic as he maintains intense eye contact. Medium close-up shot focusing on the weatherman's gestures and expressions."
+153,5,"The weatherman suddenly dons a bright yellow rain slicker over his suit, struggling momentarily with the snaps as he prepares for a simulated outdoor report. He pulls the hood up over his head, framing his face tightly while the green screen behind him shifts to show footage of swaying palm trees and flying debris. The synthetic material of the coat reflects the studio lights with a harsh glare, adding to the chaotic atmosphere. The grainy VHS texture creates color bleeding around the vibrant yellow fabric as he shouts over imaginary wind. Medium close-up shot focusing on the weatherman's gestures and expressions."
+200,0,"A female astronaut in a full spacesuit, including an astronaut helmet, is running swiftly away from an unknown threat. She has a determined and focused expression on her face. The spacesuit is sleek, silver, and equipped with various gadgets and sensors. Her hair is visible under the helmet, flowing behind her as she runs. The background shows a desolate, rocky landscape with distant mountains and a dark, starry sky. The scene captures a medium shot of the woman mid-run, emphasizing her speed and urgency."
+200,1,"The silver-suited astronaut sprints across the rocky terrain, but now she firmly clutches a glowing red geological scanner in her right hand, its lights pulsing rhythmically against the dark environment. Her expression remains intense under the helmet visor as she navigates the uneven ground, the sleek gadgets on her suit reflecting faint starlight. The desolate landscape stretches endlessly around her, framed by jagged mountains in the distance. The medium shot tracks alongside her movement, keeping pace with her urgent stride against the backdrop of the vast, starry void. medium shot mid-run speed urgency"
+200,2,"The female astronaut races forward across the jagged terrain, her silver spacesuit gleaming against the dark void. Suddenly, a small drone detaches from her shoulder armor and hovers briefly before zooming ahead to scout the path. Her face remains locked in focused determination behind the helmet visor as her hair shifts with her rapid movement. The desolate rocky ground and looming distant mountains provide a stark backdrop to her flight. The camera maintains a medium shot of the woman mid-run, emphasizing her speed and urgency"
+200,3,"The female astronaut sprints across the desolate, rocky landscape, her silver spacesuit reflecting the cold starlight. As she runs, she suddenly raises her left arm to activate a holographic map projected from her wrist gauntlet, displaying a complex grid of blue lines and waypoints. Her expression remains fierce and concentrated behind the helmet visor while her hair moves with the momentum of her stride. The dark mountains loom in the distance under the starry sky. The scene captures a medium shot of the woman mid-run, emphasizing her speed and urgency"
+200,4,"The female astronaut dashes across the uneven, rocky ground, her sleek silver spacesuit shimmering under the starry sky. Without slowing her rapid pace, she reaches to her belt and deploys a luminous blue energy flare, dropping it behind her to mark her trail. Her face is set in a look of grim determination inside the helmet, with strands of hair floating with her motion. The dark, desolate landscape and distant mountains rush by as she flees. The scene captures a medium shot of the woman mid-run, emphasizing her speed and urgency"
+200,5,"The silver-clad astronaut sprints relentlessly across the treacherous rocky terrain, her breath fogging the corner of her helmet visor. As she runs, she suddenly taps a control on her chest plate, causing a pair of bright white headlights to activate on either side of her helmet, cutting through the darkness ahead. Her determined eyes scan the illuminated path while the desolate landscape and jagged mountains blur in the background. The starry sky hangs heavy above her swift escape. The scene captures a medium shot of the woman mid-run, emphasizing her speed and urgency"
+312,0,"A young woman standing in the rain, looking up at the sky with a warm, inviting smile on her face. She is dressed in a light, flowy dress that clings to her form as droplets of water fall around her. Her hair is gently tousled from the rain, framing her delicate features. The background shows a blurred cityscape with tall buildings and the faint glow of streetlights. The scene captures the serene beauty of a rainy evening. Medium close-up, static shot focusing on the girl's face and upper body."
+312,2,"The young woman remains framed against the soft blur of city lights, the rain now glistening on her skin as she slowly extends her right hand palm-up to catch the falling droplets. Her expression shifts slightly to one of quiet wonder as the water pools in her cupped fingers. The light fabric of her dress continues to sway subtly with the gentle wind, emphasizing the damp atmosphere. The distant streetlights create bokeh orbs behind her silhouette. Medium close-up, static shot focusing on the girl's face and upper body."
+312,3,"The young woman in the light, flowy dress now closes her eyes, tilting her head back slightly to let the rain wash over her face. She reaches into her pocket and pulls out a bright red origami crane, holding it delicately between her fingers. The paper quickly darkens as it absorbs the moisture, contrasting with the blurred gray cityscape behind her. Her hair is plastered more closely to her cheeks by the persistent downpour, while the streetlights cast a soft, shimmering glow on the wet paper bird. Medium close-up, static shot focusing on the girl's face and upper body."
+312,4,"The young woman in the soaked flowy dress opens her eyes and suddenly unfurls a small, transparent umbrella with a floral pattern above her head. The rain drums rhythmically against the plastic canopy, creating a protective bubble around her upper body while water streams down the sides. The red paper crane she held previously is now tucked away or gone, replaced by her grip on the curved umbrella handle. The blurred city lights reflect beautifully on the wet surface of the umbrella as she gazes forward with renewed calmness. Medium close-up, static shot focusing on the girl's face and upper body."
+312,5,"The young woman stands beneath the transparent floral umbrella, the rain creating a rhythmic patter on its surface. She reaches up with her free hand and adjusts a pair of round, gold-rimmed glasses onto the bridge of her nose, blinking behind the lenses as they catch the ambient city light. Her damp hair frames her face, and the light dress clings softly to her form in the humid air. The blurred cityscape behind her glows with the warmth of streetlights, enhancing the serene mood. Medium close-up, static shot focusing on the girl's face and upper body."
+334,0,"A stylish, young woman riding a sleek black motorcycle down a bustling city street. She wears a fitted leather jacket, dark sunglasses, and a helmet with a visor up, revealing her confident expression. Her posture is relaxed yet controlled as she grips the handlebars firmly. The motorcycle's engine roars as she navigates through traffic. The urban backdrop includes tall buildings, street signs, and passing cars, creating a vibrant, dynamic scene. Medium shot focusing on the girl and the motorcycle, capturing the energy of the city."
+334,1,"The stylish young woman on the sleek black motorcycle leans slightly to the right as she smoothly changes lanes. Her fitted leather jacket gleams under the city lights, and her dark sunglasses reflect the passing scenery. With her helmet visor up, a faint smile plays on her lips, showing her enjoyment of the ride. Suddenly, she extends her left hand to adjust the side mirror, briefly checking the reflection of the vibrant urban backdrop behind her before returning her grip to the handlebars. Medium shot focusing on the girl and the motorcycle, capturing the energy of the city."
+334,2,"The stylish young woman on the sleek black motorcycle accelerates gently, causing her hair to flutter beneath the edge of her helmet. Her fitted leather jacket remains snug against the wind, while her dark sunglasses shield her eyes from the glare. As she cruises past towering skyscrapers and vibrant street signs, she reaches down with her right hand to toggle a switch on the dashboard, activating the motorcycle's bright turn signal. The urban environment blurs slightly in the background, emphasizing her focused movement through the traffic. Medium shot focusing on the girl and the motorcycle, capturing the energy of the city."
+334,3,"The stylish young woman on the sleek black motorcycle maintains her steady pace through the busy urban corridor. Her fitted leather jacket and dark sunglasses remain prominent against the backdrop of tall buildings and passing cars. With her helmet visor up, her confident expression is clear as she navigates the road. As she rides, she briefly lifts her left boot to shift gears, pressing down decisively on the pedal near the footrest. The engine note changes pitch slightly, blending with the city noise, while street signs flash by in the background. Medium shot focusing on the girl and the motorcycle, capturing the energy of the city."
+334,4,"The stylish young woman on the sleek black motorcycle rides confidently forward amidst the bustling traffic. Her fitted leather jacket and dark sunglasses stay consistent with her cool demeanor, while the helmet visor remains up. As she passes a row of tall buildings and street signs, she suddenly raises her left hand to wave at a pedestrian standing on the nearby sidewalk. Her posture stays relaxed despite the momentary gesture, and she quickly returns her hand to the grip to maintain control. The urban backdrop continues to provide a vibrant, dynamic atmosphere around her. Medium shot focusing on the girl and the motorcycle, capturing the energy of the city."
+334,5,"The stylish young woman on the sleek black motorcycle rides forward, her fitted leather jacket absorbing the ambient city light. She wears dark sunglasses and keeps her helmet visor up, maintaining a confident, relaxed expression amidst the towering buildings and passing cars. While cruising through the vibrant urban scene, she briefly tilts her head to glance at a large digital billboard flashing colorful advertisements above the street. Her grip on the handlebars remains steady as she takes in the glowing display before refocusing on the road ahead. Medium shot focusing on the girl and the motorcycle, capturing the energy of the city."

Helios/_DEV/example/toy_data/toy_filter.json

@@ -0,0 +1,46 @@
+[
+  {
+    "cut": [
+      0,
+      81
+    ],
+    "crop": [
+      0,
+      832,
+      0,
+      480
+    ],
+    "fps": 24.0,
+    "num_frames": 81,
+    "resolution": {
+      "height": 480,
+      "width": 832
+    },
+    "cap": [
+      "A stunning mid-afternoon landscape photograph with a low camera angle, showcasing several giant wooly mammoths treading through a snowy meadow. Their long, wooly fur gently billows in the brisk wind as they move, creating a sense of natural movement. Snow-covered trees and dramatic snow-capped mountains loom in the distance, adding to the majestic setting. Wispy clouds and a high sun cast a warm glow over the scene, enhancing the serene and awe-inspiring atmosphere. The depth of field brings out the detailed textures of the mammoths and the snowy environment, capturing every nuance of these prehistoric giants in breathtaking clarity."
+    ],
+    "path": "videos/2_240_ori81.mp4"
+  },
+  {
+    "cut": [
+      0,
+      129
+    ],
+    "crop": [
+      0,
+      832,
+      0,
+      480
+    ],
+    "fps": 24.0,
+    "num_frames": 129,
+    "resolution": {
+      "height": 480,
+      "width": 832
+    },
+    "cap": [
+      "An old man in blue jeans and a white T-shirt takes a leisurely stroll along a bustling street in Mumbai, India, during a breathtaking sunset. He walks with a gentle sway, his weathered face reflecting the warm hues of the setting sun. His hands rest casually in his pockets, and he appears content and at peace. The background features a vibrant mix of colorful buildings, street vendors, and pedestrians, with the sky painted in shades of orange, pink, and purple. The photo has a nostalgic and documentary style, capturing the essence of a serene moment amidst the city's energy. A medium shot with a soft focus on the old man."
+    ],
+    "path": "videos/239_120_ori129.mp4"
+  }
+]

Helios/_DEV/helios/dataset/dataloader_dmd.py

@@ -0,0 +1,531 @@
+import os
+import pickle
+import random
+from collections import defaultdict
+
+import torch
+from einops import rearrange
+from torch.utils.data import Dataset, Sampler
+
+
+class BucketedFeatureDataset(Dataset):
+    def __init__(
+        self,
+        gan_folders=None,
+        ode_folders=None,
+        text_folders=None,
+        is_use_gt_history=False,
+        return_secondary=False,
+        force_rebuild=False,
+        single_res=True,
+        single_length=True,
+        single_num_frame=81,
+        single_height=384,
+        single_width=640,
+        seed=42,
+    ):
+        self.is_use_gt_history = is_use_gt_history
+        self.return_secondary = return_secondary
+        self.force_rebuild = force_rebuild
+        self.base_seed = seed
+        self._epoch = 0
+
+        self.single_res = single_res
+        self.single_length = single_length
+        self.single_num_frame = single_num_frame
+        self.single_height = single_height
+        self.single_width = single_width
+
+        self.gan_samples = self._init_samples(gan_folders, "gan")
+        self.ode_samples = self._init_samples(ode_folders, "ode")
+        self.text_samples = self._init_samples(text_folders, "text")
+
+        self._align_sample_counts()
+
+    def _init_samples(self, folders, data_type):
+        if folders is None:
+            return []
+
+        folders = [folders] if isinstance(folders, str) else folders
+        samples = []
+
+        for folder in folders:
+            cache_file = os.path.join(folder, f"{data_type}_dataset_cache.pkl")
+            folder_samples = self._process_folder(folder, cache_file, data_type)
+            samples.extend(folder_samples)
+
+        return samples
+
+    def _align_sample_counts(self, is_log=True):
+        lengths = {"gan": len(self.gan_samples), "ode": len(self.ode_samples), "text": len(self.text_samples)}
+
+        non_empty_lengths = {k: v for k, v in lengths.items() if v > 0}
+        if not non_empty_lengths:
+            return
+        max_length = max(non_empty_lengths.values())
+
+        if is_log:
+            print(f"\nAligning sample counts to max: {max_length}")
+            print(f"Original counts - GAN: {lengths['gan']}, ODE: {lengths['ode']}, TEXT: {lengths['text']}")
+
+        random.seed(self.base_seed)
+
+        if self.gan_samples and len(self.gan_samples) < max_length:
+            self.gan_samples = self._expand_samples(self.gan_samples, max_length, "GAN")
+
+        if self.ode_samples and len(self.ode_samples) < max_length:
+            self.ode_samples = self._expand_samples(self.ode_samples, max_length, "ODE")
+
+        if self.text_samples and len(self.text_samples) < max_length:
+            self.text_samples = self._expand_samples(self.text_samples, max_length, "TEXT")
+
+        if is_log:
+            print(
+                f"Aligned counts - GAN: {len(self.gan_samples)}, ODE: {len(self.ode_samples)}, TEXT: {len(self.text_samples)}\n"
+            )
+
+    def _expand_samples(self, samples, target_length, data_type):
+        original_length = len(samples)
+        expanded_samples = samples.copy()
+
+        while len(expanded_samples) < target_length:
+            random_sample = random.choice(samples)
+            expanded_samples.append(random_sample)
+
+        print(f"{data_type}: Expanded from {original_length} to {len(expanded_samples)} samples")
+        return expanded_samples
+
+    def _process_folder(self, folder, cache_file, data_type):
+        if self.force_rebuild or not os.path.exists(cache_file):
+            # if os.path.exists(cache_file):
+            #     os.remove(cache_file)
+            print(f"{data_type.upper()}: Building metadata cache for folder: {folder}")
+            folder_samples = self._build_folder_metadata(folder, data_type)
+
+            if not self.force_rebuild:
+                print(f"{data_type.upper()}: Saving metadata cache for folder: {folder}")
+                with open(cache_file, "wb") as f:
+                    pickle.dump({"samples": folder_samples}, f)
+
+            print(f"{data_type.upper()}: Cached {len(folder_samples)} samples from {folder}")
+        else:
+            print(f"{data_type.upper()}: Loading cached metadata from: {folder}")
+            with open(cache_file, "rb") as f:
+                folder_samples = pickle.load(f)["samples"]
+            print(f"{data_type.upper()}: Loaded {len(folder_samples)} samples from cache: {folder}")
+
+        return folder_samples
+
+    def _build_folder_metadata(self, folder, data_type):
+        feature_files = [f for f in os.listdir(folder) if f.endswith(".pt")]
+        samples = []
+
+        print(f"{data_type.upper()}: Processing {len(feature_files)} files in {folder}...")
+        for i, feature_file in enumerate(feature_files):
+            if i % 10000 == 0:
+                print(f"  {data_type.upper()}: Processed {i}/{len(feature_files)} files")
+
+            feature_path = os.path.join(folder, feature_file)
+
+            # TODO hard code here now
+            if data_type == "gan":
+                parts = feature_file.split("_")
+                num_frame = int(parts[-3])
+                height = int(parts[-2])
+                width = int(parts[-1].replace(".pt", ""))
+
+                if self.is_use_gt_history:
+                    if (height, width) not in [(self.single_height, self.single_width)]:
+                        continue
+                else:
+                    if (num_frame, height, width) not in [
+                        (self.single_num_frame, self.single_height, self.single_width)
+                    ]:
+                        continue
+
+            samples.append(
+                {
+                    "uttid": os.path.splitext(os.path.basename(feature_file))[0],
+                    "dataset_name": folder.rstrip("/"),
+                    "file_path": feature_path,
+                }
+            )
+
+        return samples
+
+    def prepare_stage1_latent(self, vae_latent, idx, base_vae_latent=None, return_secondary=False):
+        self.is_keep_x0 = (True,)
+        self.history_sizes = [16, 2, 1]
+        self.num_rollout_sections = 9
+
+        source_latent = base_vae_latent if base_vae_latent is not None else vae_latent
+
+        x0_latent = None
+        if self.is_keep_x0:
+            x0_latent = source_latent[0, :, :1, :, :].clone()
+        total_sections = source_latent.shape[0]
+        latent_window_size = source_latent.shape[2]
+        history_window_size = sum(self.history_sizes)
+        section_size = history_window_size + latent_window_size
+
+        temp_source_latent = rearrange(source_latent, "b c t h w -> c (b t) h w")
+        zero_padding_source = torch.zeros(
+            temp_source_latent.shape[0],
+            history_window_size,
+            temp_source_latent.shape[2],
+            temp_source_latent.shape[3],
+            device=temp_source_latent.device,
+            dtype=temp_source_latent.dtype,
+        )
+        continue_source_latent = torch.cat([zero_padding_source, temp_source_latent], dim=1)
+
+        temp_vae_latent = rearrange(vae_latent, "b c t h w -> c (b t) h w")
+        zero_padding_vae = torch.zeros(
+            temp_vae_latent.shape[0],
+            history_window_size,
+            temp_vae_latent.shape[2],
+            temp_vae_latent.shape[3],
+            device=temp_vae_latent.device,
+            dtype=temp_vae_latent.dtype,
+        )
+        continue_vae_latent = torch.cat([zero_padding_vae, temp_vae_latent], dim=1)
+
+        sample_seed = self.base_seed + self._epoch * 1000000 + idx
+        choice_idx = torch.randint(
+            0, total_sections, (1,), generator=torch.Generator().manual_seed(sample_seed)
+        ).item()
+        if choice_idx == 0 and x0_latent is not None:
+            x0_latent = torch.zeros_like(x0_latent)
+
+        start_indice = choice_idx * latent_window_size
+        end_indice = start_indice + section_size
+
+        history_latent = continue_source_latent[:, start_indice : start_indice + history_window_size, :, :]
+        target_latent = continue_vae_latent[:, start_indice + history_window_size : end_indice, :, :]
+
+        x0_latent_2 = None
+        history_latent_2 = None
+        target_latent_2 = None
+        if return_secondary:
+            sample_seed_2 = self.base_seed + self._epoch * 1000000 + idx + 999999
+            choice_idx_2 = torch.randint(
+                0, total_sections, (1,), generator=torch.Generator().manual_seed(sample_seed_2)
+            ).item()
+
+            x0_latent_2 = None
+            if self.is_keep_x0:
+                x0_latent_2 = source_latent[0, :, :1, :, :].clone()
+                if choice_idx_2 == 0:
+                    x0_latent_2 = torch.zeros_like(x0_latent_2)
+
+            start_indice_2 = choice_idx_2 * latent_window_size
+            end_indice_2 = start_indice_2 + section_size
+
+            history_latent_2 = continue_source_latent[:, start_indice_2 : start_indice_2 + history_window_size, :, :]
+            target_latent_2 = continue_vae_latent[:, start_indice_2 + history_window_size : end_indice_2, :, :]
+
+        return (x0_latent, history_latent, target_latent), (x0_latent_2, history_latent_2, target_latent_2)
+
+    def set_epoch(self, epoch):
+        self._epoch = epoch
+        random.seed(self.base_seed + epoch)
+        self._align_sample_counts(is_log=False)
+
+    def __len__(self):
+        return max(len(self.gan_samples), len(self.ode_samples), len(self.text_samples))
+
+    def __getitem__(self, idx):
+        while True:
+            try:
+                output_dict = {}
+
+                if self.gan_samples:
+                    gan_sample = self.gan_samples[idx]
+                    gan_feature = torch.load(gan_sample["file_path"], map_location="cpu", weights_only=False)
+                    if self.is_use_gt_history:
+                        (
+                            (x0_latent, history_latent, target_latent),
+                            (x0_latent_2, history_latent_2, target_latent_2),
+                        ) = self.prepare_stage1_latent(
+                            gan_feature["vae_latent"],
+                            idx,
+                            return_secondary=self.return_secondary,
+                        )
+                        output_dict.update(
+                            {
+                                "gan_uttid": gan_sample["uttid"],
+                                "gan_dataset_name": gan_sample["dataset_name"],
+                                "gan_vae_latents": target_latent,
+                                "gan_x0_latents": x0_latent,
+                                "gan_history_latents": history_latent,
+                                "gan_vae_latents_2": target_latent_2,
+                                "gan_x0_latents_2": x0_latent_2,
+                                "gan_history_latents_2": history_latent_2,
+                                "gan_prompt_raws": gan_feature["prompt_raw"],
+                                "gan_prompt_embeds": gan_feature["prompt_embed"],
+                            }
+                        )
+                    else:
+                        output_dict.update(
+                            {
+                                "gan_uttid": gan_sample["uttid"],
+                                "gan_dataset_name": gan_sample["dataset_name"],
+                                "gan_vae_latents": gan_feature["vae_latent"],
+                                "gan_prompt_raws": gan_feature["prompt_raw"],
+                                "gan_prompt_embeds": gan_feature["prompt_embed"],
+                            }
+                        )
+                    gan_sample = None
+                    gan_feature = None
+                    del gan_sample
+                    del gan_feature
+
+                if self.ode_samples:
+                    ode_sample = self.ode_samples[idx]
+                    ode_feature = torch.load(ode_sample["file_path"], map_location="cpu", weights_only=False)
+                    output_dict.update(
+                        {
+                            "ode_uttid": ode_sample["uttid"],
+                            "ode_dataset_name": ode_sample["dataset_name"],
+                            "ode_latent_window_size": ode_feature["latent_window_size"],
+                            "ode_latents": ode_feature["ode_latents"],
+                            "ode_prompt_raws": ode_feature["prompt_raw"],
+                            "ode_prompt_embeds": ode_feature["prompt_embed"][0],
+                        }
+                    )
+                    ode_sample = None
+                    ode_feature = None
+                    del ode_sample
+                    del ode_feature
+
+                if self.text_samples:
+                    text_sample = self.text_samples[idx]
+                    text_feature = torch.load(text_sample["file_path"], map_location="cpu", weights_only=False)
+                    output_dict.update(
+                        {
+                            "text_uttid": text_sample["uttid"],
+                            "text_dataset_name": text_sample["dataset_name"],
+                            "text_prompt_raws": text_feature["prompt_raw"],
+                            "text_prompt_embeds": text_feature["prompt_embed"],
+                        }
+                    )
+                    text_sample = None
+                    text_feature = None
+                    del text_sample
+                    del text_feature
+
+                return output_dict
+
+            except Exception as e:
+                idx = random.randint(0, len(self) - 1)
+                print(f"Error loading sample at idx {idx}, retrying... Error: {e}")
+
+
+class BucketedSampler(Sampler):
+    def __init__(
+        self,
+        dataset,
+        batch_size,
+        dataset_sampling_ratios={},
+        drop_last=False,
+        shuffle=True,
+        seed=42,
+        num_sp_groups=1,
+        sp_world_size=1,
+        global_rank=0,
+    ):
+        self.dataset = dataset
+        self.batch_size = batch_size
+        self.drop_last = drop_last
+        self.shuffle = shuffle
+        self.seed = seed
+        self.generator = torch.Generator()
+        self._epoch = 0
+
+        # Distributed parameters
+        self.num_sp_groups = num_sp_groups
+        self.sp_world_size = sp_world_size
+        self.global_rank = global_rank
+        self.ith_sp_group = self.global_rank // self.sp_world_size
+
+    def set_epoch(self, epoch):
+        self._epoch = epoch
+
+    def _shard_indices_for_sp_group(self, indices):
+        """
+        Shard indices across SP groups.
+        Each SP group gets a disjoint subset of the data.
+        """
+        if self.num_sp_groups == 1:
+            return indices
+
+        # Convert to tensor if it's a list
+        if isinstance(indices, list):
+            indices_tensor = torch.tensor(indices, dtype=torch.long)
+        else:
+            indices_tensor = indices
+
+        # Pad indices if necessary to make it divisible by num_sp_groups
+        total_size = len(indices_tensor)
+        if total_size % self.num_sp_groups != 0:
+            if not self.drop_last:
+                padding_size = self.num_sp_groups - (total_size % self.num_sp_groups)
+                indices_tensor = torch.cat([indices_tensor, indices_tensor[:padding_size]])
+        else:
+            # If drop_last, truncate to be divisible
+            if self.drop_last:
+                truncate_size = (total_size // self.num_sp_groups) * self.num_sp_groups
+                indices_tensor = indices_tensor[:truncate_size]
+
+        # Shard: each SP group gets every num_sp_groups-th element
+        sp_group_indices = indices_tensor[self.ith_sp_group :: self.num_sp_groups]
+
+        return sp_group_indices.tolist()
+
+    def __iter__(self):
+        # Use epoch-level seed for reproducibility
+        epoch_seed = self.seed + self._epoch
+        self.generator.manual_seed(epoch_seed)
+
+        # Get all indices
+        all_indices = list(range(len(self.dataset)))
+
+        # Global shuffle before sharding (important for distributed consistency)
+        if self.shuffle:
+            perm = torch.randperm(len(all_indices), generator=self.generator).tolist()
+            all_indices = [all_indices[i] for i in perm]
+
+        # Shard indices for this SP group
+        sp_group_indices = self._shard_indices_for_sp_group(all_indices)
+
+        # Create batches
+        for i in range(0, len(sp_group_indices), self.batch_size):
+            batch = sp_group_indices[i : i + self.batch_size]
+            if len(batch) == self.batch_size or not self.drop_last:
+                yield batch
+
+    def __len__(self):
+        # Total samples in dataset
+        total_samples = len(self.dataset)
+
+        # Account for SP group sharding
+        sp_group_samples = total_samples // self.num_sp_groups
+        if not self.drop_last and total_samples % self.num_sp_groups != 0:
+            sp_group_samples += 1
+
+        # Calculate number of batches
+        total_batches = sp_group_samples // self.batch_size
+        if not self.drop_last and sp_group_samples % self.batch_size != 0:
+            total_batches += 1
+
+        return total_batches
+
+
+def collate_fn(batch):
+    return {
+        key: torch.stack([d[key] for d in batch])
+        if isinstance(batch[0][key], torch.Tensor)
+        else [d[key] for d in batch]
+        for key in batch[0]
+    }
+
+
+if __name__ == "__main__":
+    from accelerate import Accelerator
+    from torchdata.stateful_dataloader import StatefulDataLoader
+
+    dataloader_num_workers = 8
+    batch_size = 2
+    num_train_epochs = 2
+    seed = 0
+
+    gan_folder = [
+        "/mnt/hdfs/data/ysh_new/userful_things_wan/gan_latents/ultravideo/clips_long_960",
+        "/mnt/hdfs/data/ysh_new/userful_things_wan/gan_latents/ultravideo/clips_short_960",
+    ]
+    ode_folder = [
+        "/mnt/hdfs/data/ysh_new/userful_things_wan/ode_pairs/vidprom_filtered_extended",
+    ]
+    text_folder = [
+        "/mnt/hdfs/data/ysh_new/userful_things_wan/text-embedding/mixkit_filter",
+        "/mnt/hdfs/data/ysh_new/userful_things_wan/text-embedding/vidprom_filtered_extended",
+    ]
+
+    accelerator = Accelerator()
+    print(accelerator.process_index, accelerator.num_processes)
+
+    dataset = BucketedFeatureDataset(
+        gan_folders=gan_folder,
+        ode_folders=ode_folder,
+        text_folders=text_folder,
+        is_use_gt_history=True,
+        force_rebuild=True,
+        seed=seed,
+    )
+    sampler = BucketedSampler(
+        dataset,
+        batch_size=batch_size,
+        drop_last=True,
+        shuffle=True,
+        seed=seed,
+        num_sp_groups=accelerator.num_processes // 1,
+        sp_world_size=1,
+        global_rank=accelerator.process_index,
+    )
+    dataloader = StatefulDataLoader(
+        dataset,
+        batch_sampler=sampler,
+        collate_fn=collate_fn,
+        num_workers=dataloader_num_workers,
+        prefetch_factor=2 if dataloader_num_workers > 0 else None,
+    )
+    print(len(dataset), len(dataloader))
+    print(f"Dataset size: {len(dataset)}, Dataloader batches: {len(dataloader)}")
+
+    step = 0
+    global_step = 0
+    first_epoch = 0
+    print("Testing dataloader...")
+    dataset_counts = defaultdict(int)
+    for epoch in range(first_epoch, num_train_epochs):
+        sampler.set_epoch(epoch)
+        dataset.set_epoch(epoch)
+        for i, batch in enumerate(dataloader):
+            # Get metadata
+            gan_uttid = batch["gan_uttid"]
+            ode_uttid = batch["ode_uttid"]
+            text_uttid = batch["text_uttid"]
+
+            # Get feature
+            # For GAN
+            gan_vae_latents = batch["gan_vae_latents"]
+            gan_prompt_raws = batch["gan_prompt_raws"]
+            gan_prompt_embeds = batch["gan_prompt_embeds"]
+            print(gan_vae_latents.shape, gan_prompt_embeds.shape, gan_prompt_raws)
+
+            # For ODE
+            ode_prompt_raws = batch["ode_prompt_raws"]
+            ode_prompt_embeds = batch["ode_prompt_embeds"]
+            print(ode_prompt_embeds.shape, ode_prompt_raws)
+
+            # For Text
+            text_prompt_raws = batch["text_prompt_raws"]
+            text_prompt_embeds = batch["text_prompt_embeds"]
+            print(text_prompt_embeds.shape, text_prompt_raws)
+
+            if accelerator.process_index == 0:
+                # print info
+                print(f" Step {step}:")
+                print(f"  Batch {i}:")
+                print(f"  Batch size: {len(gan_uttid)}")
+                print(f"  Uttids: {gan_uttid}, {ode_uttid}, {text_uttid}")
+                print(
+                    f"  Data Name: {batch['gan_dataset_name']}, {batch['ode_dataset_name']}, {batch['text_dataset_name']}"
+                )
+
+            for dataset_name in batch["gan_dataset_name"]:
+                dataset_counts[dataset_name] += 1
+
+            step += 1
+
+    print("实际采样统计:", dict(dataset_counts))

Helios/_DEV/helios/dataset/dataloader_history_latents_dist.py

@@ -0,0 +1,685 @@
+import os
+import pickle
+import random
+from collections import defaultdict
+
+import torch
+from einops import rearrange
+from torch.utils.data import Dataset, Sampler
+
+
+class BucketedFeatureDataset(Dataset):
+    def __init__(
+        self,
+        feature_folders,
+        history_sizes=[16, 2, 1],
+        is_keep_x0=True,
+        force_rebuild=False,
+        return_all_vae_latent=False,
+        return_prompt_raw=False,
+        num_rollout_sections=3,
+        single_res=False,
+        single_height=384,
+        single_width=640,
+        seed=42,
+    ):
+        self.history_sizes = history_sizes
+        self.is_keep_x0 = is_keep_x0
+        self.force_rebuild = force_rebuild
+        self.return_all_vae_latent = return_all_vae_latent
+        self.return_prompt_raw = return_prompt_raw
+        self.num_rollout_sections = num_rollout_sections
+        self.single_res = single_res
+        self.single_height = single_height
+        self.single_width = single_width
+        assert self.is_keep_x0, "is_keep_x0 need to be True now!"
+
+        self.base_seed = seed
+        self._epoch = 0
+
+        if isinstance(feature_folders, str):
+            self.feature_folders = [feature_folders]
+        else:
+            self.feature_folders = feature_folders
+
+        self.samples = []
+        self.buckets = defaultdict(list)
+
+        for folder in self.feature_folders:
+            cache_file = os.path.join(folder, "dataset_cache.pkl")
+            self._process_folder(folder, cache_file)
+
+    def _process_folder(self, folder, cache_file):
+        if self.force_rebuild or not os.path.exists(cache_file):
+            print(f"Building metadata cache for folder: {folder}")
+            folder_samples, folder_buckets = self._build_folder_metadata(folder)
+
+            print(f"Saving metadata cache for folder: {folder}")
+            cached_data = {"samples": folder_samples, "buckets": folder_buckets}
+            if not self.force_rebuild:
+                with open(cache_file, "wb") as f:
+                    pickle.dump(cached_data, f)
+            print(f"Cached {len(folder_samples)} samples from {folder}\n")
+        else:
+            print(f"Loading cached metadata from: {folder}")
+            with open(cache_file, "rb") as f:
+                cached_data = pickle.load(f)
+            folder_samples = cached_data["samples"]
+            folder_buckets = cached_data["buckets"]
+            print(f"Loaded {len(folder_samples)} samples from cache: {folder}\n")
+
+        sample_idx_offset = len(self.samples)
+        self.samples.extend(folder_samples)
+
+        for bucket_key, indices in folder_buckets.items():
+            adjusted_indices = [idx + sample_idx_offset for idx in indices]
+            self.buckets[bucket_key].extend(adjusted_indices)
+
+    def _build_folder_metadata(self, folder):
+        feature_files = [f for f in os.listdir(folder) if f.endswith(".pt")]
+        samples = []
+        buckets = defaultdict(list)
+        sample_idx = 0
+
+        print(f"Processing {len(feature_files)} files in {folder}...")
+
+        for i, feature_file in enumerate(feature_files):
+            if i % 10000 == 0:
+                print(f"  Processed {i}/{len(feature_files)} files")
+
+            feature_path = os.path.join(folder, feature_file)
+
+            # Parse filename
+            parts = feature_file.split("_")
+            uttid = "_".join(parts[:-3])
+            num_frame = int(parts[-3])
+            height = int(parts[-2])
+            width = int(parts[-1].replace(".pt", ""))
+
+            # keep length >= 121
+            if num_frame < 121:
+                continue
+
+            # keep resolution
+            allowed_resolutions = [
+                (self.single_height, self.single_width),
+                (self.single_height // 2, self.single_width // 2),
+                (self.single_height // 4, self.single_width // 4),
+            ]
+            if self.single_res and (height, width) not in allowed_resolutions:
+                continue
+
+            bucket_key = (num_frame, height, width)
+
+            sample_info = {
+                "uttid": uttid,
+                "dataset_name": folder.rstrip("/"),
+                "file_path": feature_path,
+                "bucket_key": bucket_key,
+                "num_frame": num_frame,
+                "height": height,
+                "width": width,
+            }
+
+            samples.append(sample_info)
+            buckets[bucket_key].append(sample_idx)
+            sample_idx += 1
+
+        return samples, buckets
+
+    def set_epoch(self, epoch):
+        self._epoch = epoch
+
+    def prepare_stage1_latent(self, vae_latent, idx, base_vae_latent=None):
+        source_latent = base_vae_latent if base_vae_latent is not None else vae_latent
+
+        x0_latent = None
+        if self.is_keep_x0:
+            x0_latent = source_latent[0, :, :1, :, :].clone()
+        total_sections = source_latent.shape[0]
+        latent_window_size = source_latent.shape[2]
+        history_window_size = sum(self.history_sizes)
+        section_size = history_window_size + latent_window_size
+
+        temp_source_latent = rearrange(source_latent, "b c t h w -> c (b t) h w")
+        zero_padding_source = torch.zeros(
+            temp_source_latent.shape[0],
+            history_window_size,
+            temp_source_latent.shape[2],
+            temp_source_latent.shape[3],
+            device=temp_source_latent.device,
+            dtype=temp_source_latent.dtype,
+        )
+        continue_source_latent = torch.cat([zero_padding_source, temp_source_latent], dim=1)
+
+        temp_vae_latent = rearrange(vae_latent, "b c t h w -> c (b t) h w")
+        zero_padding_vae = torch.zeros(
+            temp_vae_latent.shape[0],
+            history_window_size,
+            temp_vae_latent.shape[2],
+            temp_vae_latent.shape[3],
+            device=temp_vae_latent.device,
+            dtype=temp_vae_latent.dtype,
+        )
+        continue_vae_latent = torch.cat([zero_padding_vae, temp_vae_latent], dim=1)
+
+        sample_seed = self.base_seed + self._epoch * 1000000 + idx
+        choice_idx = torch.randint(
+            0, total_sections, (1,), generator=torch.Generator().manual_seed(sample_seed)
+        ).item()
+        if choice_idx == 0 and x0_latent is not None:
+            x0_latent = torch.zeros_like(x0_latent)
+
+        clean_all_vae_latent = None
+        if self.return_all_vae_latent:
+            max_start_idx = total_sections - self.num_rollout_sections
+            if max_start_idx < 0:
+                raise ValueError(
+                    f"Not enough sections: total_sections={total_sections}, num_rollout_sections={self.num_rollout_sections}"
+                )
+            start_section_idx = random.randint(0, max_start_idx)
+            start_indice = start_section_idx * latent_window_size
+            end_indice = start_indice + history_window_size + self.num_rollout_sections * latent_window_size
+            clean_all_vae_latent = continue_source_latent[:, start_indice:end_indice, :, :]
+
+        start_indice = choice_idx * latent_window_size
+        end_indice = start_indice + section_size
+
+        history_latent = continue_source_latent[:, start_indice : start_indice + history_window_size, :, :]
+        target_latent = continue_vae_latent[:, start_indice + history_window_size : end_indice, :, :]
+
+        return x0_latent, history_latent, target_latent, clean_all_vae_latent
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        anchor_f = self.samples[idx]["num_frame"]
+        anchor_h = self.samples[idx]["height"]
+        anchor_w = self.samples[idx]["width"]
+        while True:
+            sample_info = self.samples[idx]
+
+            if (
+                anchor_f != sample_info["num_frame"]
+                or anchor_h != sample_info["height"]
+                or anchor_w != sample_info["width"]
+            ):
+                idx = random.randint(0, len(self.samples) - 1)
+                print("Try to find a same dim sample, retrying...")
+                continue
+
+            try:
+                base_vae_latent = None
+                if (anchor_h, anchor_w) in [
+                    (self.single_height // 2, self.single_width // 2),
+                    (self.single_height // 4, self.single_width // 4),
+                ]:
+                    base_file_path = (
+                        sample_info["file_path"]
+                        .replace("/mid", "")
+                        .replace("/low", "")
+                        .replace(
+                            f"{self.single_height // 2}_{self.single_width // 2}",
+                            f"{self.single_height}_{self.single_width}",
+                        )
+                        .replace(
+                            f"{self.single_height // 4}_{self.single_width // 4}",
+                            f"{self.single_height}_{self.single_width}",
+                        )
+                    )
+                    base_vae_latent = torch.load(base_file_path, map_location="cpu", weights_only=False)["vae_latent"]
+
+                feature_data = torch.load(sample_info["file_path"], map_location="cpu", weights_only=False)
+                x0_latent, history_latent, target_latent, clean_all_vae_latent = self.prepare_stage1_latent(
+                    feature_data["vae_latent"], idx, base_vae_latent
+                )
+                if self.return_prompt_raw:
+                    prompt_raws = feature_data["prompt_raw"]
+                break
+            except Exception:
+                idx = random.randint(0, len(self.samples) - 1)
+                print(f"Error loading {sample_info['file_path']}, retrying...")
+                file_name = os.path.basename(sample_info["file_path"])
+                txt_name = f"{file_name}.txt"
+                with open(txt_name, "w") as f:
+                    f.write(sample_info["file_path"] + "\n")
+
+        output_dict = {
+            "uttid": sample_info["uttid"],
+            "bucket_key": sample_info["bucket_key"],
+            "dataset_name": sample_info["dataset_name"],
+            "num_frame": sample_info["num_frame"],
+            "height": sample_info["height"],
+            "width": sample_info["width"],
+            "x0_latents": x0_latent,
+            "history_latents": history_latent,
+            "target_latents": target_latent,
+            "clean_all_latents": clean_all_vae_latent,
+            "prompt_embeds": feature_data["prompt_embed"],
+            "prompt_attention_masks": feature_data.get("prompt_attention_mask", None),
+        }
+
+        if self.return_prompt_raw:
+            output_dict["prompt_raws"] = prompt_raws
+
+        return output_dict
+
+
+class BucketedSampler(Sampler):
+    def __init__(
+        self,
+        dataset,
+        batch_size,
+        drop_last=False,
+        shuffle=True,
+        seed=42,
+        dataset_sampling_ratios=None,
+        num_sp_groups=1,
+        sp_world_size=1,
+        global_rank=0,
+    ):
+        self.dataset = dataset
+        self.batch_size = batch_size
+        self.drop_last = drop_last
+        self.shuffle = shuffle
+        self.seed = seed
+        self.generator = torch.Generator()
+        self.buckets = dataset.buckets
+        self._epoch = 0
+
+        # Distributed parameters
+        self.num_sp_groups = num_sp_groups
+        self.sp_world_size = sp_world_size
+        self.global_rank = global_rank
+        self.ith_sp_group = self.global_rank // self.sp_world_size
+
+        self.dataset_sampling_ratios = (
+            {key.rstrip("/"): value for key, value in dataset_sampling_ratios.items()}
+            if dataset_sampling_ratios is not None
+            else {}
+        )
+        self._prepare_dataset_buckets()
+
+    def _prepare_dataset_buckets(self):
+        self.dataset_buckets = {}
+
+        for bucket_key, sample_indices in self.buckets.items():
+            dataset_groups = {}
+            for idx in sample_indices:
+                dataset_name = self.dataset.samples[idx]["dataset_name"]
+                if dataset_name not in dataset_groups:
+                    dataset_groups[dataset_name] = []
+                dataset_groups[dataset_name].append(idx)
+            self.dataset_buckets[bucket_key] = dataset_groups
+
+    def set_epoch(self, epoch):
+        self._epoch = epoch
+
+    def _shard_indices_for_sp_group(self, indices):
+        """
+        Shard indices across SP groups, similar to DP_SP_BatchSampler.
+        Each SP group gets a disjoint subset of the data.
+        """
+        if self.num_sp_groups == 1:
+            return indices
+
+        # Convert to tensor if it's a list
+        if isinstance(indices, list):
+            indices_tensor = torch.tensor(indices, dtype=torch.long)
+        else:
+            indices_tensor = indices
+
+        # Pad indices if necessary to make it divisible by num_sp_groups
+        total_size = len(indices_tensor)
+        if total_size % self.num_sp_groups != 0:
+            if not self.drop_last:
+                padding_size = self.num_sp_groups - (total_size % self.num_sp_groups)
+                indices_tensor = torch.cat([indices_tensor, indices_tensor[:padding_size]])
+        else:
+            # If drop_last, truncate to be divisible
+            if self.drop_last:
+                truncate_size = (total_size // self.num_sp_groups) * self.num_sp_groups
+                indices_tensor = indices_tensor[:truncate_size]
+
+        # Shard: each SP group gets every num_sp_groups-th element
+        sp_group_indices = indices_tensor[self.ith_sp_group :: self.num_sp_groups]
+
+        return sp_group_indices.tolist()
+
+    def _apply_global_ratio_sampling(self):
+        if not self.dataset_sampling_ratios:
+            return
+
+        dataset_sample_map = {}
+        for bucket_key, dataset_groups in self.dataset_buckets.items():
+            for dataset_name, indices in dataset_groups.items():
+                if dataset_name not in dataset_sample_map:
+                    dataset_sample_map[dataset_name] = {"indices": [], "buckets": []}
+                dataset_sample_map[dataset_name]["indices"].extend(indices)
+                dataset_sample_map[dataset_name]["buckets"].extend([bucket_key] * len(indices))
+
+        total_samples = sum(len(info["indices"]) for info in dataset_sample_map.values())
+        total_ratio = sum(self.dataset_sampling_ratios.values())
+
+        sampled_dataset_map = {}
+        for dataset_name, info in dataset_sample_map.items():
+            if dataset_name in self.dataset_sampling_ratios:
+                ratio = self.dataset_sampling_ratios[dataset_name] / total_ratio
+                target_samples = max(1, int(total_samples * ratio))
+
+                indices = info["indices"]
+                buckets = info["buckets"]
+
+                if len(indices) >= target_samples:
+                    selected = torch.randperm(len(indices), generator=self.generator)[:target_samples].tolist()
+                    sampled_indices = [indices[i] for i in selected]
+                    sampled_buckets = [buckets[i] for i in selected]
+                else:
+                    sampled_indices = []
+                    sampled_buckets = []
+                    remaining = target_samples
+
+                    while remaining > 0:
+                        repeat_count = min(remaining, len(indices))
+                        selected = torch.randperm(len(indices), generator=self.generator)[:repeat_count].tolist()
+                        sampled_indices.extend([indices[i] for i in selected])
+                        sampled_buckets.extend([buckets[i] for i in selected])
+                        remaining -= repeat_count
+
+                sampled_dataset_map[dataset_name] = {"indices": sampled_indices, "buckets": sampled_buckets}
+            else:
+                sampled_dataset_map[dataset_name] = info
+
+        new_dataset_buckets = {}
+        for bucket_key in self.dataset_buckets.keys():
+            new_dataset_buckets[bucket_key] = {}
+
+        for dataset_name, info in sampled_dataset_map.items():
+            indices = info["indices"]
+            buckets = info["buckets"]
+
+            for idx, bucket_key in zip(indices, buckets):
+                if dataset_name not in new_dataset_buckets[bucket_key]:
+                    new_dataset_buckets[bucket_key][dataset_name] = []
+                new_dataset_buckets[bucket_key][dataset_name].append(idx)
+
+        self.dataset_buckets = new_dataset_buckets
+
+    def __iter__(self):
+        # Use epoch-level seed for reproducibility
+        epoch_seed = self.seed + self._epoch
+        self.generator.manual_seed(epoch_seed)
+
+        if self.dataset_sampling_ratios:
+            self._apply_global_ratio_sampling()
+
+        bucket_iterators = {}
+        bucket_batches = {}
+
+        for bucket_key, dataset_groups in self.dataset_buckets.items():
+            balanced_indices = self._create_balanced_indices(dataset_groups)
+
+            # Global shuffle before sharding (important for distributed consistency)
+            if self.shuffle:
+                perm = torch.randperm(len(balanced_indices), generator=self.generator).tolist()
+                balanced_indices = [balanced_indices[i] for i in perm]
+
+            # Shard indices for this SP group
+            sp_group_indices = self._shard_indices_for_sp_group(balanced_indices)
+
+            batches = []
+            for i in range(0, len(sp_group_indices), self.batch_size):
+                batch = sp_group_indices[i : i + self.batch_size]
+                if len(batch) == self.batch_size or not self.drop_last:
+                    batches.append(batch)
+
+            if batches:
+                bucket_batches[bucket_key] = batches
+                bucket_iterators[bucket_key] = iter(batches)
+
+        remaining_buckets = list(bucket_iterators.keys())
+
+        while remaining_buckets:
+            idx = torch.randint(len(remaining_buckets), (1,), generator=self.generator).item()
+            bucket_key = remaining_buckets[idx]
+            bucket_iter = bucket_iterators[bucket_key]
+
+            try:
+                batch = next(bucket_iter)
+                yield batch
+            except StopIteration:
+                remaining_buckets.remove(bucket_key)
+
+    def _create_balanced_indices(self, dataset_groups):
+        return sum(dataset_groups.values(), [])
+
+    def _equal_sampling(self, dataset_groups):
+        all_indices = []
+        dataset_names = list(dataset_groups.keys())
+
+        if len(dataset_names) <= 1:
+            return sum(dataset_groups.values(), [])
+
+        min_samples = min(len(indices) for indices in dataset_groups.values())
+
+        for dataset_name, indices in dataset_groups.items():
+            if len(indices) > min_samples:
+                selected = torch.randperm(len(indices), generator=self.generator)[:min_samples].tolist()
+                sampled_indices = [indices[i] for i in selected]
+            else:
+                sampled_indices = indices
+            all_indices.extend(sampled_indices)
+
+        return all_indices
+
+    def _ratio_sampling(self, dataset_groups):
+        return sum(dataset_groups.values(), [])
+
+    def __len__(self):
+        if self.dataset_sampling_ratios:
+            temp_generator = torch.Generator()
+            temp_generator.manual_seed(self.seed)
+
+            dataset_sample_map = {}
+            for bucket_key, dataset_groups in self.dataset_buckets.items():
+                for dataset_name, indices in dataset_groups.items():
+                    if dataset_name not in dataset_sample_map:
+                        dataset_sample_map[dataset_name] = []
+                    dataset_sample_map[dataset_name].extend(indices)
+
+            total_samples = sum(len(indices) for indices in dataset_sample_map.values())
+            total_ratio = sum(self.dataset_sampling_ratios.values())
+
+            sampled_total = 0
+            for dataset_name, indices in dataset_sample_map.items():
+                if dataset_name in self.dataset_sampling_ratios:
+                    ratio = self.dataset_sampling_ratios[dataset_name] / total_ratio
+                    target_samples = max(1, int(total_samples * ratio))
+                    sampled_total += target_samples
+                else:
+                    sampled_total += len(indices)
+
+            # Account for SP group sharding
+            sp_group_samples = sampled_total // self.num_sp_groups
+            if not self.drop_last and sampled_total % self.num_sp_groups != 0:
+                sp_group_samples += 1
+
+            total_batches = sp_group_samples // self.batch_size
+            if not self.drop_last and sp_group_samples % self.batch_size != 0:
+                total_batches += 1
+            return total_batches
+        else:
+            total_batches = 0
+            for bucket_key, dataset_groups in self.dataset_buckets.items():
+                balanced_indices = self._create_balanced_indices(dataset_groups)
+
+                # Account for SP group sharding
+                sp_group_size = len(balanced_indices) // self.num_sp_groups
+                if not self.drop_last and len(balanced_indices) % self.num_sp_groups != 0:
+                    sp_group_size += 1
+
+                num_batches = sp_group_size // self.batch_size
+                if not self.drop_last and sp_group_size % self.batch_size != 0:
+                    num_batches += 1
+                total_batches += num_batches
+            return total_batches
+
+
+def collate_fn(batch):
+    return {
+        key: torch.stack([d[key] for d in batch])
+        if isinstance(batch[0][key], torch.Tensor)
+        else [d[key] for d in batch]
+        for key in batch[0]
+    }
+
+
+if __name__ == "__main__":
+    import torch.distributed.checkpoint as dcp
+    from accelerate import Accelerator
+    from torchdata.stateful_dataloader import StatefulDataLoader
+
+    feature_folder = [
+        "demo_data/ultravideo-long",
+    ]
+    dataloader_num_workers = 0
+    batch_size = 2
+    num_train_epochs = 2
+    seed = 0
+    output_dir = "accelerate_checkpoints"
+    checkpoint_dirs = (
+        [
+            d
+            for d in os.listdir(output_dir)
+            if d.startswith("checkpoint-") and os.path.isdir(os.path.join(output_dir, d))
+        ]
+        if os.path.exists(output_dir)
+        else []
+    )
+
+    dataset_ratios = {}
+    # dataset_ratios = {
+    #     "demo_data/ultravideo-long": 0.9,
+    # }
+
+    accelerator = Accelerator()
+    print(accelerator.process_index, accelerator.num_processes)
+
+    dataset = BucketedFeatureDataset(
+        feature_folder,
+        force_rebuild=True,
+        return_all_vae_latent=True,
+        return_prompt_raw=True,
+        single_res=True,
+        single_height=384,
+        single_width=640,
+        seed=seed,
+    )
+    sampler = BucketedSampler(
+        dataset,
+        batch_size=batch_size,
+        drop_last=True,
+        shuffle=True,
+        dataset_sampling_ratios=dataset_ratios,
+        seed=seed,
+        # num_sp_groups=get_world_size() // get_sp_world_size(),
+        # sp_world_size=get_sp_world_size(),
+        # global_rank=get_world_rank(),
+        num_sp_groups=accelerator.num_processes // 1,
+        sp_world_size=1,
+        global_rank=accelerator.process_index,
+    )
+    dataloader = StatefulDataLoader(
+        dataset, batch_sampler=sampler, collate_fn=collate_fn, num_workers=dataloader_num_workers
+    )
+
+    print(len(dataset), len(dataloader))
+    print(f"Dataset size: {len(dataset)}, Dataloader batches: {len(dataloader)}")
+
+    step = 0
+    global_step = 0
+    first_epoch = 0
+    num_update_steps_per_epoch = len(dataloader)
+    if checkpoint_dirs:
+        latest_checkpoint = max(checkpoint_dirs, key=lambda x: int(x.split("-")[1]))
+        checkpoint_path = os.path.join(output_dir, latest_checkpoint)
+        print(f"Found checkpoint: {checkpoint_path}")
+
+        accelerator.load_state(checkpoint_path)
+        global_step = int(latest_checkpoint.split("-")[1])
+        first_epoch = global_step // num_update_steps_per_epoch
+
+        states = {
+            "dataloader": dataloader,
+        }
+        dcp_dir = os.path.join(checkpoint_path, "distributed_checkpoint")
+        dcp.load(states, checkpoint_id=dcp_dir)
+
+        print(f"Resuming from step {global_step}, epoch {first_epoch}")
+
+    print("Testing dataloader...")
+    step = global_step
+    dataset_counts = defaultdict(int)
+    for epoch in range(first_epoch, num_train_epochs):
+        sampler.set_epoch(epoch)
+        dataset.set_epoch(epoch)
+        for i, batch in enumerate(dataloader):
+            # Get metadata
+            uttid = batch["uttid"]
+            num_frame = batch["num_frame"]
+            height = batch["height"]
+            width = batch["width"]
+            bucket_key = batch["bucket_key"]
+
+            # Get feature
+            x0_latents = batch["x0_latents"]
+            history_latents = batch["history_latents"]
+            target_latents = batch["target_latents"]
+            prompt_embeds = batch["prompt_embeds"]
+
+            if accelerator.process_index == 0:
+                # print info
+                print(f" Step {step}:")
+                print(f"  Batch {i}:")
+                # print(f"  Data Name: {batch['dataset_name']}")
+                print(f"  Batch size: {len(uttid)}")
+                print(f"  Uttids: {uttid}")
+                print(f"  Dimensions - frames: {num_frame[0]}, height: {height[0]}, width: {width[0]}")
+                print(f"  Bucket key: {bucket_key[0]}")
+                print(f"  X0 latent shape: {x0_latents.shape}")
+                print(f"  History latent shape: {history_latents.shape}")
+                print(f"  Context latent shape: {target_latents.shape}")
+                print(f"  Prompt embed shape: {prompt_embeds.shape}")
+                # print(f"  Prompt attention mask shape: {prompt_attention_masks.shape}")
+
+                # verify
+                assert all(nf == num_frame[0] for nf in num_frame), "Frame numbers not consistent in batch"
+                assert all(h == height[0] for h in height), "Heights not consistent in batch"
+                assert all(w == width[0] for w in width), "Widths not consistent in batch"
+
+                print("  ✓ Batch dimensions are consistent")
+
+            for dataset_name in batch["dataset_name"]:
+                dataset_counts[dataset_name] += 1
+
+            step += 1
+
+            # if step == 20:
+            #     checkpoint_dir = f"checkpoint-{step}"
+            #     save_path = os.path.join(output_dir, checkpoint_dir)
+            #     os.makedirs(save_path, exist_ok=True)
+
+            #     if accelerator.is_main_process:
+            #         print(f"Saving checkpoint at step {step}")
+
+            #         accelerator.save_state(save_path)
+
+            #     print(accelerator.process_index, accelerator.num_processes)
+            #     states = {
+            #         "dataloader": dataloader,
+            #     }
+            #     dcp_dir = os.path.join(save_path, "distributed_checkpoint")
+            #     dcp.save(states, checkpoint_id=dcp_dir)
+
+    print("实际采样统计:", dict(dataset_counts))

Helios/_DEV/helios/dataset/dataloader_mp4_dist.py

@@ -0,0 +1,854 @@
+import json
+import os
+import pickle
+import random
+from collections import defaultdict
+from typing import Optional
+
+import pandas as pd
+import torch
+import torchvision
+from torch.utils.data import Dataset, Sampler
+from video_reader import PyVideoReader
+
+from diffusers.training_utils import free_memory
+from diffusers.utils import export_to_video
+
+
+resolution_bucket_options = {
+    640: [
+        (768, 320),
+        (768, 384),
+        (640, 384),
+        (768, 512),
+        (576, 448),
+        (512, 512),
+        (448, 576),
+        (512, 768),
+        (384, 640),
+        (384, 768),
+        (320, 768),
+    ],
+}
+
+length_bucket_options = {
+    1: [
+        501,
+        481,
+        461,
+        441,
+        421,
+        401,
+        381,
+        361,
+        341,
+        321,
+        301,
+        281,
+        261,
+        241,
+        221,
+        193,
+        181,
+        161,
+        141,
+        121,
+        101,
+        81,
+        61,
+        41,
+        21,
+    ],
+    2: [193, 177, 161, 156, 145, 133, 129, 121, 113, 109, 97, 85, 81, 73, 65, 61, 49, 37, 25],
+}
+
+
+def find_nearest_resolution_bucket(h, w, resolution=640):
+    min_metric = float("inf")
+    best_bucket = None
+    for bucket_h, bucket_w in resolution_bucket_options[resolution]:
+        metric = abs(h * bucket_w - w * bucket_h)
+        if metric <= min_metric:
+            min_metric = metric
+            best_bucket = (bucket_h, bucket_w)
+    return best_bucket
+
+
+def find_nearest_length_bucket(length, stride=1):
+    buckets = length_bucket_options[stride]
+    min_bucket = min(buckets)
+    if length < min_bucket:
+        return length
+    valid_buckets = [bucket for bucket in buckets if bucket <= length]
+    return max(valid_buckets)
+
+
+def read_cut_crop_and_resize(
+    video_path, f_prime, h_prime, w_prime, stride=1, start_frame=None, end_frame=None, crop=None
+):
+    frame_indices = list(range(start_frame, end_frame, stride))
+    assert len(frame_indices) == f_prime
+
+    vr = PyVideoReader(video_path, threads=0)  # 0 means auto (let ffmpeg pick the optimal number)
+    frames = torch.from_numpy(vr.get_batch(frame_indices)).float()
+
+    frames = (frames / 127.5) - 1
+    video = frames.permute(0, 3, 1, 2)
+
+    s_x, e_x, s_y, e_y = crop
+    video = video[:, :, s_y:e_y, s_x:e_x]
+
+    frames, channels, h, w = video.shape
+    aspect_ratio_original = h / w
+    aspect_ratio_target = h_prime / w_prime
+
+    if aspect_ratio_original >= aspect_ratio_target:
+        new_h = int(w * aspect_ratio_target)
+        top = (h - new_h) // 2
+        bottom = top + new_h
+        left = 0
+        right = w
+    else:
+        new_w = int(h / aspect_ratio_target)
+        left = (w - new_w) // 2
+        right = left + new_w
+        top = 0
+        bottom = h
+
+    # Crop the video
+    cropped_video = video[:, :, top:bottom, left:right]
+    # Resize the cropped video
+    resized_video = torchvision.transforms.functional.resize(cropped_video, (h_prime, w_prime))
+    return resized_video
+
+
+def save_frames(frame_raw, fps=24, video_path="1.mp4"):
+    save_list = []
+    for frame in frame_raw:
+        frame = (frame + 1) / 2 * 255
+        frame = torchvision.transforms.transforms.ToPILImage()(frame.to(torch.uint8)).convert("RGB")
+        save_list.append(frame)
+        frame = None
+        del frame
+    export_to_video(save_list, video_path, fps=fps)
+
+    save_list = None
+    del save_list
+    free_memory()
+
+
+class BucketedFeatureDataset(Dataset):
+    def __init__(
+        self,
+        json_files,
+        video_folders,
+        stride=1,
+        base_fps=None,
+        resolution=640,
+        force_rebuild=True,
+        single_res=False,
+        single_length=False,
+        single_num_frame=81,
+        single_height=384,
+        single_width=640,
+        multi_res=False,
+        id_token: Optional[str] = None,
+    ):
+        self.stride = stride
+        self.base_fps = base_fps
+        self.resolution = resolution
+        self.force_rebuild = force_rebuild
+        self.single_res = single_res
+        self.single_height = single_height
+        self.single_width = single_width
+        self.single_length = single_length
+        self.single_num_frame = single_num_frame
+        self.multi_res = multi_res
+        self.id_token = id_token or ""
+        self._epoch = 0
+
+        if isinstance(json_files, str):
+            self.json_files = [json_files]
+        else:
+            self.json_files = json_files
+
+        if isinstance(video_folders, str):
+            self.video_folders = [video_folders]
+        else:
+            self.video_folders = video_folders
+
+        assert len(self.json_files) == len(self.video_folders), (
+            f"json_files ({len(self.json_files)}) and video_folders ({len(self.video_folders)}) must have the same length"
+        )
+
+        self.samples = []
+        self.buckets = defaultdict(list)
+
+        for json_file, video_folder in zip(self.json_files, self.video_folders):
+            cache_file = json_file.replace(".json", "_cache.pkl").replace(".csv", "_cache.pkl")
+            self._process_json_file(json_file, video_folder, cache_file)
+
+    def _process_json_file(self, json_file, video_folder, cache_file):
+        if self.force_rebuild or not os.path.exists(cache_file):
+            if os.path.exists(cache_file):
+                print(f"Remove {cache_file}")
+                os.remove(cache_file)
+            print(f"Building metadata cache for file: {json_file}")
+            print(f"  Video folder: {video_folder}")
+            file_samples, file_buckets = self._build_file_metadata(json_file, video_folder)
+
+            print(f"Saving metadata cache to: {cache_file}")
+            cached_data = {"samples": file_samples, "buckets": file_buckets}
+            with open(cache_file, "wb") as f:
+                pickle.dump(cached_data, f)
+            print(f"Cached {len(file_samples)} samples from {json_file}\n")
+        else:
+            print(f"Loading cached metadata from: {cache_file}")
+            with open(cache_file, "rb") as f:
+                cached_data = pickle.load(f)
+            file_samples = cached_data["samples"]
+            file_buckets = cached_data["buckets"]
+            print(f"Loaded {len(file_samples)} samples from cache: {cache_file}\n")
+
+        sample_idx_offset = len(self.samples)
+        self.samples.extend(file_samples)
+
+        for bucket_key, indices in file_buckets.items():
+            adjusted_indices = [idx + sample_idx_offset for idx in indices]
+            self.buckets[bucket_key].extend(adjusted_indices)
+
+    def _build_file_metadata(self, json_file, video_folder):
+        with open(json_file, "r") as f:
+            data = json.load(f)
+
+        print(f"Scanning video folder: {video_folder}")
+        existing_videos = set()
+        for root, dirs, files in os.walk(video_folder):
+            for file in files:
+                if file.endswith(".mp4"):
+                    rel_path = os.path.relpath(os.path.join(root, file), video_folder)
+                    existing_videos.add(rel_path)
+        print(f"Found {len(existing_videos)} video files")
+
+        df = pd.DataFrame(
+            [
+                {
+                    "cut": item["cut"],
+                    "crop": item["crop"],
+                    "path": item["path"],
+                    "num_frames": item["num_frames"],
+                    "width": item["resolution"]["width"],
+                    "height": item["resolution"]["height"],
+                    "fps": item["fps"],
+                    "cap": item["cap"],
+                }
+                for item in data
+            ]
+        )
+
+        samples = []
+        buckets = defaultdict(list)
+        sample_idx = 0
+
+        print(f"Processing {len(df)} records from {json_file} with stride={self.stride}...")
+        for i, row in df.iterrows():
+            if i % 10000 == 0:
+                print(f"  Processed {i}/{len(df)} records")
+
+            video_file = (
+                row["path"]
+                .replace("videos_clip_v1_20241111/", "")
+                .replace("videos_clip_v2_20241111/", "")
+                .replace("videos_clip_v4_20241111/", "")
+            )
+            if video_file not in existing_videos:
+                print("bad video!")
+                continue
+            video_path = os.path.join(video_folder, video_file)
+
+            cut_start_frame = row["cut"][0]
+            cut_end_frame = row["cut"][1]
+            num_frame = cut_end_frame - cut_start_frame
+
+            if self.single_length:
+                if num_frame < self.single_num_frame:
+                    continue
+            else:
+                if num_frame < 121:
+                    continue
+
+            uttid = os.path.basename(video_file).replace(".mp4", "") + f"_{cut_start_frame}-{cut_end_frame}"
+            fps = row["fps"]
+
+            crop = row["crop"]
+            width = crop[1] - crop[0]
+            height = crop[3] - crop[2]
+
+            prompt = row["cap"][0]
+
+            # TODO need to be checked
+            effective_num_frame = (num_frame + self.stride - 1) // self.stride
+            bucket_num_frame = find_nearest_length_bucket(effective_num_frame, stride=self.stride)
+            bucket_height, bucket_width = find_nearest_resolution_bucket(height, width, resolution=self.resolution)
+
+            if self.single_res or self.multi_res:
+                allowed_resolutions = [(self.single_height, self.single_width)]
+                if self.multi_res:
+                    allowed_resolutions.extend(
+                        [
+                            (self.single_height // 2, self.single_width // 2),
+                            (self.single_height // 4, self.single_width // 4),
+                        ]
+                    )
+                if (bucket_height, bucket_width) not in allowed_resolutions:
+                    print("continue res")
+                    continue
+                bucket_height, bucket_width = random.choice(allowed_resolutions)
+
+            if self.single_length:
+                bucket_num_frame = self.single_num_frame
+
+            if self.base_fps is not None:
+                stride = max(int(fps / self.base_fps), 1)
+                required_frames = bucket_num_frame * stride
+                if required_frames >= num_frame:
+                    print("continue frame")
+                    continue
+            else:
+                stride = self.stride
+
+            bucket_key = (bucket_num_frame, bucket_height, bucket_width)
+
+            sample_info = {
+                "uttid": uttid,
+                "dataset_name": json_file.rstrip("/"),
+                "video_folder": video_folder,
+                "video_path": video_path,
+                "bucket_key": bucket_key,
+                "prompt": self.id_token + prompt,
+                "fps": fps,
+                "stride": stride,
+                "effective_num_frame": effective_num_frame,
+                "num_frame": num_frame,
+                "height": height,
+                "width": width,
+                "bucket_num_frame": bucket_num_frame,
+                "bucket_height": bucket_height,
+                "bucket_width": bucket_width,
+                "cut_start_frame": cut_start_frame,
+                "cut_end_frame": cut_end_frame,
+                "crop": crop,
+            }
+
+            samples.append(sample_info)
+            buckets[bucket_key].append(sample_idx)
+            sample_idx += 1
+
+        return samples, buckets
+
+    def set_epoch(self, epoch):
+        self._epoch = epoch
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        anchor_h = self.samples[idx]["bucket_height"]
+        anchor_w = self.samples[idx]["bucket_width"]
+        anchor_f = self.samples[idx]["bucket_num_frame"]
+
+        max_retries = 1000
+        retry_count = 0
+
+        while retry_count < max_retries:
+            sample_info = self.samples[idx]
+
+            if (
+                anchor_h != sample_info["bucket_height"]
+                or anchor_w != sample_info["bucket_width"]
+                or anchor_f != sample_info["bucket_num_frame"]
+            ):
+                idx = random.randint(0, len(self.samples) - 1)
+                retry_count += 1
+                continue
+
+            try:
+                stride = sample_info["stride"]
+                cut_start_frame = sample_info["cut_start_frame"]
+                cut_end_frame = sample_info["cut_end_frame"]
+                bucket_num_frame = sample_info["bucket_num_frame"]
+
+                max_start_frame = cut_end_frame - bucket_num_frame * stride
+                if max_start_frame < cut_start_frame:
+                    start_frame = cut_start_frame
+                else:
+                    start_frame = random.randint(cut_start_frame, max_start_frame)
+                end_frame = start_frame + bucket_num_frame * stride
+
+                video_data = read_cut_crop_and_resize(
+                    video_path=sample_info["video_path"],
+                    f_prime=sample_info["bucket_num_frame"],
+                    h_prime=sample_info["bucket_height"],
+                    w_prime=sample_info["bucket_width"],
+                    stride=stride,
+                    start_frame=start_frame,
+                    end_frame=end_frame,
+                    crop=sample_info["crop"],
+                )
+
+                return {
+                    "uttid": sample_info["uttid"],
+                    "bucket_key": sample_info["bucket_key"],
+                    "dataset_name": sample_info["dataset_name"],
+                    "video_metadata": {
+                        "num_frames": sample_info["bucket_num_frame"],
+                        "height": sample_info["bucket_height"],
+                        "width": sample_info["bucket_width"],
+                        "fps": sample_info["fps"],
+                        "stride": stride,
+                        "effective_num_frame": sample_info["effective_num_frame"],
+                    },
+                    "videos": video_data,
+                    "prompts": sample_info["prompt"],
+                    "first_frames_images": (video_data[0] + 1) / 2 * 255,
+                }
+            except Exception as e:
+                print(f"Error loading {sample_info['video_path']}: {e}")
+                idx = random.randint(0, len(self.samples) - 1)
+                retry_count += 1
+
+        print(f"Failed to load sample after {max_retries} retries, returning None")
+        return None
+
+
+class BucketedSampler(Sampler):
+    def __init__(
+        self,
+        dataset,
+        batch_size,
+        drop_last=False,
+        shuffle=True,
+        seed=42,
+        dataset_sampling_ratios=None,
+        num_sp_groups=1,
+        sp_world_size=1,
+        global_rank=0,
+    ):
+        self.dataset = dataset
+        self.batch_size = batch_size
+        self.drop_last = drop_last
+        self.shuffle = shuffle
+        self.seed = seed
+        self.generator = torch.Generator()
+        self.buckets = dataset.buckets
+        self._epoch = 0
+
+        # Distributed parameters
+        self.num_sp_groups = num_sp_groups
+        self.sp_world_size = sp_world_size
+        self.global_rank = global_rank
+        self.ith_sp_group = self.global_rank // self.sp_world_size
+
+        self.dataset_sampling_ratios = (
+            {key.rstrip("/"): value for key, value in dataset_sampling_ratios.items()}
+            if dataset_sampling_ratios is not None
+            else {}
+        )
+        self._prepare_dataset_buckets()
+
+    def _prepare_dataset_buckets(self):
+        self.dataset_buckets = {}
+
+        for bucket_key, sample_indices in self.buckets.items():
+            dataset_groups = {}
+            for idx in sample_indices:
+                dataset_name = self.dataset.samples[idx]["dataset_name"]
+                if dataset_name not in dataset_groups:
+                    dataset_groups[dataset_name] = []
+                dataset_groups[dataset_name].append(idx)
+            self.dataset_buckets[bucket_key] = dataset_groups
+
+    def set_epoch(self, epoch):
+        self._epoch = epoch
+
+    def _shard_indices_for_sp_group(self, indices):
+        """
+        Shard indices across SP groups, similar to DP_SP_BatchSampler.
+        Each SP group gets a disjoint subset of the data.
+        """
+        if self.num_sp_groups == 1:
+            return indices
+
+        # Convert to tensor if it's a list
+        if isinstance(indices, list):
+            indices_tensor = torch.tensor(indices, dtype=torch.long)
+        else:
+            indices_tensor = indices
+
+        # Pad indices if necessary to make it divisible by num_sp_groups
+        total_size = len(indices_tensor)
+        if total_size % self.num_sp_groups != 0:
+            if not self.drop_last:
+                padding_size = self.num_sp_groups - (total_size % self.num_sp_groups)
+                indices_tensor = torch.cat([indices_tensor, indices_tensor[:padding_size]])
+        else:
+            # If drop_last, truncate to be divisible
+            if self.drop_last:
+                truncate_size = (total_size // self.num_sp_groups) * self.num_sp_groups
+                indices_tensor = indices_tensor[:truncate_size]
+
+        # Shard: each SP group gets every num_sp_groups-th element
+        sp_group_indices = indices_tensor[self.ith_sp_group :: self.num_sp_groups]
+
+        return sp_group_indices.tolist()
+
+    def _apply_global_ratio_sampling(self):
+        if not self.dataset_sampling_ratios:
+            return
+
+        dataset_sample_map = {}
+        for bucket_key, dataset_groups in self.dataset_buckets.items():
+            for dataset_name, indices in dataset_groups.items():
+                if dataset_name not in dataset_sample_map:
+                    dataset_sample_map[dataset_name] = {"indices": [], "buckets": []}
+                dataset_sample_map[dataset_name]["indices"].extend(indices)
+                dataset_sample_map[dataset_name]["buckets"].extend([bucket_key] * len(indices))
+
+        total_samples = sum(len(info["indices"]) for info in dataset_sample_map.values())
+        total_ratio = sum(self.dataset_sampling_ratios.values())
+
+        sampled_dataset_map = {}
+        for dataset_name, info in dataset_sample_map.items():
+            if dataset_name in self.dataset_sampling_ratios:
+                ratio = self.dataset_sampling_ratios[dataset_name] / total_ratio
+                target_samples = max(1, int(total_samples * ratio))
+
+                indices = info["indices"]
+                buckets = info["buckets"]
+
+                if len(indices) >= target_samples:
+                    selected = torch.randperm(len(indices), generator=self.generator)[:target_samples].tolist()
+                    sampled_indices = [indices[i] for i in selected]
+                    sampled_buckets = [buckets[i] for i in selected]
+                else:
+                    sampled_indices = []
+                    sampled_buckets = []
+                    remaining = target_samples
+
+                    while remaining > 0:
+                        repeat_count = min(remaining, len(indices))
+                        selected = torch.randperm(len(indices), generator=self.generator)[:repeat_count].tolist()
+                        sampled_indices.extend([indices[i] for i in selected])
+                        sampled_buckets.extend([buckets[i] for i in selected])
+                        remaining -= repeat_count
+
+                sampled_dataset_map[dataset_name] = {"indices": sampled_indices, "buckets": sampled_buckets}
+            else:
+                sampled_dataset_map[dataset_name] = info
+
+        new_dataset_buckets = {}
+        for bucket_key in self.dataset_buckets.keys():
+            new_dataset_buckets[bucket_key] = {}
+
+        for dataset_name, info in sampled_dataset_map.items():
+            indices = info["indices"]
+            buckets = info["buckets"]
+
+            for idx, bucket_key in zip(indices, buckets):
+                if dataset_name not in new_dataset_buckets[bucket_key]:
+                    new_dataset_buckets[bucket_key][dataset_name] = []
+                new_dataset_buckets[bucket_key][dataset_name].append(idx)
+
+        self.dataset_buckets = new_dataset_buckets
+
+    def __iter__(self):
+        # Use epoch-level seed for reproducibility
+        epoch_seed = self.seed + self._epoch
+        self.generator.manual_seed(epoch_seed)
+
+        if self.dataset_sampling_ratios:
+            self._apply_global_ratio_sampling()
+
+        bucket_iterators = {}
+        bucket_batches = {}
+
+        for bucket_key, dataset_groups in self.dataset_buckets.items():
+            balanced_indices = self._create_balanced_indices(dataset_groups)
+
+            # Global shuffle before sharding (important for distributed consistency)
+            if self.shuffle:
+                perm = torch.randperm(len(balanced_indices), generator=self.generator).tolist()
+                balanced_indices = [balanced_indices[i] for i in perm]
+
+            # Shard indices for this SP group
+            sp_group_indices = self._shard_indices_for_sp_group(balanced_indices)
+
+            batches = []
+            for i in range(0, len(sp_group_indices), self.batch_size):
+                batch = sp_group_indices[i : i + self.batch_size]
+                if len(batch) == self.batch_size or not self.drop_last:
+                    batches.append(batch)
+
+            if batches:
+                bucket_batches[bucket_key] = batches
+                bucket_iterators[bucket_key] = iter(batches)
+
+        remaining_buckets = list(bucket_iterators.keys())
+
+        while remaining_buckets:
+            idx = torch.randint(len(remaining_buckets), (1,), generator=self.generator).item()
+            bucket_key = remaining_buckets[idx]
+            bucket_iter = bucket_iterators[bucket_key]
+
+            try:
+                batch = next(bucket_iter)
+                yield batch
+            except StopIteration:
+                remaining_buckets.remove(bucket_key)
+
+    def _create_balanced_indices(self, dataset_groups):
+        return sum(dataset_groups.values(), [])
+
+    def _equal_sampling(self, dataset_groups):
+        all_indices = []
+        dataset_names = list(dataset_groups.keys())
+
+        if len(dataset_names) <= 1:
+            return sum(dataset_groups.values(), [])
+
+        min_samples = min(len(indices) for indices in dataset_groups.values())
+
+        for dataset_name, indices in dataset_groups.items():
+            if len(indices) > min_samples:
+                selected = torch.randperm(len(indices), generator=self.generator)[:min_samples].tolist()
+                sampled_indices = [indices[i] for i in selected]
+            else:
+                sampled_indices = indices
+            all_indices.extend(sampled_indices)
+
+        return all_indices
+
+    def _ratio_sampling(self, dataset_groups):
+        return sum(dataset_groups.values(), [])
+
+    def __len__(self):
+        if self.dataset_sampling_ratios:
+            temp_generator = torch.Generator()
+            temp_generator.manual_seed(self.seed)
+
+            dataset_sample_map = {}
+            for bucket_key, dataset_groups in self.dataset_buckets.items():
+                for dataset_name, indices in dataset_groups.items():
+                    if dataset_name not in dataset_sample_map:
+                        dataset_sample_map[dataset_name] = []
+                    dataset_sample_map[dataset_name].extend(indices)
+
+            total_samples = sum(len(indices) for indices in dataset_sample_map.values())
+            total_ratio = sum(self.dataset_sampling_ratios.values())
+
+            sampled_total = 0
+            for dataset_name, indices in dataset_sample_map.items():
+                if dataset_name in self.dataset_sampling_ratios:
+                    ratio = self.dataset_sampling_ratios[dataset_name] / total_ratio
+                    target_samples = max(1, int(total_samples * ratio))
+                    sampled_total += target_samples
+                else:
+                    sampled_total += len(indices)
+
+            # Account for SP group sharding
+            sp_group_samples = sampled_total // self.num_sp_groups
+            if not self.drop_last and sampled_total % self.num_sp_groups != 0:
+                sp_group_samples += 1
+
+            total_batches = sp_group_samples // self.batch_size
+            if not self.drop_last and sp_group_samples % self.batch_size != 0:
+                total_batches += 1
+            return total_batches
+        else:
+            total_batches = 0
+            for bucket_key, dataset_groups in self.dataset_buckets.items():
+                balanced_indices = self._create_balanced_indices(dataset_groups)
+
+                # Account for SP group sharding
+                sp_group_size = len(balanced_indices) // self.num_sp_groups
+                if not self.drop_last and len(balanced_indices) % self.num_sp_groups != 0:
+                    sp_group_size += 1
+
+                num_batches = sp_group_size // self.batch_size
+                if not self.drop_last and sp_group_size % self.batch_size != 0:
+                    num_batches += 1
+                total_batches += num_batches
+            return total_batches
+
+
+def collate_fn(batch):
+    batch = [item for item in batch if item is not None]
+
+    if len(batch) == 0:
+        return None
+
+    def collate_dict(data_list):
+        if isinstance(data_list[0], dict):
+            return {key: collate_dict([d[key] for d in data_list]) for key in data_list[0]}
+        elif isinstance(data_list[0], torch.Tensor):
+            return torch.stack(data_list)
+        else:
+            return data_list
+
+    return {key: collate_dict([d[key] for d in batch]) for key in batch[0]}
+
+
+if __name__ == "__main__":
+    import torch.distributed.checkpoint as dcp
+    from accelerate import Accelerator
+    from torchdata.stateful_dataloader import StatefulDataLoader
+
+    json_file = [
+        "opensoraplan/jsons/video_mixkit_513f_1997.json",
+    ]
+    video_folder = [
+        "opensoraplan/videos",
+    ]
+    stride = 1
+    batch_size = 2
+    num_train_epochs = 1
+    seed = 0
+    num_workers = 8
+    output_dir = "accelerate_checkpoints"
+    checkpoint_dirs = (
+        [
+            d
+            for d in os.listdir(output_dir)
+            if d.startswith("checkpoint-") and os.path.isdir(os.path.join(output_dir, d))
+        ]
+        if os.path.exists(output_dir)
+        else []
+    )
+
+    dataset_ratios = {}
+    # dataset_ratios = {
+    #     "/mnt/hdfs/data/ysh_new/userful_things_wan/open-sora-plan-istock/istock_v4/latents": 0.9,
+    #     "/mnt/hdfs/data/ysh_new/userful_things_wan/sekai/sekai-real-walking-hq-193/latents_stride1": 0.1
+    # }
+
+    accelerator = Accelerator()
+    print(accelerator.process_index, accelerator.num_processes)
+
+    dataset = BucketedFeatureDataset(
+        json_files=json_file,
+        video_folders=video_folder,
+        stride=stride,
+        force_rebuild=False,
+        resolution=640,
+        single_res=True,
+        single_height=384,
+        single_width=640,
+        single_length=True,
+        single_num_frame=81,
+        multi_res=True,
+    )
+    sampler = BucketedSampler(
+        dataset,
+        batch_size=batch_size,
+        drop_last=True,
+        shuffle=False,
+        dataset_sampling_ratios=dataset_ratios,
+        seed=seed,
+        # num_sp_groups=get_world_size() // get_sp_world_size(),
+        # sp_world_size=get_sp_world_size(),
+        # global_rank=get_world_rank(),
+        num_sp_groups=accelerator.num_processes // 1,
+        sp_world_size=1,
+        global_rank=accelerator.process_index,
+    )
+    dataloader = StatefulDataLoader(dataset, batch_sampler=sampler, collate_fn=collate_fn, num_workers=num_workers)
+
+    print(len(dataset), len(dataloader))
+    print(f"Dataset size: {len(dataset)}, Dataloader batches: {len(dataloader)}")
+
+    step = 0
+    global_step = 0
+    first_epoch = 0
+    num_update_steps_per_epoch = len(dataloader)
+    if checkpoint_dirs:
+        latest_checkpoint = max(checkpoint_dirs, key=lambda x: int(x.split("-")[1]))
+        checkpoint_path = os.path.join(output_dir, latest_checkpoint)
+        print(f"Found checkpoint: {checkpoint_path}")
+
+        accelerator.load_state(checkpoint_path)
+        global_step = int(latest_checkpoint.split("-")[1])
+        first_epoch = global_step // num_update_steps_per_epoch
+
+        states = {
+            "dataloader": dataloader,
+        }
+        dcp_dir = os.path.join(checkpoint_path, "distributed_checkpoint")
+        dcp.load(states, checkpoint_id=dcp_dir)
+
+        print(f"Resuming from step {global_step}, epoch {first_epoch}")
+
+    print("Testing dataloader...")
+    step = global_step
+    dataset_counts = defaultdict(int)
+    for epoch in range(first_epoch, num_train_epochs):
+        sampler.set_epoch(epoch)
+        dataset.set_epoch(epoch)
+        for i, batch in enumerate(dataloader):
+            # Get metadata
+            uttid = batch["uttid"]
+            bucket_key = batch["bucket_key"]
+            num_frame = batch["video_metadata"]["num_frames"]
+            height = batch["video_metadata"]["height"]
+            width = batch["video_metadata"]["width"]
+
+            # Get feature
+            video_data = batch["videos"]
+            prompt = batch["prompts"]
+            first_frames_images = batch["first_frames_images"]
+            first_frames_images = [torchvision.transforms.ToPILImage()(x.to(torch.uint8)) for x in first_frames_images]
+
+            # save_frames(video_data[0].squeeze(0), video_path="1.mp4")
+            # import pdb;pdb.set_trace()
+
+            if accelerator.process_index == 0:
+                # print info
+                print(f" Step {step}:")
+                print(f"  Batch {i}:")
+                # print(f"  Data Name: {batch['dataset_name']}")
+                print(f"  Batch size: {len(uttid)}")
+                print(f"  Uttids: {uttid}")
+                print(f"  Dimensions - frames: {num_frame[0]}, height: {height[0]}, width: {width[0]}")
+                print(f"  Bucket key: {bucket_key[0]}")
+                print(f"  Videos shape: {video_data.shape}")
+                print(f"  Cpation: {prompt}")
+
+                # verify
+                assert all(nf == num_frame[0] for nf in num_frame), "Frame numbers not consistent in batch"
+                assert all(h == height[0] for h in height), "Heights not consistent in batch"
+                assert all(w == width[0] for w in width), "Widths not consistent in batch"
+
+                print("  ✓ Batch dimensions are consistent")
+
+            for dataset_name in batch["dataset_name"]:
+                dataset_counts[dataset_name] += 1
+
+            step += 1
+
+            # if step == 20:
+            #     checkpoint_dir = f"checkpoint-{step}"
+            #     save_path = os.path.join(output_dir, checkpoint_dir)
+            #     os.makedirs(save_path, exist_ok=True)
+
+            #     if accelerator.is_main_process:
+            #         print(f"Saving checkpoint at step {step}")
+
+            #         accelerator.save_state(save_path)
+
+            #     print(accelerator.process_index, accelerator.num_processes)
+            #     states = {
+            #         "dataloader": dataloader,
+            #     }
+            #     dcp_dir = os.path.join(save_path, "distributed_checkpoint")
+            #     dcp.save(states, checkpoint_id=dcp_dir)
+
+    print("实际采样统计:", dict(dataset_counts))

Helios/_DEV/helios/diffusers_version/pipeline_helios_diffusers.py

@@ -0,0 +1,1406 @@
+# Copyright 2025 The Helios Team and The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import html
+import math
+from itertools import accumulate
+from typing import Any, Callable
+
+import numpy as np
+import regex as re
+import torch
+import torch.nn.functional as F
+from transformers import AutoTokenizer, UMT5EncoderModel
+
+from diffusers.callbacks import MultiPipelineCallbacks, PipelineCallback
+from diffusers.image_processor import PipelineImageInput
+from diffusers.loaders import HeliosLoraLoaderMixin
+from diffusers.models import AutoencoderKLWan, HeliosTransformer3DModel
+from diffusers.pipelines.pipeline_utils import DiffusionPipeline
+from diffusers.schedulers import HeliosScheduler
+from diffusers.utils import is_ftfy_available, is_torch_xla_available, logging, replace_example_docstring
+from diffusers.utils.torch_utils import randn_tensor
+from diffusers.video_processor import VideoProcessor
+
+from ..pipelines.pipeline_output import HeliosPipelineOutput
+
+
+if is_torch_xla_available():
+    import torch_xla.core.xla_model as xm
+
+    XLA_AVAILABLE = True
+else:
+    XLA_AVAILABLE = False
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+if is_ftfy_available():
+    import ftfy
+
+
+EXAMPLE_DOC_STRING = """
+    Examples:
+        ```python
+        >>> import torch
+        >>> from diffusers.utils import export_to_video
+        >>> from diffusers import AutoencoderKLWan, HeliosPipeline
+
+        >>> # Available models: BestWishYsh/Helios-Base, BestWishYsh/Helios-Mid, BestWishYsh/Helios-Distilled
+        >>> model_id = "BestWishYsh/Helios-Base"
+        >>> vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", torch_dtype=torch.float32)
+        >>> pipe = HeliosPipeline.from_pretrained(model_id, vae=vae, torch_dtype=torch.bfloat16)
+        >>> pipe.to("cuda")
+
+        >>> prompt = "A cat and a dog baking a cake together in a kitchen. The cat is carefully measuring flour, while the dog is stirring the batter with a wooden spoon. The kitchen is cozy, with sunlight streaming through the window."
+        >>> negative_prompt = "Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards"
+
+        >>> output = pipe(
+        ...     prompt=prompt,
+        ...     negative_prompt=negative_prompt,
+        ...     height=384,
+        ...     width=640,
+        ...     num_frames=132,
+        ...     guidance_scale=5.0,
+        ... ).frames[0]
+        >>> export_to_video(output, "output.mp4", fps=24)
+        ```
+"""
+
+
+def optimized_scale(positive_flat, negative_flat):
+    positive_flat = positive_flat.float()
+    negative_flat = negative_flat.float()
+    # Calculate dot production
+    dot_product = torch.sum(positive_flat * negative_flat, dim=1, keepdim=True)
+    # Squared norm of uncondition
+    squared_norm = torch.sum(negative_flat**2, dim=1, keepdim=True) + 1e-8
+    # st_star = v_cond^T * v_uncond / ||v_uncond||^2
+    st_star = dot_product / squared_norm
+    return st_star
+
+
+def basic_clean(text):
+    text = ftfy.fix_text(text)
+    text = html.unescape(html.unescape(text))
+    return text.strip()
+
+
+def whitespace_clean(text):
+    text = re.sub(r"\s+", " ", text)
+    text = text.strip()
+    return text
+
+
+def prompt_clean(text):
+    text = whitespace_clean(basic_clean(text))
+    return text
+
+
+# Copied from diffusers.pipelines.flux.pipeline_flux.calculate_shift
+def calculate_shift(
+    image_seq_len,
+    base_seq_len: int = 256,
+    max_seq_len: int = 4096,
+    base_shift: float = 0.5,
+    max_shift: float = 1.15,
+):
+    m = (max_shift - base_shift) / (max_seq_len - base_seq_len)
+    b = base_shift - m * base_seq_len
+    mu = image_seq_len * m + b
+    return mu
+
+
+class HeliosPipeline(DiffusionPipeline, HeliosLoraLoaderMixin):
+    r"""
+    Pipeline for text-to-video / image-to-video / video-to-video generation using Helios.
+
+    This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods
+    implemented for all pipelines (downloading, saving, running on a particular device, etc.).
+
+    Args:
+        tokenizer ([`T5Tokenizer`]):
+            Tokenizer from [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer),
+            specifically the [google/umt5-xxl](https://huggingface.co/google/umt5-xxl) variant.
+        text_encoder ([`T5EncoderModel`]):
+            [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), specifically
+            the [google/umt5-xxl](https://huggingface.co/google/umt5-xxl) variant.
+        transformer ([`HeliosTransformer3DModel`]):
+            Conditional Transformer to denoise the input latents.
+        scheduler ([`HeliosScheduler`]):
+            A scheduler to be used in combination with `transformer` to denoise the encoded image latents.
+        vae ([`AutoencoderKLWan`]):
+            Variational Auto-Encoder (VAE) Model to encode and decode videos to and from latent representations.
+    """
+
+    model_cpu_offload_seq = "text_encoder->transformer->vae"
+    _callback_tensor_inputs = ["latents", "prompt_embeds", "negative_prompt_embeds"]
+    _optional_components = ["transformer"]
+
+    def __init__(
+        self,
+        tokenizer: AutoTokenizer,
+        text_encoder: UMT5EncoderModel,
+        vae: AutoencoderKLWan,
+        scheduler: HeliosScheduler,
+        transformer: HeliosTransformer3DModel,
+        is_cfg_zero_star: bool = False,
+        is_distilled: bool = False,
+    ):
+        super().__init__()
+
+        self.register_modules(
+            vae=vae,
+            text_encoder=text_encoder,
+            tokenizer=tokenizer,
+            transformer=transformer,
+            scheduler=scheduler,
+        )
+        self.register_to_config(is_cfg_zero_star=is_cfg_zero_star)
+        self.register_to_config(is_distilled=is_distilled)
+        self.vae_scale_factor_temporal = self.vae.config.scale_factor_temporal if getattr(self, "vae", None) else 4
+        self.vae_scale_factor_spatial = self.vae.config.scale_factor_spatial if getattr(self, "vae", None) else 8
+        self.video_processor = VideoProcessor(vae_scale_factor=self.vae_scale_factor_spatial)
+
+    def _get_t5_prompt_embeds(
+        self,
+        prompt: str | list[str] = None,
+        num_videos_per_prompt: int = 1,
+        max_sequence_length: int = 226,
+        device: torch.device | None = None,
+        dtype: torch.dtype | None = None,
+    ):
+        device = device or self._execution_device
+        dtype = dtype or self.text_encoder.dtype
+
+        prompt = [prompt] if isinstance(prompt, str) else prompt
+        prompt = [prompt_clean(u) for u in prompt]
+        batch_size = len(prompt)
+
+        text_inputs = self.tokenizer(
+            prompt,
+            padding="max_length",
+            max_length=max_sequence_length,
+            truncation=True,
+            add_special_tokens=True,
+            return_attention_mask=True,
+            return_tensors="pt",
+        )
+        text_input_ids, mask = text_inputs.input_ids, text_inputs.attention_mask
+        seq_lens = mask.gt(0).sum(dim=1).long()
+
+        prompt_embeds = self.text_encoder(text_input_ids.to(device), mask.to(device)).last_hidden_state
+        prompt_embeds = prompt_embeds.to(dtype=dtype, device=device)
+        prompt_embeds = [u[:v] for u, v in zip(prompt_embeds, seq_lens)]
+        prompt_embeds = torch.stack(
+            [torch.cat([u, u.new_zeros(max_sequence_length - u.size(0), u.size(1))]) for u in prompt_embeds], dim=0
+        )
+
+        # duplicate text embeddings for each generation per prompt, using mps friendly method
+        _, seq_len, _ = prompt_embeds.shape
+        prompt_embeds = prompt_embeds.repeat(1, num_videos_per_prompt, 1)
+        prompt_embeds = prompt_embeds.view(batch_size * num_videos_per_prompt, seq_len, -1)
+
+        return prompt_embeds, text_inputs.attention_mask.bool()
+
+    def encode_prompt(
+        self,
+        prompt: str | list[str],
+        negative_prompt: str | list[str] | None = None,
+        do_classifier_free_guidance: bool = True,
+        num_videos_per_prompt: int = 1,
+        prompt_embeds: torch.Tensor | None = None,
+        negative_prompt_embeds: torch.Tensor | None = None,
+        max_sequence_length: int = 226,
+        device: torch.device | None = None,
+        dtype: torch.dtype | None = None,
+    ):
+        r"""
+        Encodes the prompt into text encoder hidden states.
+
+        Args:
+            prompt (`str` or `list[str]`, *optional*):
+                prompt to be encoded
+            negative_prompt (`str` or `list[str]`, *optional*):
+                The prompt or prompts not to guide the image generation. If not defined, one has to pass
+                `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is
+                less than `1`).
+            do_classifier_free_guidance (`bool`, *optional*, defaults to `True`):
+                Whether to use classifier free guidance or not.
+            num_videos_per_prompt (`int`, *optional*, defaults to 1):
+                Number of videos that should be generated per prompt. torch device to place the resulting embeddings on
+            prompt_embeds (`torch.Tensor`, *optional*):
+                Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not
+                provided, text embeddings will be generated from `prompt` input argument.
+            negative_prompt_embeds (`torch.Tensor`, *optional*):
+                Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt
+                weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input
+                argument.
+            device: (`torch.device`, *optional*):
+                torch device
+            dtype: (`torch.dtype`, *optional*):
+                torch dtype
+        """
+        device = device or self._execution_device
+
+        prompt = [prompt] if isinstance(prompt, str) else prompt
+        if prompt is not None:
+            batch_size = len(prompt)
+        else:
+            batch_size = prompt_embeds.shape[0]
+
+        if prompt_embeds is None:
+            prompt_embeds, _ = self._get_t5_prompt_embeds(
+                prompt=prompt,
+                num_videos_per_prompt=num_videos_per_prompt,
+                max_sequence_length=max_sequence_length,
+                device=device,
+                dtype=dtype,
+            )
+
+        if do_classifier_free_guidance and negative_prompt_embeds is None:
+            negative_prompt = negative_prompt or ""
+            negative_prompt = batch_size * [negative_prompt] if isinstance(negative_prompt, str) else negative_prompt
+
+            if prompt is not None and type(prompt) is not type(negative_prompt):
+                raise TypeError(
+                    f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
+                    f" {type(prompt)}."
+                )
+            elif batch_size != len(negative_prompt):
+                raise ValueError(
+                    f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
+                    f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
+                    " the batch size of `prompt`."
+                )
+
+            negative_prompt_embeds, _ = self._get_t5_prompt_embeds(
+                prompt=negative_prompt,
+                num_videos_per_prompt=num_videos_per_prompt,
+                max_sequence_length=max_sequence_length,
+                device=device,
+                dtype=dtype,
+            )
+
+        return prompt_embeds, negative_prompt_embeds
+
+    def check_inputs(
+        self,
+        prompt,
+        negative_prompt,
+        height,
+        width,
+        prompt_embeds=None,
+        negative_prompt_embeds=None,
+        callback_on_step_end_tensor_inputs=None,
+        image=None,
+        video=None,
+        use_interpolate_prompt=False,
+        num_videos_per_prompt=None,
+        interpolate_time_list=None,
+        interpolation_steps=None,
+        guidance_scale=None,
+    ):
+        if height % 16 != 0 or width % 16 != 0:
+            raise ValueError(f"`height` and `width` have to be divisible by 16 but are {height} and {width}.")
+
+        if callback_on_step_end_tensor_inputs is not None and not all(
+            k in self._callback_tensor_inputs for k in callback_on_step_end_tensor_inputs
+        ):
+            raise ValueError(
+                f"`callback_on_step_end_tensor_inputs` has to be in {self._callback_tensor_inputs}, but found {[k for k in callback_on_step_end_tensor_inputs if k not in self._callback_tensor_inputs]}"
+            )
+
+        if prompt is not None and prompt_embeds is not None:
+            raise ValueError(
+                f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to"
+                " only forward one of the two."
+            )
+        elif negative_prompt is not None and negative_prompt_embeds is not None:
+            raise ValueError(
+                f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`: {negative_prompt_embeds}. Please make sure to"
+                " only forward one of the two."
+            )
+        elif prompt is None and prompt_embeds is None:
+            raise ValueError(
+                "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined."
+            )
+        elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)):
+            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
+        elif negative_prompt is not None and (
+            not isinstance(negative_prompt, str) and not isinstance(negative_prompt, list)
+        ):
+            raise ValueError(f"`negative_prompt` has to be of type `str` or `list` but is {type(negative_prompt)}")
+
+        if image is not None and video is not None:
+            raise ValueError("image and video cannot be provided simultaneously")
+
+        if use_interpolate_prompt:
+            assert num_videos_per_prompt == 1, f"num_videos_per_prompt must be 1, got {num_videos_per_prompt}"
+            assert isinstance(prompt, list), "prompt must be a list"
+            assert len(prompt) == len(interpolate_time_list), (
+                f"Length mismatch: {len(prompt)} vs {len(interpolate_time_list)}"
+            )
+            assert min(interpolate_time_list) > interpolation_steps, (
+                f"Minimum value {min(interpolate_time_list)} must be greater than {interpolation_steps}"
+            )
+
+        if guidance_scale > 1.0 and self.config.is_distilled:
+            logger.warning(f"Guidance scale {guidance_scale} is ignored for step-wise distilled models.")
+
+    def prepare_latents(
+        self,
+        batch_size: int,
+        num_channels_latents: int = 16,
+        height: int = 384,
+        width: int = 640,
+        num_frames: int = 33,
+        dtype: torch.dtype | None = None,
+        device: torch.device | None = None,
+        generator: torch.Generator | list[torch.Generator] | None = None,
+        latents: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        if latents is not None:
+            return latents.to(device=device, dtype=dtype)
+
+        num_latent_frames = (num_frames - 1) // self.vae_scale_factor_temporal + 1
+        shape = (
+            batch_size,
+            num_channels_latents,
+            num_latent_frames,
+            int(height) // self.vae_scale_factor_spatial,
+            int(width) // self.vae_scale_factor_spatial,
+        )
+        if isinstance(generator, list) and len(generator) != batch_size:
+            raise ValueError(
+                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
+                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
+            )
+
+        latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
+        return latents
+
+    def prepare_image_latents(
+        self,
+        image: torch.Tensor,
+        latents_mean: torch.Tensor,
+        latents_std: torch.Tensor,
+        num_latent_frames_per_chunk: int,
+        dtype: torch.dtype | None = None,
+        device: torch.device | None = None,
+        generator: torch.Generator | list[torch.Generator] | None = None,
+        latents: torch.Tensor | None = None,
+        fake_latents: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        device = device or self._execution_device
+        if latents is None:
+            image = image.unsqueeze(2).to(device=device, dtype=self.vae.dtype)
+            latents = self.vae.encode(image).latent_dist.sample(generator=generator)
+            latents = (latents - latents_mean) * latents_std
+        if fake_latents is None:
+            min_frames = (num_latent_frames_per_chunk - 1) * self.vae_scale_factor_temporal + 1
+            fake_video = image.repeat(1, 1, min_frames, 1, 1).to(device=device, dtype=self.vae.dtype)
+            fake_latents_full = self.vae.encode(fake_video).latent_dist.sample(generator=generator)
+            fake_latents_full = (fake_latents_full - latents_mean) * latents_std
+            fake_latents = fake_latents_full[:, :, -1:, :, :]
+        return latents.to(device=device, dtype=dtype), fake_latents.to(device=device, dtype=dtype)
+
+    def prepare_video_latents(
+        self,
+        video: torch.Tensor,
+        latents_mean: torch.Tensor,
+        latents_std: torch.Tensor,
+        num_latent_frames_per_chunk: int,
+        dtype: torch.dtype | None = None,
+        device: torch.device | None = None,
+        generator: torch.Generator | list[torch.Generator] | None = None,
+        latents: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        device = device or self._execution_device
+        video = video.to(device=device, dtype=self.vae.dtype)
+        if latents is None:
+            num_frames = video.shape[2]
+            min_frames = (num_latent_frames_per_chunk - 1) * self.vae_scale_factor_temporal + 1
+            num_chunks = num_frames // min_frames
+            if num_chunks == 0:
+                raise ValueError(
+                    f"Video must have at least {min_frames} frames "
+                    f"(got {num_frames} frames). "
+                    f"Required: (num_latent_frames_per_chunk - 1) * {self.vae_scale_factor_temporal} + 1 = ({num_latent_frames_per_chunk} - 1) * {self.vae_scale_factor_temporal} + 1 = {min_frames}"
+                )
+            total_valid_frames = num_chunks * min_frames
+            start_frame = num_frames - total_valid_frames
+
+            first_frame = video[:, :, 0:1, :, :]
+            first_frame_latent = self.vae.encode(first_frame).latent_dist.sample(generator=generator)
+            first_frame_latent = (first_frame_latent - latents_mean) * latents_std
+
+            latents_chunks = []
+            for i in range(num_chunks):
+                chunk_start = start_frame + i * min_frames
+                chunk_end = chunk_start + min_frames
+                video_chunk = video[:, :, chunk_start:chunk_end, :, :]
+                chunk_latents = self.vae.encode(video_chunk).latent_dist.sample(generator=generator)
+                chunk_latents = (chunk_latents - latents_mean) * latents_std
+                latents_chunks.append(chunk_latents)
+            latents = torch.cat(latents_chunks, dim=2)
+        return first_frame_latent.to(device=device, dtype=dtype), latents.to(device=device, dtype=dtype)
+
+    def interpolate_prompt_embeds(
+        self,
+        prompt_embeds_1: torch.Tensor,
+        prompt_embeds_2: torch.Tensor,
+        interpolation_steps: int = 3,
+    ):
+        x = torch.lerp(
+            prompt_embeds_1,
+            prompt_embeds_2,
+            torch.linspace(0, 1, steps=interpolation_steps).unsqueeze(1).unsqueeze(2).to(prompt_embeds_1),
+        )
+        interpolated_prompt_embeds = list(x.chunk(interpolation_steps, dim=0))
+        return interpolated_prompt_embeds
+
+    def sample_block_noise(
+        self,
+        batch_size,
+        channel,
+        num_frames,
+        height,
+        width,
+        patch_size: tuple[int, ...] = (1, 2, 2),
+        device: torch.device | None = None,
+        generator: torch.Generator | None = None,
+    ):
+        # NOTE: A generator must be provided to ensure correct and reproducible results.
+        # Creating a default generator here is a fallback only — without a fixed seed,
+        # the output will be non-deterministic and may produce incorrect results in CP context.
+        if generator is None:
+            generator = torch.Generator(device=device)
+        elif isinstance(generator, list):
+            generator = generator[0]
+
+        gamma = self.scheduler.config.gamma
+        _, ph, pw = patch_size
+        block_size = ph * pw
+
+        cov = (
+            torch.eye(block_size, device=device) * (1 + gamma)
+            - torch.ones(block_size, block_size, device=device) * gamma
+        )
+        cov += torch.eye(block_size, device=device) * 1e-8
+        cov = cov.float()  # Upcast to fp32 for numerical stability — cholesky is unreliable in fp16/bf16.
+
+        L = torch.linalg.cholesky(cov)
+        block_number = batch_size * channel * num_frames * (height // ph) * (width // pw)
+        z = torch.randn(block_number, block_size, generator=generator, device=generator.device).to(device=device)
+        noise = z @ L.T
+
+        noise = noise.view(batch_size, channel, num_frames, height // ph, width // pw, ph, pw)
+        noise = noise.permute(0, 1, 2, 3, 5, 4, 6).reshape(batch_size, channel, num_frames, height, width)
+
+        return noise
+
+    def record_relative_l1(
+        self,
+        records: list[dict[str, float | int]] | None,
+        chunk_index: int,
+        stage_index: int | None,
+        step_index: int,
+        timestep: torch.Tensor,
+        latents_t: torch.Tensor,
+        latents_t_minus_1: torch.Tensor,
+    ):
+        if records is None:
+            return
+
+        latents_t = latents_t.detach().float()
+        latents_t_minus_1 = latents_t_minus_1.detach().float()
+        delta_abs = (latents_t_minus_1 - latents_t).abs()
+        latents_abs = latents_t.abs()
+        relative_l1 = (delta_abs / latents_abs.clamp_min(1e-8)).mean()
+        relative_l1_ratio = delta_abs.mean() / latents_abs.mean().clamp_min(1e-8)
+        timestep_value = timestep.detach().float().mean().item() if torch.is_tensor(timestep) else float(timestep)
+
+        records.append(
+            {
+                "chunk_index": int(chunk_index),
+                "stage_index": -1 if stage_index is None else int(stage_index),
+                "step_index": int(step_index),
+                "timestep": float(timestep_value),
+                "relative_l1": float(relative_l1.item()),
+                "relative_l1_ratio": float(relative_l1_ratio.item()),
+            }
+        )
+
+    def stage1_sample(
+        self,
+        latents: torch.Tensor = None,
+        prompt_embeds: torch.Tensor = None,
+        negative_prompt_embeds: torch.Tensor = None,
+        timesteps: torch.Tensor = None,
+        guidance_scale: float | None = 5.0,
+        indices_hidden_states: torch.Tensor = None,
+        indices_latents_history_short: torch.Tensor = None,
+        indices_latents_history_mid: torch.Tensor = None,
+        indices_latents_history_long: torch.Tensor = None,
+        latents_history_short: torch.Tensor = None,
+        latents_history_mid: torch.Tensor = None,
+        latents_history_long: torch.Tensor = None,
+        attention_kwargs: dict | None = None,
+        device: torch.device | None = None,
+        transformer_dtype: torch.dtype = None,
+        generator: torch.Generator | None = None,
+        num_warmup_steps: int | None = None,
+        # ------------ CFG Zero ------------
+        use_zero_init: bool | None = True,
+        zero_steps: int | None = 1,
+        # ------------ Callback ------------
+        callback_on_step_end: Callable[[int, int], None] | PipelineCallback | MultiPipelineCallbacks | None = None,
+        callback_on_step_end_tensor_inputs: list[str] = ["latents"],
+        progress_bar=None,
+        chunk_index: int = 0,
+        relative_l1_records: list[dict[str, float | int]] | None = None,
+    ):
+        batch_size = latents.shape[0]
+
+        for i, t in enumerate(timesteps):
+            if self.interrupt:
+                continue
+
+            self._current_timestep = t
+            timestep = t.expand(latents.shape[0])
+
+            latent_model_input = latents.to(transformer_dtype)
+            with self.transformer.cache_context("cond"):
+                noise_pred = self.transformer(
+                    hidden_states=latent_model_input,
+                    timestep=timestep,
+                    encoder_hidden_states=prompt_embeds,
+                    indices_hidden_states=indices_hidden_states,
+                    indices_latents_history_short=indices_latents_history_short,
+                    indices_latents_history_mid=indices_latents_history_mid,
+                    indices_latents_history_long=indices_latents_history_long,
+                    latents_history_short=latents_history_short.to(transformer_dtype),
+                    latents_history_mid=latents_history_mid.to(transformer_dtype),
+                    latents_history_long=latents_history_long.to(transformer_dtype),
+                    attention_kwargs=attention_kwargs,
+                    return_dict=False,
+                )[0]
+
+            if self.do_classifier_free_guidance:
+                with self.transformer.cache_context("uncond"):
+                    noise_uncond = self.transformer(
+                        hidden_states=latent_model_input,
+                        timestep=timestep,
+                        encoder_hidden_states=negative_prompt_embeds,
+                        indices_hidden_states=indices_hidden_states,
+                        indices_latents_history_short=indices_latents_history_short,
+                        indices_latents_history_mid=indices_latents_history_mid,
+                        indices_latents_history_long=indices_latents_history_long,
+                        latents_history_short=latents_history_short.to(transformer_dtype),
+                        latents_history_mid=latents_history_mid.to(transformer_dtype),
+                        latents_history_long=latents_history_long.to(transformer_dtype),
+                        attention_kwargs=attention_kwargs,
+                        return_dict=False,
+                    )[0]
+
+                if self.config.is_cfg_zero_star:
+                    noise_pred_text = noise_pred
+                    positive_flat = noise_pred_text.view(batch_size, -1)
+                    negative_flat = noise_uncond.view(batch_size, -1)
+
+                    alpha = optimized_scale(positive_flat, negative_flat)
+                    alpha = alpha.view(batch_size, *([1] * (len(noise_pred_text.shape) - 1)))
+                    alpha = alpha.to(noise_pred_text.dtype)
+
+                    if (i <= zero_steps) and use_zero_init:
+                        noise_pred = noise_pred_text * 0.0
+                    else:
+                        noise_pred = noise_uncond * alpha + guidance_scale * (noise_pred_text - noise_uncond * alpha)
+                else:
+                    noise_pred = noise_uncond + guidance_scale * (noise_pred - noise_uncond)
+
+            latents_t = latents
+            latents = self.scheduler.step(
+                noise_pred,
+                t,
+                latents,
+                return_dict=False,
+            )[0]
+            self.record_relative_l1(relative_l1_records, chunk_index, None, i, t, latents_t, latents)
+
+            if callback_on_step_end is not None:
+                callback_kwargs = {}
+                for k in callback_on_step_end_tensor_inputs:
+                    callback_kwargs[k] = locals()[k]
+                callback_outputs = callback_on_step_end(self, i, t, callback_kwargs)
+
+                latents = callback_outputs.pop("latents", latents)
+                prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds)
+                negative_prompt_embeds = callback_outputs.pop("negative_prompt_embeds", negative_prompt_embeds)
+
+            if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
+                progress_bar.update()
+
+            if XLA_AVAILABLE:
+                xm.mark_step()
+
+        return latents
+
+    def stage2_sample(
+        self,
+        latents: torch.Tensor = None,
+        pyramid_num_stages: int = None,
+        pyramid_num_inference_steps_list: list[int] = None,
+        prompt_embeds: torch.Tensor = None,
+        negative_prompt_embeds: torch.Tensor = None,
+        guidance_scale: float | None = 5.0,
+        indices_hidden_states: torch.Tensor = None,
+        indices_latents_history_short: torch.Tensor = None,
+        indices_latents_history_mid: torch.Tensor = None,
+        indices_latents_history_long: torch.Tensor = None,
+        latents_history_short: torch.Tensor = None,
+        latents_history_mid: torch.Tensor = None,
+        latents_history_long: torch.Tensor = None,
+        attention_kwargs: dict | None = None,
+        device: torch.device | None = None,
+        transformer_dtype: torch.dtype = None,
+        generator: torch.Generator | None = None,
+        # ------------ CFG Zero ------------
+        use_zero_init: bool | None = True,
+        zero_steps: int | None = 1,
+        # -------------- DMD --------------
+        is_amplify_first_chunk: bool = False,
+        # ------------ Callback ------------
+        callback_on_step_end: Callable[[int, int], None] | PipelineCallback | MultiPipelineCallbacks | None = None,
+        callback_on_step_end_tensor_inputs: list[str] = ["latents"],
+        progress_bar=None,
+        chunk_index: int = 0,
+        relative_l1_records: list[dict[str, float | int]] | None = None,
+    ):
+        batch_size, num_channel, num_frames, height, width = latents.shape
+        latents = latents.permute(0, 2, 1, 3, 4).reshape(batch_size * num_frames, num_channel, height, width)
+        for _ in range(pyramid_num_stages - 1):
+            height //= 2
+            width //= 2
+            latents = (
+                F.interpolate(
+                    latents,
+                    size=(height, width),
+                    mode="bilinear",
+                )
+                * 2
+            )
+        latents = latents.reshape(batch_size, num_frames, num_channel, height, width).permute(0, 2, 1, 3, 4)
+
+        batch_size = latents.shape[0]
+        start_point_list = None
+        if self.config.is_distilled:
+            start_point_list = [latents]
+
+        i = 0
+        for i_s in range(pyramid_num_stages):
+            patch_size = self.transformer.config.patch_size
+            image_seq_len = (latents.shape[-1] * latents.shape[-2] * latents.shape[-3]) // (
+                patch_size[0] * patch_size[1] * patch_size[2]
+            )
+            mu = calculate_shift(
+                image_seq_len,
+                self.scheduler.config.get("base_image_seq_len", 256),
+                self.scheduler.config.get("max_image_seq_len", 4096),
+                self.scheduler.config.get("base_shift", 0.5),
+                self.scheduler.config.get("max_shift", 1.15),
+            )
+            self.scheduler.set_timesteps(
+                pyramid_num_inference_steps_list[i_s],
+                i_s,
+                device=device,
+                mu=mu,
+                is_amplify_first_chunk=is_amplify_first_chunk,
+            )
+            timesteps = self.scheduler.timesteps
+
+            if i_s > 0:
+                height *= 2
+                width *= 2
+                num_frames = latents.shape[2]
+                latents = latents.permute(0, 2, 1, 3, 4).reshape(
+                    batch_size * num_frames, num_channel, height // 2, width // 2
+                )
+                latents = F.interpolate(latents, size=(height, width), mode="nearest")
+                latents = latents.reshape(batch_size, num_frames, num_channel, height, width).permute(0, 2, 1, 3, 4)
+                # Fix the stage
+                ori_sigma = 1 - self.scheduler.ori_start_sigmas[i_s]  # the original coeff of signal
+                gamma = self.scheduler.config.gamma
+                alpha = 1 / (math.sqrt(1 + (1 / gamma)) * (1 - ori_sigma) + ori_sigma)
+                beta = alpha * (1 - ori_sigma) / math.sqrt(gamma)
+
+                batch_size, channel, num_frames, height, width = latents.shape
+                noise = self.sample_block_noise(
+                    batch_size, channel, num_frames, height, width, patch_size, device, generator
+                )
+                noise = noise.to(device=device, dtype=transformer_dtype)
+                latents = alpha * latents + beta * noise  # To fix the block artifact
+
+                if self.config.is_distilled:
+                    start_point_list.append(latents)
+
+            for idx, t in enumerate(timesteps):
+                timestep = t.expand(latents.shape[0]).to(torch.int64)
+
+                with self.transformer.cache_context("cond"):
+                    noise_pred = self.transformer(
+                        hidden_states=latents.to(transformer_dtype),
+                        timestep=timestep,
+                        encoder_hidden_states=prompt_embeds,
+                        attention_kwargs=attention_kwargs,
+                        return_dict=False,
+                        indices_hidden_states=indices_hidden_states,
+                        indices_latents_history_short=indices_latents_history_short,
+                        indices_latents_history_mid=indices_latents_history_mid,
+                        indices_latents_history_long=indices_latents_history_long,
+                        latents_history_short=latents_history_short.to(transformer_dtype),
+                        latents_history_mid=latents_history_mid.to(transformer_dtype),
+                        latents_history_long=latents_history_long.to(transformer_dtype),
+                    )[0]
+
+                if self.do_classifier_free_guidance:
+                    with self.transformer.cache_context("uncond"):
+                        noise_uncond = self.transformer(
+                            hidden_states=latents.to(transformer_dtype),
+                            timestep=timestep,
+                            encoder_hidden_states=negative_prompt_embeds,
+                            attention_kwargs=attention_kwargs,
+                            return_dict=False,
+                            indices_hidden_states=indices_hidden_states,
+                            indices_latents_history_short=indices_latents_history_short,
+                            indices_latents_history_mid=indices_latents_history_mid,
+                            indices_latents_history_long=indices_latents_history_long,
+                            latents_history_short=latents_history_short.to(transformer_dtype),
+                            latents_history_mid=latents_history_mid.to(transformer_dtype),
+                            latents_history_long=latents_history_long.to(transformer_dtype),
+                        )[0]
+
+                    if self.config.is_cfg_zero_star:
+                        noise_pred_text = noise_pred
+                        positive_flat = noise_pred_text.view(batch_size, -1)
+                        negative_flat = noise_uncond.view(batch_size, -1)
+
+                        alpha = optimized_scale(positive_flat, negative_flat)
+                        alpha = alpha.view(batch_size, *([1] * (len(noise_pred_text.shape) - 1)))
+                        alpha = alpha.to(noise_pred_text.dtype)
+
+                        if (i_s == 0 and idx <= zero_steps) and use_zero_init:
+                            noise_pred = noise_pred_text * 0.0
+                        else:
+                            noise_pred = noise_uncond * alpha + guidance_scale * (
+                                noise_pred_text - noise_uncond * alpha
+                            )
+                    else:
+                        noise_pred = noise_uncond + guidance_scale * (noise_pred - noise_uncond)
+
+                latents_t = latents
+                latents = self.scheduler.step(
+                    noise_pred,
+                    t,
+                    latents,
+                    generator=generator,
+                    return_dict=False,
+                    cur_sampling_step=idx,
+                    dmd_noisy_tensor=start_point_list[i_s] if start_point_list is not None else None,
+                    dmd_sigmas=self.scheduler.sigmas,
+                    dmd_timesteps=self.scheduler.timesteps,
+                    all_timesteps=timesteps,
+                )[0]
+                self.record_relative_l1(relative_l1_records, chunk_index, i_s, i, t, latents_t, latents)
+
+                if callback_on_step_end is not None:
+                    callback_kwargs = {}
+                    for k in callback_on_step_end_tensor_inputs:
+                        callback_kwargs[k] = locals()[k]
+                    callback_outputs = callback_on_step_end(self, i, t, callback_kwargs)
+
+                    latents = callback_outputs.pop("latents", latents)
+                    prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds)
+                    negative_prompt_embeds = callback_outputs.pop("negative_prompt_embeds", negative_prompt_embeds)
+
+                progress_bar.update()
+
+                if XLA_AVAILABLE:
+                    xm.mark_step()
+
+                i += 1
+
+        return latents
+
+    @property
+    def guidance_scale(self):
+        return self._guidance_scale
+
+    @property
+    def do_classifier_free_guidance(self):
+        return self._guidance_scale > 1.0
+
+    @property
+    def num_timesteps(self):
+        return self._num_timesteps
+
+    @property
+    def current_timestep(self):
+        return self._current_timestep
+
+    @property
+    def interrupt(self):
+        return self._interrupt
+
+    @property
+    def attention_kwargs(self):
+        return self._attention_kwargs
+
+    @torch.no_grad()
+    @replace_example_docstring(EXAMPLE_DOC_STRING)
+    def __call__(
+        self,
+        prompt: str | list[str] = None,
+        negative_prompt: str | list[str] = None,
+        height: int = 384,
+        width: int = 640,
+        num_frames: int = 132,
+        num_inference_steps: int = 50,
+        sigmas: list[float] = None,
+        guidance_scale: float = 5.0,
+        num_videos_per_prompt: int | None = 1,
+        generator: torch.Generator | list[torch.Generator] | None = None,
+        latents: torch.Tensor | None = None,
+        prompt_embeds: torch.Tensor | None = None,
+        negative_prompt_embeds: torch.Tensor | None = None,
+        output_type: str | None = "np",
+        return_dict: bool = True,
+        attention_kwargs: dict[str, Any] | None = None,
+        callback_on_step_end: Callable[[int, int], None] | PipelineCallback | MultiPipelineCallbacks | None = None,
+        callback_on_step_end_tensor_inputs: list[str] = ["latents"],
+        max_sequence_length: int = 512,
+        # ------------ I2V ------------
+        image: PipelineImageInput | None = None,
+        image_latents: torch.Tensor | None = None,
+        fake_image_latents: torch.Tensor | None = None,
+        add_noise_to_image_latents: bool = True,
+        image_noise_sigma_min: float = 0.111,
+        image_noise_sigma_max: float = 0.135,
+        # ------------ V2V ------------
+        video: PipelineImageInput | None = None,
+        video_latents: torch.Tensor | None = None,
+        add_noise_to_video_latents: bool = True,
+        video_noise_sigma_min: float = 0.111,
+        video_noise_sigma_max: float = 0.135,
+        # ------------ Interactive ------------
+        use_interpolate_prompt: bool = False,
+        interpolate_time_list: list = [7, 7, 7],
+        interpolation_steps: int = 3,
+        # ------------ Stage 1 ------------
+        history_sizes: list = [16, 2, 1],
+        num_latent_frames_per_chunk: int = 9,
+        keep_first_frame: bool = True,
+        is_skip_first_chunk: bool = False,
+        # ------------ Stage 2 ------------
+        is_enable_stage2: bool = False,
+        pyramid_num_stages: int = 3,
+        pyramid_num_inference_steps_list: list = [10, 10, 10],
+        # ------------ CFG Zero ------------
+        use_zero_init: bool | None = True,
+        zero_steps: int | None = 1,
+        # ------------ DMD ------------
+        is_amplify_first_chunk: bool = False,
+        # ------------ Debug ------------
+        output_relative_l1: bool = False,
+    ):
+        r"""
+        The call function to the pipeline for generation.
+
+        Args:
+            prompt (`str` or `list[str]`, *optional*):
+                The prompt or prompts to guide the image generation. If not defined, pass `prompt_embeds` instead.
+            negative_prompt (`str` or `list[str]`, *optional*):
+                The prompt or prompts to avoid during image generation. If not defined, pass `negative_prompt_embeds`
+                instead. Ignored when not using guidance (`guidance_scale` < `1`).
+            height (`int`, defaults to `384`):
+                The height in pixels of the generated image.
+            width (`int`, defaults to `640`):
+                The width in pixels of the generated image.
+            num_frames (`int`, defaults to `132`):
+                The number of frames in the generated video.
+            num_inference_steps (`int`, defaults to `50`):
+                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
+                expense of slower inference.
+            guidance_scale (`float`, defaults to `5.0`):
+                Guidance scale as defined in [Classifier-Free Diffusion
+                Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` is defined as `w` of equation 2.
+                of [Imagen Paper](https://huggingface.co/papers/2205.11487). Guidance scale is enabled by setting
+                `guidance_scale > 1`. Higher guidance scale encourages to generate images that are closely linked to
+                the text `prompt`, usually at the expense of lower image quality.
+            num_videos_per_prompt (`int`, *optional*, defaults to 1):
+                The number of images to generate per prompt.
+            generator (`torch.Generator` or `list[torch.Generator]`, *optional*):
+                A [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make
+                generation deterministic.
+            latents (`torch.Tensor`, *optional*):
+                Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for image
+                generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
+                tensor is generated by sampling using the supplied random `generator`.
+            prompt_embeds (`torch.Tensor`, *optional*):
+                Pre-generated text embeddings. Can be used to easily tweak text inputs (prompt weighting). If not
+                provided, text embeddings are generated from the `prompt` input argument.
+            output_type (`str`, *optional*, defaults to `"np"`):
+                The output format of the generated image. Choose between `PIL.Image` or `np.array`.
+            return_dict (`bool`, *optional*, defaults to `True`):
+                Whether or not to return a [`HeliosPipelineOutput`] instead of a plain tuple.
+            attention_kwargs (`dict`, *optional*):
+                A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under
+                `self.processor` in
+                [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
+            callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *optional*):
+                A function or a subclass of `PipelineCallback` or `MultiPipelineCallbacks` that is called at the end of
+                each denoising step during the inference. with the following arguments: `callback_on_step_end(self:
+                DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` will include a
+                list of all tensors as specified by `callback_on_step_end_tensor_inputs`.
+            callback_on_step_end_tensor_inputs (`list`, *optional*):
+                The list of tensor inputs for the `callback_on_step_end` function. The tensors specified in the list
+                will be passed as `callback_kwargs` argument. You will only be able to include variables listed in the
+                `._callback_tensor_inputs` attribute of your pipeline class.
+            max_sequence_length (`int`, defaults to `512`):
+                The maximum sequence length of the text encoder. If the prompt is longer than this, it will be
+                truncated. If the prompt is shorter, it will be padded to this length.
+
+        Examples:
+
+        Returns:
+            [`~HeliosPipelineOutput`] or `tuple`:
+                If `return_dict` is `True`, [`HeliosPipelineOutput`] is returned, otherwise a `tuple` is returned where
+                the first element is a list with the generated images and the second element is a list of `bool`s
+                indicating whether the corresponding generated image contains "not-safe-for-work" (nsfw) content.
+        """
+
+        if image is not None and video is not None:
+            raise ValueError("image and video cannot be provided simultaneously")
+
+        history_sizes = sorted(history_sizes, reverse=True)  # From big to small
+
+        if isinstance(callback_on_step_end, (PipelineCallback, MultiPipelineCallbacks)):
+            callback_on_step_end_tensor_inputs = callback_on_step_end.tensor_inputs
+
+        # 1. Check inputs. Raise error if not correct
+        self.check_inputs(
+            prompt,
+            negative_prompt,
+            height,
+            width,
+            prompt_embeds,
+            negative_prompt_embeds,
+            callback_on_step_end_tensor_inputs,
+            image,
+            video,
+            use_interpolate_prompt,
+            num_videos_per_prompt,
+            interpolate_time_list,
+            interpolation_steps,
+            guidance_scale,
+        )
+
+        num_frames = max(num_frames, 1)
+
+        self._guidance_scale = guidance_scale
+        self._attention_kwargs = attention_kwargs
+        self._current_timestep = None
+        self._interrupt = False
+        relative_l1_records = [] if output_relative_l1 else None
+
+        device = self._execution_device
+        vae_dtype = self.vae.dtype
+
+        latents_mean = (
+            torch.tensor(self.vae.config.latents_mean)
+            .view(1, self.vae.config.z_dim, 1, 1, 1)
+            .to(device, self.vae.dtype)
+        )
+        latents_std = 1.0 / torch.tensor(self.vae.config.latents_std).view(1, self.vae.config.z_dim, 1, 1, 1).to(
+            device, self.vae.dtype
+        )
+
+        # 2. Define call parameters
+        if use_interpolate_prompt or (prompt is not None and isinstance(prompt, str)):
+            batch_size = 1
+        elif prompt is not None and isinstance(prompt, list):
+            batch_size = len(prompt)
+        else:
+            batch_size = prompt_embeds.shape[0]
+
+        # 3. Encode input prompt
+        if use_interpolate_prompt:
+            interpolate_interval_idx = None
+            interpolate_embeds = None
+            interpolate_cumulative_list = list(accumulate(interpolate_time_list))
+
+        all_prompt_embeds, negative_prompt_embeds = self.encode_prompt(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            do_classifier_free_guidance=self.do_classifier_free_guidance,
+            num_videos_per_prompt=num_videos_per_prompt,
+            prompt_embeds=prompt_embeds,
+            negative_prompt_embeds=negative_prompt_embeds,
+            max_sequence_length=max_sequence_length,
+            device=device,
+        )
+
+        transformer_dtype = self.transformer.dtype
+        all_prompt_embeds = all_prompt_embeds.to(transformer_dtype)
+        if negative_prompt_embeds is not None:
+            if use_interpolate_prompt:
+                negative_prompt_embeds = negative_prompt_embeds[0].unsqueeze(0)
+            negative_prompt_embeds = negative_prompt_embeds.to(transformer_dtype)
+
+        # 4. Prepare image or video
+        if image is not None:
+            image = self.video_processor.preprocess(image, height=height, width=width)
+            image_latents, fake_image_latents = self.prepare_image_latents(
+                image,
+                latents_mean=latents_mean,
+                latents_std=latents_std,
+                num_latent_frames_per_chunk=num_latent_frames_per_chunk,
+                dtype=torch.float32,
+                device=device,
+                generator=generator,
+                latents=image_latents,
+                fake_latents=fake_image_latents,
+            )
+
+        if image_latents is not None and add_noise_to_image_latents:
+            image_noise_sigma = (
+                torch.rand(1, device=device, generator=generator) * (image_noise_sigma_max - image_noise_sigma_min)
+                + image_noise_sigma_min
+            )
+            image_latents = (
+                image_noise_sigma * randn_tensor(image_latents.shape, generator=generator, device=device)
+                + (1 - image_noise_sigma) * image_latents
+            )
+            fake_image_noise_sigma = (
+                torch.rand(1, device=device, generator=generator) * (video_noise_sigma_max - video_noise_sigma_min)
+                + video_noise_sigma_min
+            )
+            fake_image_latents = (
+                fake_image_noise_sigma * randn_tensor(fake_image_latents.shape, generator=generator, device=device)
+                + (1 - fake_image_noise_sigma) * fake_image_latents
+            )
+
+        if video is not None:
+            video = self.video_processor.preprocess_video(video, height=height, width=width)
+            image_latents, video_latents = self.prepare_video_latents(
+                video,
+                latents_mean=latents_mean,
+                latents_std=latents_std,
+                num_latent_frames_per_chunk=num_latent_frames_per_chunk,
+                dtype=torch.float32,
+                device=device,
+                generator=generator,
+                latents=video_latents,
+            )
+
+        if video_latents is not None and add_noise_to_video_latents:
+            image_noise_sigma = (
+                torch.rand(1, device=device, generator=generator) * (image_noise_sigma_max - image_noise_sigma_min)
+                + image_noise_sigma_min
+            )
+            image_latents = (
+                image_noise_sigma * randn_tensor(image_latents.shape, generator=generator, device=device)
+                + (1 - image_noise_sigma) * image_latents
+            )
+
+            noisy_latents_chunks = []
+            num_latent_chunks = video_latents.shape[2] // num_latent_frames_per_chunk
+            for i in range(num_latent_chunks):
+                chunk_start = i * num_latent_frames_per_chunk
+                chunk_end = chunk_start + num_latent_frames_per_chunk
+                latent_chunk = video_latents[:, :, chunk_start:chunk_end, :, :]
+
+                chunk_frames = latent_chunk.shape[2]
+                frame_sigmas = (
+                    torch.rand(chunk_frames, device=device, generator=generator)
+                    * (video_noise_sigma_max - video_noise_sigma_min)
+                    + video_noise_sigma_min
+                )
+                frame_sigmas = frame_sigmas.view(1, 1, chunk_frames, 1, 1)
+
+                noisy_chunk = (
+                    frame_sigmas * randn_tensor(latent_chunk.shape, generator=generator, device=device)
+                    + (1 - frame_sigmas) * latent_chunk
+                )
+                noisy_latents_chunks.append(noisy_chunk)
+            video_latents = torch.cat(noisy_latents_chunks, dim=2)
+
+        # 5. Prepare latent variables
+        num_channels_latents = self.transformer.config.in_channels
+        window_num_frames = (num_latent_frames_per_chunk - 1) * self.vae_scale_factor_temporal + 1
+        num_latent_chunk = max(1, (num_frames + window_num_frames - 1) // window_num_frames)
+        num_history_latent_frames = sum(history_sizes)
+        history_video = None
+        total_generated_latent_frames = 0
+
+        if not keep_first_frame:
+            history_sizes[-1] = history_sizes[-1] + 1
+        history_latents = torch.zeros(
+            batch_size,
+            num_channels_latents,
+            num_history_latent_frames,
+            height // self.vae_scale_factor_spatial,
+            width // self.vae_scale_factor_spatial,
+            device=device,
+            dtype=torch.float32,
+        )
+        if fake_image_latents is not None:
+            history_latents = torch.cat([history_latents[:, :, :-1, :, :], fake_image_latents], dim=2)
+            total_generated_latent_frames += 1
+        if video_latents is not None:
+            history_frames = history_latents.shape[2]
+            video_frames = video_latents.shape[2]
+            if video_frames < history_frames:
+                keep_frames = history_frames - video_frames
+                history_latents = torch.cat([history_latents[:, :, :keep_frames, :, :], video_latents], dim=2)
+            else:
+                history_latents = video_latents
+            total_generated_latent_frames += video_latents.shape[2]
+
+        if keep_first_frame:
+            indices = torch.arange(0, sum([1, *history_sizes, num_latent_frames_per_chunk]))
+            (
+                indices_prefix,
+                indices_latents_history_long,
+                indices_latents_history_mid,
+                indices_latents_history_1x,
+                indices_hidden_states,
+            ) = indices.split([1, *history_sizes, num_latent_frames_per_chunk], dim=0)
+            indices_latents_history_short = torch.cat([indices_prefix, indices_latents_history_1x], dim=0)
+        else:
+            indices = torch.arange(0, sum([*history_sizes, num_latent_frames_per_chunk]))
+            (
+                indices_latents_history_long,
+                indices_latents_history_mid,
+                indices_latents_history_short,
+                indices_hidden_states,
+            ) = indices.split([*history_sizes, num_latent_frames_per_chunk], dim=0)
+        indices_hidden_states = indices_hidden_states.unsqueeze(0)
+        indices_latents_history_short = indices_latents_history_short.unsqueeze(0)
+        indices_latents_history_mid = indices_latents_history_mid.unsqueeze(0)
+        indices_latents_history_long = indices_latents_history_long.unsqueeze(0)
+
+        # 6. Denoising loop
+        if use_interpolate_prompt:
+            if num_latent_chunk < max(interpolate_cumulative_list):
+                num_latent_chunk = sum(interpolate_cumulative_list)
+                print(f"Update num_latent_chunk to: {num_latent_chunk}")
+
+        if not is_enable_stage2:
+            patch_size = self.transformer.config.patch_size
+            image_seq_len = (
+                num_latent_frames_per_chunk
+                * (height // self.vae_scale_factor_spatial)
+                * (width // self.vae_scale_factor_spatial)
+                // (patch_size[0] * patch_size[1] * patch_size[2])
+            )
+            sigmas = np.linspace(0.999, 0.0, num_inference_steps + 1)[:-1] if sigmas is None else sigmas
+            mu = calculate_shift(
+                image_seq_len,
+                self.scheduler.config.get("base_image_seq_len", 256),
+                self.scheduler.config.get("max_image_seq_len", 4096),
+                self.scheduler.config.get("base_shift", 0.5),
+                self.scheduler.config.get("max_shift", 1.15),
+            )
+
+        for k in range(num_latent_chunk):
+            if use_interpolate_prompt:
+                assert num_latent_chunk >= max(interpolate_cumulative_list)
+
+                current_interval_idx = 0
+                for idx, cumulative_val in enumerate(interpolate_cumulative_list):
+                    if k < cumulative_val:
+                        current_interval_idx = idx
+                        break
+
+                if current_interval_idx == 0:
+                    prompt_embeds = all_prompt_embeds[0].unsqueeze(0)
+                else:
+                    interval_start = interpolate_cumulative_list[current_interval_idx - 1]
+                    position_in_interval = k - interval_start
+
+                    if position_in_interval < interpolation_steps:
+                        if interpolate_embeds is None or interpolate_interval_idx != current_interval_idx:
+                            interpolate_embeds = self.interpolate_prompt_embeds(
+                                prompt_embeds_1=all_prompt_embeds[current_interval_idx - 1].unsqueeze(0),
+                                prompt_embeds_2=all_prompt_embeds[current_interval_idx].unsqueeze(0),
+                                interpolation_steps=interpolation_steps,
+                            )
+                            interpolate_interval_idx = current_interval_idx
+
+                        prompt_embeds = interpolate_embeds[position_in_interval]
+                    else:
+                        prompt_embeds = all_prompt_embeds[current_interval_idx].unsqueeze(0)
+            else:
+                prompt_embeds = all_prompt_embeds
+
+            is_first_chunk = k == 0
+            is_second_chunk = k == 1
+            if keep_first_frame:
+                latents_history_long, latents_history_mid, latents_history_1x = history_latents[
+                    :, :, -num_history_latent_frames:
+                ].split(history_sizes, dim=2)
+                if image_latents is None and is_first_chunk:
+                    latents_prefix = torch.zeros(
+                        (
+                            batch_size,
+                            num_channels_latents,
+                            1,
+                            latents_history_1x.shape[-2],
+                            latents_history_1x.shape[-1],
+                        ),
+                        device=device,
+                        dtype=latents_history_1x.dtype,
+                    )
+                else:
+                    latents_prefix = image_latents
+                latents_history_short = torch.cat([latents_prefix, latents_history_1x], dim=2)
+            else:
+                latents_history_long, latents_history_mid, latents_history_short = history_latents[
+                    :, :, -num_history_latent_frames:
+                ].split(history_sizes, dim=2)
+
+            latents = self.prepare_latents(
+                batch_size,
+                num_channels_latents,
+                height,
+                width,
+                window_num_frames,
+                dtype=torch.float32,
+                device=device,
+                generator=generator,
+                latents=None,
+            )
+
+            if not is_enable_stage2:
+                self.scheduler.set_timesteps(num_inference_steps, device=device, sigmas=sigmas, mu=mu)
+                timesteps = self.scheduler.timesteps
+                num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order
+                self._num_timesteps = len(timesteps)
+            else:
+                num_inference_steps = (
+                    sum(pyramid_num_inference_steps_list) * 2
+                    if is_amplify_first_chunk and self.config.is_distilled and is_first_chunk
+                    else sum(pyramid_num_inference_steps_list)
+                )
+
+            with self.progress_bar(total=num_inference_steps) as progress_bar:
+                if is_enable_stage2:
+                    latents = self.stage2_sample(
+                        latents=latents,
+                        pyramid_num_stages=pyramid_num_stages,
+                        pyramid_num_inference_steps_list=pyramid_num_inference_steps_list,
+                        prompt_embeds=prompt_embeds,
+                        negative_prompt_embeds=negative_prompt_embeds,
+                        guidance_scale=guidance_scale,
+                        indices_hidden_states=indices_hidden_states,
+                        indices_latents_history_short=indices_latents_history_short,
+                        indices_latents_history_mid=indices_latents_history_mid,
+                        indices_latents_history_long=indices_latents_history_long,
+                        latents_history_short=latents_history_short,
+                        latents_history_mid=latents_history_mid,
+                        latents_history_long=latents_history_long,
+                        attention_kwargs=attention_kwargs,
+                        device=device,
+                        transformer_dtype=transformer_dtype,
+                        # ------------ CFG Zero ------------
+                        use_zero_init=use_zero_init,
+                        zero_steps=zero_steps,
+                        # -------------- DMD --------------
+                        is_amplify_first_chunk=is_amplify_first_chunk and is_first_chunk,
+                        # ------------ Callback ------------
+                        callback_on_step_end=callback_on_step_end,
+                        callback_on_step_end_tensor_inputs=callback_on_step_end_tensor_inputs,
+                        progress_bar=progress_bar,
+                        chunk_index=k,
+                        relative_l1_records=relative_l1_records,
+                    )
+                else:
+                    latents = self.stage1_sample(
+                        latents=latents,
+                        prompt_embeds=prompt_embeds,
+                        negative_prompt_embeds=negative_prompt_embeds,
+                        timesteps=timesteps,
+                        guidance_scale=guidance_scale,
+                        indices_hidden_states=indices_hidden_states,
+                        indices_latents_history_short=indices_latents_history_short,
+                        indices_latents_history_mid=indices_latents_history_mid,
+                        indices_latents_history_long=indices_latents_history_long,
+                        latents_history_short=latents_history_short,
+                        latents_history_mid=latents_history_mid,
+                        latents_history_long=latents_history_long,
+                        attention_kwargs=attention_kwargs,
+                        device=device,
+                        transformer_dtype=transformer_dtype,
+                        generator=generator,
+                        num_warmup_steps=num_warmup_steps,
+                        # ------------ CFG Zero ------------
+                        use_zero_init=use_zero_init,
+                        zero_steps=zero_steps,
+                        # ------------ Callback ------------
+                        callback_on_step_end=callback_on_step_end,
+                        callback_on_step_end_tensor_inputs=callback_on_step_end_tensor_inputs,
+                        progress_bar=progress_bar,
+                        chunk_index=k,
+                        relative_l1_records=relative_l1_records,
+                    )
+
+                if keep_first_frame and (
+                    (is_first_chunk and image_latents is None) or (is_skip_first_chunk and is_second_chunk)
+                ):
+                    image_latents = latents[:, :, 0:1, :, :]
+
+                total_generated_latent_frames += latents.shape[2]
+                history_latents = torch.cat([history_latents, latents], dim=2)
+                real_history_latents = history_latents[:, :, -total_generated_latent_frames:]
+                current_latents = (
+                    real_history_latents[:, :, -num_latent_frames_per_chunk:].to(vae_dtype) / latents_std
+                    + latents_mean
+                )
+                current_video = self.vae.decode(current_latents, return_dict=False)[0]
+
+                if history_video is None:
+                    history_video = current_video
+                else:
+                    history_video = torch.cat([history_video, current_video], dim=2)
+
+        self._current_timestep = None
+
+        if output_type != "latent":
+            generated_frames = history_video.size(2)
+            generated_frames = (
+                generated_frames - 1
+            ) // self.vae_scale_factor_temporal * self.vae_scale_factor_temporal + 1
+            history_video = history_video[:, :, :generated_frames]
+            video = self.video_processor.postprocess_video(history_video, output_type=output_type)
+        else:
+            video = real_history_latents
+
+        # Offload all models
+        self.maybe_free_model_hooks()
+
+        if not return_dict:
+            return (video,)
+
+        return HeliosPipelineOutput(frames=video, relative_l1=relative_l1_records)

Helios/_DEV/helios/diffusers_version/scheduling_helios_diffusers.py

@@ -0,0 +1,947 @@
+# Copyright 2025 The Helios Team and The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+from dataclasses import dataclass
+from typing import Literal
+
+import numpy as np
+import torch
+
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.schedulers.scheduling_utils import SchedulerMixin
+from diffusers.utils import BaseOutput, deprecate
+
+
+@dataclass
+class HeliosSchedulerOutput(BaseOutput):
+    prev_sample: torch.FloatTensor
+    model_outputs: torch.FloatTensor | None = None
+    last_sample: torch.FloatTensor | None = None
+    this_order: int | None = None
+
+
+class HeliosScheduler(SchedulerMixin, ConfigMixin):
+    _compatibles = []
+    order = 1
+
+    @register_to_config
+    def __init__(
+        self,
+        num_train_timesteps: int = 1000,
+        shift: float = 1.0,  # Following Stable diffusion 3,
+        stages: int = 3,
+        stage_range: list = [0, 1 / 3, 2 / 3, 1],
+        gamma: float = 1 / 3,
+        # For UniPC
+        thresholding: bool = False,
+        prediction_type: str = "flow_prediction",
+        solver_order: int = 2,
+        predict_x0: bool = True,
+        solver_type: str = "bh2",
+        lower_order_final: bool = True,
+        disable_corrector: list[int] = [],
+        solver_p: SchedulerMixin = None,
+        use_flow_sigmas: bool = True,
+        scheduler_type: str = "unipc",  # ["euler", "unipc", "dmd"]
+        use_dynamic_shifting: bool = False,
+        time_shift_type: Literal["exponential", "linear"] = "linear",
+    ):
+        self.timestep_ratios = {}  # The timestep ratio for each stage
+        self.timesteps_per_stage = {}  # The detailed timesteps per stage (fix max and min per stage)
+        self.sigmas_per_stage = {}  # always uniform [1000, 0]
+        self.start_sigmas = {}  # for start point / upsample renoise
+        self.end_sigmas = {}  # for end point
+        self.ori_start_sigmas = {}
+
+        # self.init_sigmas()
+        self.init_sigmas_for_each_stage()
+        self.sigma_min = self.sigmas[-1].item()
+        self.sigma_max = self.sigmas[0].item()
+        self.gamma = gamma
+
+        if solver_type not in ["bh1", "bh2"]:
+            if solver_type in ["midpoint", "heun", "logrho"]:
+                self.register_to_config(solver_type="bh2")
+            else:
+                raise NotImplementedError(f"{solver_type} is not implemented for {self.__class__}")
+
+        self.predict_x0 = predict_x0
+        self.model_outputs = [None] * solver_order
+        self.timestep_list = [None] * solver_order
+        self.lower_order_nums = 0
+        self.disable_corrector = disable_corrector
+        self.solver_p = solver_p
+        self.last_sample = None
+        self._step_index = None
+        self._begin_index = None
+
+    def init_sigmas(self):
+        """
+        initialize the global timesteps and sigmas
+        """
+        num_train_timesteps = self.config.num_train_timesteps
+        shift = self.config.shift
+
+        alphas = np.linspace(1, 1 / num_train_timesteps, num_train_timesteps + 1)
+        sigmas = 1.0 - alphas
+        sigmas = np.flip(shift * sigmas / (1 + (shift - 1) * sigmas))[:-1].copy()
+        sigmas = torch.from_numpy(sigmas)
+        timesteps = (sigmas * num_train_timesteps).clone()
+
+        self._step_index = None
+        self._begin_index = None
+        self.timesteps = timesteps
+        self.sigmas = sigmas.to("cpu")  # to avoid too much CPU/GPU communication
+
+    def init_sigmas_for_each_stage(self):
+        """
+        Init the timesteps for each stage
+        """
+        self.init_sigmas()
+
+        stage_distance = []
+        stages = self.config.stages
+        training_steps = self.config.num_train_timesteps
+        stage_range = self.config.stage_range
+
+        # Init the start and end point of each stage
+        for i_s in range(stages):
+            # To decide the start and ends point
+            start_indice = int(stage_range[i_s] * training_steps)
+            start_indice = max(start_indice, 0)
+            end_indice = int(stage_range[i_s + 1] * training_steps)
+            end_indice = min(end_indice, training_steps)
+            start_sigma = self.sigmas[start_indice].item()
+            end_sigma = self.sigmas[end_indice].item() if end_indice < training_steps else 0.0
+            self.ori_start_sigmas[i_s] = start_sigma
+
+            if i_s != 0:
+                ori_sigma = 1 - start_sigma
+                gamma = self.config.gamma
+                corrected_sigma = (1 / (math.sqrt(1 + (1 / gamma)) * (1 - ori_sigma) + ori_sigma)) * ori_sigma
+                # corrected_sigma = 1 / (2 - ori_sigma) * ori_sigma
+                start_sigma = 1 - corrected_sigma
+
+            stage_distance.append(start_sigma - end_sigma)
+            self.start_sigmas[i_s] = start_sigma
+            self.end_sigmas[i_s] = end_sigma
+
+        # Determine the ratio of each stage according to flow length
+        tot_distance = sum(stage_distance)
+        for i_s in range(stages):
+            if i_s == 0:
+                start_ratio = 0.0
+            else:
+                start_ratio = sum(stage_distance[:i_s]) / tot_distance
+            if i_s == stages - 1:
+                end_ratio = 0.9999999999999999
+            else:
+                end_ratio = sum(stage_distance[: i_s + 1]) / tot_distance
+
+            self.timestep_ratios[i_s] = (start_ratio, end_ratio)
+
+        # Determine the timesteps and sigmas for each stage
+        for i_s in range(stages):
+            timestep_ratio = self.timestep_ratios[i_s]
+            # timestep_max = self.timesteps[int(timestep_ratio[0] * training_steps)]
+            timestep_max = min(self.timesteps[int(timestep_ratio[0] * training_steps)], 999)
+            timestep_min = self.timesteps[min(int(timestep_ratio[1] * training_steps), training_steps - 1)]
+            timesteps = np.linspace(timestep_max, timestep_min, training_steps + 1)
+            self.timesteps_per_stage[i_s] = (
+                timesteps[:-1] if isinstance(timesteps, torch.Tensor) else torch.from_numpy(timesteps[:-1])
+            )
+            stage_sigmas = np.linspace(0.999, 0, training_steps + 1)
+            self.sigmas_per_stage[i_s] = torch.from_numpy(stage_sigmas[:-1])
+
+    @property
+    def step_index(self):
+        """
+        The index counter for current timestep. It will increase 1 after each scheduler step.
+        """
+        return self._step_index
+
+    @property
+    def begin_index(self):
+        """
+        The index for the first timestep. It should be set from pipeline with `set_begin_index` method.
+        """
+        return self._begin_index
+
+    def set_begin_index(self, begin_index: int = 0):
+        """
+        Sets the begin index for the scheduler. This function should be run from pipeline before the inference.
+
+        Args:
+            begin_index (`int`):
+                The begin index for the scheduler.
+        """
+        self._begin_index = begin_index
+
+    def _sigma_to_t(self, sigma):
+        return sigma * self.config.num_train_timesteps
+
+    def set_timesteps(
+        self,
+        num_inference_steps: int,
+        stage_index: int | None = None,
+        device: str | torch.device = None,
+        sigmas: bool | None = None,
+        mu: bool | None = None,
+        is_amplify_first_chunk: bool = False,
+    ):
+        """
+        Setting the timesteps and sigmas for each stage
+        """
+        if self.config.scheduler_type == "dmd":
+            if is_amplify_first_chunk:
+                num_inference_steps = num_inference_steps * 2 + 1
+            else:
+                num_inference_steps = num_inference_steps + 1
+
+        self.num_inference_steps = num_inference_steps
+        self.init_sigmas()
+
+        if self.config.stages == 1:
+            if sigmas is None:
+                sigmas = np.linspace(1, 1 / self.config.num_train_timesteps, num_inference_steps + 1)[:-1].astype(
+                    np.float32
+                )
+                if self.config.shift != 1.0:
+                    assert not self.config.use_dynamic_shifting
+                    sigmas = self.time_shift(self.config.shift, 1.0, sigmas)
+            timesteps = (sigmas * self.config.num_train_timesteps).copy()
+            sigmas = torch.from_numpy(sigmas)
+        else:
+            stage_timesteps = self.timesteps_per_stage[stage_index]
+            timesteps = np.linspace(
+                stage_timesteps[0].item(),
+                stage_timesteps[-1].item(),
+                num_inference_steps,
+            )
+
+            stage_sigmas = self.sigmas_per_stage[stage_index]
+            ratios = np.linspace(stage_sigmas[0].item(), stage_sigmas[-1].item(), num_inference_steps)
+            sigmas = torch.from_numpy(ratios)
+
+        self.timesteps = torch.from_numpy(timesteps).to(device=device)
+        self.sigmas = torch.cat([sigmas, torch.zeros(1)]).to(device=device)
+
+        self._step_index = None
+        self.reset_scheduler_history()
+
+        if self.config.scheduler_type == "dmd":
+            self.timesteps = self.timesteps[:-1]
+            self.sigmas = torch.cat([self.sigmas[:-2], self.sigmas[-1:]])
+
+        if self.config.use_dynamic_shifting:
+            assert self.config.shift == 1.0
+            self.sigmas = self.time_shift(mu, 1.0, self.sigmas)
+            if self.config.stages == 1:
+                self.timesteps = self.sigmas[:-1] * self.config.num_train_timesteps
+            else:
+                self.timesteps = self.timesteps_per_stage[stage_index].min() + self.sigmas[:-1] * (
+                    self.timesteps_per_stage[stage_index].max() - self.timesteps_per_stage[stage_index].min()
+                )
+
+    # Copied from diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler.time_shift
+    def time_shift(self, mu: float, sigma: float, t: torch.Tensor):
+        """
+        Apply time shifting to the sigmas.
+
+        Args:
+            mu (`float`):
+                The mu parameter for the time shift.
+            sigma (`float`):
+                The sigma parameter for the time shift.
+            t (`torch.Tensor`):
+                The input timesteps.
+
+        Returns:
+            `torch.Tensor`:
+                The time-shifted timesteps.
+        """
+        if self.config.time_shift_type == "exponential":
+            return self._time_shift_exponential(mu, sigma, t)
+        elif self.config.time_shift_type == "linear":
+            return self._time_shift_linear(mu, sigma, t)
+
+    # Copied from diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler._time_shift_exponential
+    def _time_shift_exponential(self, mu, sigma, t):
+        return math.exp(mu) / (math.exp(mu) + (1 / t - 1) ** sigma)
+
+    # Copied from diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler._time_shift_linear
+    def _time_shift_linear(self, mu, sigma, t):
+        return mu / (mu + (1 / t - 1) ** sigma)
+
+    # ---------------------------------- Euler ----------------------------------
+    def index_for_timestep(self, timestep, schedule_timesteps=None):
+        if schedule_timesteps is None:
+            schedule_timesteps = self.timesteps
+
+        indices = (schedule_timesteps == timestep).nonzero()
+
+        # The sigma index that is taken for the **very** first `step`
+        # is always the second index (or the last index if there is only 1)
+        # This way we can ensure we don't accidentally skip a sigma in
+        # case we start in the middle of the denoising schedule (e.g. for image-to-image)
+        pos = 1 if len(indices) > 1 else 0
+
+        return indices[pos].item()
+
+    def _init_step_index(self, timestep):
+        if self.begin_index is None:
+            if isinstance(timestep, torch.Tensor):
+                timestep = timestep.to(self.timesteps.device)
+            self._step_index = self.index_for_timestep(timestep)
+        else:
+            self._step_index = self._begin_index
+
+    def step_euler(
+        self,
+        model_output: torch.FloatTensor,
+        timestep: float | torch.FloatTensor = None,
+        sample: torch.FloatTensor = None,
+        generator: torch.Generator | None = None,
+        sigma: torch.FloatTensor | None = None,
+        sigma_next: torch.FloatTensor | None = None,
+        return_dict: bool = True,
+    ) -> HeliosSchedulerOutput | tuple:
+        assert (sigma is None) == (sigma_next is None), "sigma and sigma_next must both be None or both be not None"
+
+        if sigma is None and sigma_next is None:
+            if (
+                isinstance(timestep, int)
+                or isinstance(timestep, torch.IntTensor)
+                or isinstance(timestep, torch.LongTensor)
+            ):
+                raise ValueError(
+                    (
+                        "Passing integer indices (e.g. from `enumerate(timesteps)`) as timesteps to"
+                        " `EulerDiscreteScheduler.step()` is not supported. Make sure to pass"
+                        " one of the `scheduler.timesteps` as a timestep."
+                    ),
+                )
+
+        if self.step_index is None:
+            self._step_index = 0
+
+        # Upcast to avoid precision issues when computing prev_sample
+        sample = sample.to(torch.float32)
+
+        if sigma is None and sigma_next is None:
+            sigma = self.sigmas[self.step_index]
+            sigma_next = self.sigmas[self.step_index + 1]
+
+        prev_sample = sample + (sigma_next - sigma) * model_output
+
+        # Cast sample back to model compatible dtype
+        prev_sample = prev_sample.to(model_output.dtype)
+
+        # upon completion increase step index by one
+        self._step_index += 1
+
+        if not return_dict:
+            return (prev_sample,)
+
+        return HeliosSchedulerOutput(prev_sample=prev_sample)
+
+    # ---------------------------------- UniPC ----------------------------------
+    def _sigma_to_alpha_sigma_t(self, sigma):
+        if self.config.use_flow_sigmas:
+            alpha_t = 1 - sigma
+            sigma_t = torch.clamp(sigma, min=1e-8)
+        else:
+            alpha_t = 1 / ((sigma**2 + 1) ** 0.5)
+            sigma_t = sigma * alpha_t
+
+        return alpha_t, sigma_t
+
+    def convert_model_output(
+        self,
+        model_output: torch.Tensor,
+        *args,
+        sample: torch.Tensor = None,
+        sigma: torch.Tensor = None,
+        **kwargs,
+    ) -> torch.Tensor:
+        r"""
+        Convert the model output to the corresponding type the UniPC algorithm needs.
+
+        Args:
+            model_output (`torch.Tensor`):
+                The direct output from the learned diffusion model.
+            timestep (`int`):
+                The current discrete timestep in the diffusion chain.
+            sample (`torch.Tensor`):
+                A current instance of a sample created by the diffusion process.
+
+        Returns:
+            `torch.Tensor`:
+                The converted model output.
+        """
+        timestep = args[0] if len(args) > 0 else kwargs.pop("timestep", None)
+        if sample is None:
+            if len(args) > 1:
+                sample = args[1]
+            else:
+                raise ValueError("missing `sample` as a required keyword argument")
+        if timestep is not None:
+            deprecate(
+                "timesteps",
+                "1.0.0",
+                "Passing `timesteps` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
+            )
+
+        flag = False
+        if sigma is None:
+            flag = True
+            sigma = self.sigmas[self.step_index]
+        alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma)
+
+        if self.predict_x0:
+            if self.config.prediction_type == "epsilon":
+                x0_pred = (sample - sigma_t * model_output) / alpha_t
+            elif self.config.prediction_type == "sample":
+                x0_pred = model_output
+            elif self.config.prediction_type == "v_prediction":
+                x0_pred = alpha_t * sample - sigma_t * model_output
+            elif self.config.prediction_type == "flow_prediction":
+                if flag:
+                    sigma_t = self.sigmas[self.step_index]
+                else:
+                    sigma_t = sigma
+                x0_pred = sample - sigma_t * model_output
+            else:
+                raise ValueError(
+                    f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, "
+                    "`v_prediction`, or `flow_prediction` for the UniPCMultistepScheduler."
+                )
+
+            if self.config.thresholding:
+                x0_pred = self._threshold_sample(x0_pred)
+
+            return x0_pred
+        else:
+            if self.config.prediction_type == "epsilon":
+                return model_output
+            elif self.config.prediction_type == "sample":
+                epsilon = (sample - alpha_t * model_output) / sigma_t
+                return epsilon
+            elif self.config.prediction_type == "v_prediction":
+                epsilon = alpha_t * model_output + sigma_t * sample
+                return epsilon
+            else:
+                raise ValueError(
+                    f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, or"
+                    " `v_prediction` for the UniPCMultistepScheduler."
+                )
+
+    def multistep_uni_p_bh_update(
+        self,
+        model_output: torch.Tensor,
+        *args,
+        sample: torch.Tensor = None,
+        order: int = None,
+        sigma: torch.Tensor = None,
+        sigma_next: torch.Tensor = None,
+        **kwargs,
+    ) -> torch.Tensor:
+        """
+        One step for the UniP (B(h) version). Alternatively, `self.solver_p` is used if is specified.
+
+        Args:
+            model_output (`torch.Tensor`):
+                The direct output from the learned diffusion model at the current timestep.
+            prev_timestep (`int`):
+                The previous discrete timestep in the diffusion chain.
+            sample (`torch.Tensor`):
+                A current instance of a sample created by the diffusion process.
+            order (`int`):
+                The order of UniP at this timestep (corresponds to the *p* in UniPC-p).
+
+        Returns:
+            `torch.Tensor`:
+                The sample tensor at the previous timestep.
+        """
+        prev_timestep = args[0] if len(args) > 0 else kwargs.pop("prev_timestep", None)
+        if sample is None:
+            if len(args) > 1:
+                sample = args[1]
+            else:
+                raise ValueError("missing `sample` as a required keyword argument")
+        if order is None:
+            if len(args) > 2:
+                order = args[2]
+            else:
+                raise ValueError("missing `order` as a required keyword argument")
+        if prev_timestep is not None:
+            deprecate(
+                "prev_timestep",
+                "1.0.0",
+                "Passing `prev_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
+            )
+        model_output_list = self.model_outputs
+
+        s0 = self.timestep_list[-1]
+        m0 = model_output_list[-1]
+        x = sample
+
+        if self.solver_p:
+            x_t = self.solver_p.step(model_output, s0, x).prev_sample
+            return x_t
+
+        if sigma_next is None and sigma is None:
+            sigma_t, sigma_s0 = self.sigmas[self.step_index + 1], self.sigmas[self.step_index]
+        else:
+            sigma_t, sigma_s0 = sigma_next, sigma
+        alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma_t)
+        alpha_s0, sigma_s0 = self._sigma_to_alpha_sigma_t(sigma_s0)
+
+        lambda_t = torch.log(alpha_t) - torch.log(sigma_t)
+        lambda_s0 = torch.log(alpha_s0) - torch.log(sigma_s0)
+
+        h = lambda_t - lambda_s0
+        device = sample.device
+
+        rks = []
+        D1s = []
+        for i in range(1, order):
+            si = self.step_index - i
+            mi = model_output_list[-(i + 1)]
+            alpha_si, sigma_si = self._sigma_to_alpha_sigma_t(self.sigmas[si])
+            lambda_si = torch.log(alpha_si) - torch.log(sigma_si)
+            rk = (lambda_si - lambda_s0) / h
+            rks.append(rk)
+            D1s.append((mi - m0) / rk)
+
+        rks.append(1.0)
+        rks = torch.tensor(rks, device=device)
+
+        R = []
+        b = []
+
+        hh = -h if self.predict_x0 else h
+        h_phi_1 = torch.expm1(hh)  # h\phi_1(h) = e^h - 1
+        h_phi_k = h_phi_1 / hh - 1
+
+        factorial_i = 1
+
+        if self.config.solver_type == "bh1":
+            B_h = hh
+        elif self.config.solver_type == "bh2":
+            B_h = torch.expm1(hh)
+        else:
+            raise NotImplementedError()
+
+        for i in range(1, order + 1):
+            R.append(torch.pow(rks, i - 1))
+            b.append(h_phi_k * factorial_i / B_h)
+            factorial_i *= i + 1
+            h_phi_k = h_phi_k / hh - 1 / factorial_i
+
+        R = torch.stack(R)
+        b = torch.tensor(b, device=device)
+
+        if len(D1s) > 0:
+            D1s = torch.stack(D1s, dim=1)  # (B, K)
+            # for order 2, we use a simplified version
+            if order == 2:
+                rhos_p = torch.tensor([0.5], dtype=x.dtype, device=device)
+            else:
+                rhos_p = torch.linalg.solve(R[:-1, :-1], b[:-1]).to(device).to(x.dtype)
+        else:
+            D1s = None
+
+        if self.predict_x0:
+            x_t_ = sigma_t / sigma_s0 * x - alpha_t * h_phi_1 * m0
+            if D1s is not None:
+                pred_res = torch.einsum("k,bkc...->bc...", rhos_p, D1s)
+            else:
+                pred_res = 0
+            x_t = x_t_ - alpha_t * B_h * pred_res
+        else:
+            x_t_ = alpha_t / alpha_s0 * x - sigma_t * h_phi_1 * m0
+            if D1s is not None:
+                pred_res = torch.einsum("k,bkc...->bc...", rhos_p, D1s)
+            else:
+                pred_res = 0
+            x_t = x_t_ - sigma_t * B_h * pred_res
+
+        x_t = x_t.to(x.dtype)
+        return x_t
+
+    def multistep_uni_c_bh_update(
+        self,
+        this_model_output: torch.Tensor,
+        *args,
+        last_sample: torch.Tensor = None,
+        this_sample: torch.Tensor = None,
+        order: int = None,
+        sigma_before: torch.Tensor = None,
+        sigma: torch.Tensor = None,
+        **kwargs,
+    ) -> torch.Tensor:
+        """
+        One step for the UniC (B(h) version).
+
+        Args:
+            this_model_output (`torch.Tensor`):
+                The model outputs at `x_t`.
+            this_timestep (`int`):
+                The current timestep `t`.
+            last_sample (`torch.Tensor`):
+                The generated sample before the last predictor `x_{t-1}`.
+            this_sample (`torch.Tensor`):
+                The generated sample after the last predictor `x_{t}`.
+            order (`int`):
+                The `p` of UniC-p at this step. The effective order of accuracy should be `order + 1`.
+
+        Returns:
+            `torch.Tensor`:
+                The corrected sample tensor at the current timestep.
+        """
+        this_timestep = args[0] if len(args) > 0 else kwargs.pop("this_timestep", None)
+        if last_sample is None:
+            if len(args) > 1:
+                last_sample = args[1]
+            else:
+                raise ValueError("missing `last_sample` as a required keyword argument")
+        if this_sample is None:
+            if len(args) > 2:
+                this_sample = args[2]
+            else:
+                raise ValueError("missing `this_sample` as a required keyword argument")
+        if order is None:
+            if len(args) > 3:
+                order = args[3]
+            else:
+                raise ValueError("missing `order` as a required keyword argument")
+        if this_timestep is not None:
+            deprecate(
+                "this_timestep",
+                "1.0.0",
+                "Passing `this_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
+            )
+
+        model_output_list = self.model_outputs
+
+        m0 = model_output_list[-1]
+        x = last_sample
+        x_t = this_sample
+        model_t = this_model_output
+
+        if sigma_before is None and sigma is None:
+            sigma_t, sigma_s0 = self.sigmas[self.step_index], self.sigmas[self.step_index - 1]
+        else:
+            sigma_t, sigma_s0 = sigma, sigma_before
+        alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma_t)
+        alpha_s0, sigma_s0 = self._sigma_to_alpha_sigma_t(sigma_s0)
+
+        lambda_t = torch.log(alpha_t) - torch.log(sigma_t)
+        lambda_s0 = torch.log(alpha_s0) - torch.log(sigma_s0)
+
+        h = lambda_t - lambda_s0
+        device = this_sample.device
+
+        rks = []
+        D1s = []
+        for i in range(1, order):
+            si = self.step_index - (i + 1)
+            mi = model_output_list[-(i + 1)]
+            alpha_si, sigma_si = self._sigma_to_alpha_sigma_t(self.sigmas[si])
+            lambda_si = torch.log(alpha_si) - torch.log(sigma_si)
+            rk = (lambda_si - lambda_s0) / h
+            rks.append(rk)
+            D1s.append((mi - m0) / rk)
+
+        rks.append(1.0)
+        rks = torch.tensor(rks, device=device)
+
+        R = []
+        b = []
+
+        hh = -h if self.predict_x0 else h
+        h_phi_1 = torch.expm1(hh)  # h\phi_1(h) = e^h - 1
+        h_phi_k = h_phi_1 / hh - 1
+
+        factorial_i = 1
+
+        if self.config.solver_type == "bh1":
+            B_h = hh
+        elif self.config.solver_type == "bh2":
+            B_h = torch.expm1(hh)
+        else:
+            raise NotImplementedError()
+
+        for i in range(1, order + 1):
+            R.append(torch.pow(rks, i - 1))
+            b.append(h_phi_k * factorial_i / B_h)
+            factorial_i *= i + 1
+            h_phi_k = h_phi_k / hh - 1 / factorial_i
+
+        R = torch.stack(R)
+        b = torch.tensor(b, device=device)
+
+        if len(D1s) > 0:
+            D1s = torch.stack(D1s, dim=1)
+        else:
+            D1s = None
+
+        # for order 1, we use a simplified version
+        if order == 1:
+            rhos_c = torch.tensor([0.5], dtype=x.dtype, device=device)
+        else:
+            rhos_c = torch.linalg.solve(R, b).to(device).to(x.dtype)
+
+        if self.predict_x0:
+            x_t_ = sigma_t / sigma_s0 * x - alpha_t * h_phi_1 * m0
+            if D1s is not None:
+                corr_res = torch.einsum("k,bkc...->bc...", rhos_c[:-1], D1s)
+            else:
+                corr_res = 0
+            D1_t = model_t - m0
+            x_t = x_t_ - alpha_t * B_h * (corr_res + rhos_c[-1] * D1_t)
+        else:
+            x_t_ = alpha_t / alpha_s0 * x - sigma_t * h_phi_1 * m0
+            if D1s is not None:
+                corr_res = torch.einsum("k,bkc...->bc...", rhos_c[:-1], D1s)
+            else:
+                corr_res = 0
+            D1_t = model_t - m0
+            x_t = x_t_ - sigma_t * B_h * (corr_res + rhos_c[-1] * D1_t)
+        x_t = x_t.to(x.dtype)
+        return x_t
+
+    def step_unipc(
+        self,
+        model_output: torch.Tensor,
+        timestep: int | torch.Tensor = None,
+        sample: torch.Tensor = None,
+        return_dict: bool = True,
+        model_outputs: list = None,
+        timestep_list: list = None,
+        sigma_before: torch.Tensor = None,
+        sigma: torch.Tensor = None,
+        sigma_next: torch.Tensor = None,
+        cus_step_index: int = None,
+        cus_lower_order_num: int = None,
+        cus_this_order: int = None,
+        cus_last_sample: torch.Tensor = None,
+    ) -> HeliosSchedulerOutput | tuple:
+        if self.num_inference_steps is None:
+            raise ValueError(
+                "Number of inference steps is 'None', you need to run 'set_timesteps' after creating the scheduler"
+            )
+
+        if cus_step_index is None:
+            if self.step_index is None:
+                self._step_index = 0
+        else:
+            self._step_index = cus_step_index
+
+        if cus_lower_order_num is not None:
+            self.lower_order_nums = cus_lower_order_num
+
+        if cus_this_order is not None:
+            self.this_order = cus_this_order
+
+        if cus_last_sample is not None:
+            self.last_sample = cus_last_sample
+
+        use_corrector = (
+            self.step_index > 0 and self.step_index - 1 not in self.disable_corrector and self.last_sample is not None
+        )
+
+        # Convert model output using the proper conversion method
+        model_output_convert = self.convert_model_output(model_output, sample=sample, sigma=sigma)
+
+        if model_outputs is not None and timestep_list is not None:
+            self.model_outputs = model_outputs[:-1]
+            self.timestep_list = timestep_list[:-1]
+
+        if use_corrector:
+            sample = self.multistep_uni_c_bh_update(
+                this_model_output=model_output_convert,
+                last_sample=self.last_sample,
+                this_sample=sample,
+                order=self.this_order,
+                sigma_before=sigma_before,
+                sigma=sigma,
+            )
+
+        if model_outputs is not None and timestep_list is not None:
+            model_outputs[-1] = model_output_convert
+            self.model_outputs = model_outputs[1:]
+            self.timestep_list = timestep_list[1:]
+        else:
+            for i in range(self.config.solver_order - 1):
+                self.model_outputs[i] = self.model_outputs[i + 1]
+                self.timestep_list[i] = self.timestep_list[i + 1]
+            self.model_outputs[-1] = model_output_convert
+            self.timestep_list[-1] = timestep
+
+        if self.config.lower_order_final:
+            this_order = min(self.config.solver_order, len(self.timesteps) - self.step_index)
+        else:
+            this_order = self.config.solver_order
+        self.this_order = min(this_order, self.lower_order_nums + 1)  # warmup for multistep
+        assert self.this_order > 0
+
+        self.last_sample = sample
+        prev_sample = self.multistep_uni_p_bh_update(
+            model_output=model_output,  # pass the original non-converted model output, in case solver-p is used
+            sample=sample,
+            order=self.this_order,
+            sigma=sigma,
+            sigma_next=sigma_next,
+        )
+
+        if cus_lower_order_num is None:
+            if self.lower_order_nums < self.config.solver_order:
+                self.lower_order_nums += 1
+
+        # upon completion increase step index by one
+        if cus_step_index is None:
+            self._step_index += 1
+
+        if not return_dict:
+            return (prev_sample, model_outputs, self.last_sample, self.this_order)
+
+        return HeliosSchedulerOutput(
+            prev_sample=prev_sample,
+            model_outputs=model_outputs,
+            last_sample=self.last_sample,
+            this_order=self.this_order,
+        )
+
+    # ---------------------------------- For DMD ----------------------------------
+    def add_noise(self, original_samples, noise, timestep, sigmas, timesteps):
+        sigmas = sigmas.to(noise.device)
+        timesteps = timesteps.to(noise.device)
+        timestep_id = torch.argmin((timesteps.unsqueeze(0) - timestep.unsqueeze(1)).abs(), dim=1)
+        sigma = sigmas[timestep_id].reshape(-1, 1, 1, 1, 1)
+        sample = (1 - sigma) * original_samples + sigma * noise
+        return sample.type_as(noise)
+
+    def convert_flow_pred_to_x0(self, flow_pred, xt, timestep, sigmas, timesteps):
+        # use higher precision for calculations
+        original_dtype = flow_pred.dtype
+        device = flow_pred.device
+        flow_pred, xt, sigmas, timesteps = (x.double().to(device) for x in (flow_pred, xt, sigmas, timesteps))
+
+        timestep_id = torch.argmin((timesteps.unsqueeze(0) - timestep.unsqueeze(1)).abs(), dim=1)
+        sigma_t = sigmas[timestep_id].reshape(-1, 1, 1, 1, 1)
+        x0_pred = xt - sigma_t * flow_pred
+        return x0_pred.to(original_dtype)
+
+    def step_dmd(
+        self,
+        model_output: torch.FloatTensor,
+        timestep: float | torch.FloatTensor = None,
+        sample: torch.FloatTensor = None,
+        generator: torch.Generator | None = None,
+        return_dict: bool = True,
+        cur_sampling_step: int = 0,
+        dmd_noisy_tensor: torch.FloatTensor | None = None,
+        dmd_sigmas: torch.FloatTensor | None = None,
+        dmd_timesteps: torch.FloatTensor | None = None,
+        all_timesteps: torch.FloatTensor | None = None,
+    ):
+        pred_image_or_video = self.convert_flow_pred_to_x0(
+            flow_pred=model_output,
+            xt=sample,
+            timestep=torch.full((model_output.shape[0],), timestep, dtype=torch.long, device=model_output.device),
+            sigmas=dmd_sigmas,
+            timesteps=dmd_timesteps,
+        )
+        if cur_sampling_step < len(all_timesteps) - 1:
+            prev_sample = self.add_noise(
+                pred_image_or_video,
+                dmd_noisy_tensor,
+                torch.full(
+                    (model_output.shape[0],),
+                    all_timesteps[cur_sampling_step + 1],
+                    dtype=torch.long,
+                    device=model_output.device,
+                ),
+                sigmas=dmd_sigmas,
+                timesteps=dmd_timesteps,
+            )
+        else:
+            prev_sample = pred_image_or_video
+
+        if not return_dict:
+            return (prev_sample,)
+
+        return HeliosSchedulerOutput(prev_sample=prev_sample)
+
+    # ---------------------------------- Merge ----------------------------------
+    def step(
+        self,
+        model_output: torch.FloatTensor,
+        timestep: float | torch.FloatTensor = None,
+        sample: torch.FloatTensor = None,
+        generator: torch.Generator | None = None,
+        return_dict: bool = True,
+        # For DMD
+        cur_sampling_step: int = 0,
+        dmd_noisy_tensor: torch.FloatTensor | None = None,
+        dmd_sigmas: torch.FloatTensor | None = None,
+        dmd_timesteps: torch.FloatTensor | None = None,
+        all_timesteps: torch.FloatTensor | None = None,
+    ) -> HeliosSchedulerOutput | tuple:
+        if self.config.scheduler_type == "euler":
+            return self.step_euler(
+                model_output=model_output,
+                timestep=timestep,
+                sample=sample,
+                generator=generator,
+                return_dict=return_dict,
+            )
+        elif self.config.scheduler_type == "unipc":
+            return self.step_unipc(
+                model_output=model_output,
+                timestep=timestep,
+                sample=sample,
+                return_dict=return_dict,
+            )
+        elif self.config.scheduler_type == "dmd":
+            return self.step_dmd(
+                model_output=model_output,
+                timestep=timestep,
+                sample=sample,
+                generator=generator,
+                return_dict=return_dict,
+                cur_sampling_step=cur_sampling_step,
+                dmd_noisy_tensor=dmd_noisy_tensor,
+                dmd_sigmas=dmd_sigmas,
+                dmd_timesteps=dmd_timesteps,
+                all_timesteps=all_timesteps,
+            )
+        else:
+            raise NotImplementedError
+
+    def reset_scheduler_history(self):
+        self.model_outputs = [None] * self.config.solver_order
+        self.timestep_list = [None] * self.config.solver_order
+        self.lower_order_nums = 0
+        self.disable_corrector = self.config.disable_corrector
+        self.solver_p = self.config.solver_p
+        self.last_sample = None
+        self._step_index = None
+        self._begin_index = None
+
+    def __len__(self):
+        return self.config.num_train_timesteps

Helios/_DEV/helios/diffusers_version/transformer_helios_diffusers.py

@@ -0,0 +1,825 @@
+# Copyright 2025 The Helios Team and The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+from functools import lru_cache
+from typing import Any
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.loaders import FromOriginalModelMixin, PeftAdapterMixin
+from diffusers.models._modeling_parallel import ContextParallelInput, ContextParallelOutput
+from diffusers.models.attention import AttentionMixin, AttentionModuleMixin, FeedForward
+from diffusers.models.attention_dispatch import dispatch_attention_fn
+from diffusers.models.cache_utils import CacheMixin
+from diffusers.models.embeddings import PixArtAlphaTextProjection, TimestepEmbedding, Timesteps
+from diffusers.models.modeling_outputs import Transformer2DModelOutput
+from diffusers.models.modeling_utils import ModelMixin
+from diffusers.models.normalization import FP32LayerNorm
+from diffusers.utils import apply_lora_scale, logging
+from diffusers.utils.torch_utils import maybe_allow_in_graph
+
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+
+def pad_for_3d_conv(x, kernel_size):
+    b, c, t, h, w = x.shape
+    pt, ph, pw = kernel_size
+    pad_t = (pt - (t % pt)) % pt
+    pad_h = (ph - (h % ph)) % ph
+    pad_w = (pw - (w % pw)) % pw
+    return torch.nn.functional.pad(x, (0, pad_w, 0, pad_h, 0, pad_t), mode="replicate")
+
+
+def center_down_sample_3d(x, kernel_size):
+    return torch.nn.functional.avg_pool3d(x, kernel_size, stride=kernel_size)
+
+
+def apply_rotary_emb_transposed(
+    hidden_states: torch.Tensor,
+    freqs_cis: torch.Tensor,
+):
+    x_1, x_2 = hidden_states.unflatten(-1, (-1, 2)).unbind(-1)
+    cos, sin = freqs_cis.unsqueeze(-2).chunk(2, dim=-1)
+    out = torch.empty_like(hidden_states)
+    out[..., 0::2] = x_1 * cos[..., 0::2] - x_2 * sin[..., 1::2]
+    out[..., 1::2] = x_1 * sin[..., 1::2] + x_2 * cos[..., 0::2]
+    return out.type_as(hidden_states)
+
+
+def _get_qkv_projections(attn: "HeliosAttention", hidden_states: torch.Tensor, encoder_hidden_states: torch.Tensor):
+    # encoder_hidden_states is only passed for cross-attention
+    if encoder_hidden_states is None:
+        encoder_hidden_states = hidden_states
+
+    if attn.fused_projections:
+        if not attn.is_cross_attention:
+            # In self-attention layers, we can fuse the entire QKV projection into a single linear
+            query, key, value = attn.to_qkv(hidden_states).chunk(3, dim=-1)
+        else:
+            # In cross-attention layers, we can only fuse the KV projections into a single linear
+            query = attn.to_q(hidden_states)
+            key, value = attn.to_kv(encoder_hidden_states).chunk(2, dim=-1)
+    else:
+        query = attn.to_q(hidden_states)
+        key = attn.to_k(encoder_hidden_states)
+        value = attn.to_v(encoder_hidden_states)
+    return query, key, value
+
+
+class HeliosOutputNorm(nn.Module):
+    def __init__(self, dim: int, eps: float = 1e-6, elementwise_affine: bool = False):
+        super().__init__()
+        self.scale_shift_table = nn.Parameter(torch.randn(1, 2, dim) / dim**0.5)
+        self.norm = FP32LayerNorm(dim, eps, elementwise_affine=False)
+
+    def forward(self, hidden_states: torch.Tensor, temb: torch.Tensor, original_context_length: int):
+        temb = temb[:, -original_context_length:, :]
+        shift, scale = (self.scale_shift_table.unsqueeze(0).to(temb.device) + temb.unsqueeze(2)).chunk(2, dim=2)
+        shift, scale = shift.squeeze(2).to(hidden_states.device), scale.squeeze(2).to(hidden_states.device)
+        hidden_states = hidden_states[:, -original_context_length:, :]
+        hidden_states = (self.norm(hidden_states.float()) * (1 + scale) + shift).type_as(hidden_states)
+        return hidden_states
+
+
+class HeliosAttnProcessor:
+    _attention_backend = None
+    _parallel_config = None
+
+    def __init__(self):
+        if not hasattr(F, "scaled_dot_product_attention"):
+            raise ImportError(
+                "HeliosAttnProcessor requires PyTorch 2.0. To use it, please upgrade PyTorch to version 2.0 or higher."
+            )
+
+    def __call__(
+        self,
+        attn: "HeliosAttention",
+        hidden_states: torch.Tensor,
+        encoder_hidden_states: torch.Tensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        rotary_emb: tuple[torch.Tensor, torch.Tensor] | None = None,
+        original_context_length: int = None,
+    ) -> torch.Tensor:
+        query, key, value = _get_qkv_projections(attn, hidden_states, encoder_hidden_states)
+
+        query = attn.norm_q(query)
+        key = attn.norm_k(key)
+
+        query = query.unflatten(2, (attn.heads, -1))
+        key = key.unflatten(2, (attn.heads, -1))
+        value = value.unflatten(2, (attn.heads, -1))
+
+        if rotary_emb is not None:
+            query = apply_rotary_emb_transposed(query, rotary_emb)
+            key = apply_rotary_emb_transposed(key, rotary_emb)
+
+        if not attn.is_cross_attention and attn.is_amplify_history:
+            history_seq_len = hidden_states.shape[1] - original_context_length
+
+            if history_seq_len > 0:
+                scale_key = 1.0 + torch.sigmoid(attn.history_key_scale) * (attn.max_scale - 1.0)
+                if attn.history_scale_mode == "per_head":
+                    scale_key = scale_key.view(1, 1, -1, 1)
+                key = torch.cat([key[:, :history_seq_len] * scale_key, key[:, history_seq_len:]], dim=1)
+
+        hidden_states = dispatch_attention_fn(
+            query,
+            key,
+            value,
+            attn_mask=attention_mask,
+            dropout_p=0.0,
+            is_causal=False,
+            backend=self._attention_backend,
+            # Reference: https://github.com/huggingface/diffusers/pull/12909
+            parallel_config=(self._parallel_config if encoder_hidden_states is None else None),
+        )
+        hidden_states = hidden_states.flatten(2, 3)
+        hidden_states = hidden_states.type_as(query)
+
+        hidden_states = attn.to_out[0](hidden_states)
+        hidden_states = attn.to_out[1](hidden_states)
+        return hidden_states
+
+
+class HeliosAttention(torch.nn.Module, AttentionModuleMixin):
+    _default_processor_cls = HeliosAttnProcessor
+    _available_processors = [HeliosAttnProcessor]
+
+    def __init__(
+        self,
+        dim: int,
+        heads: int = 8,
+        dim_head: int = 64,
+        eps: float = 1e-5,
+        dropout: float = 0.0,
+        added_kv_proj_dim: int | None = None,
+        cross_attention_dim_head: int | None = None,
+        processor=None,
+        is_cross_attention=None,
+        is_amplify_history=False,
+        history_scale_mode="per_head",  # [scalar, per_head]
+    ):
+        super().__init__()
+
+        self.inner_dim = dim_head * heads
+        self.heads = heads
+        self.added_kv_proj_dim = added_kv_proj_dim
+        self.cross_attention_dim_head = cross_attention_dim_head
+        self.kv_inner_dim = self.inner_dim if cross_attention_dim_head is None else cross_attention_dim_head * heads
+
+        self.to_q = torch.nn.Linear(dim, self.inner_dim, bias=True)
+        self.to_k = torch.nn.Linear(dim, self.kv_inner_dim, bias=True)
+        self.to_v = torch.nn.Linear(dim, self.kv_inner_dim, bias=True)
+        self.to_out = torch.nn.ModuleList(
+            [
+                torch.nn.Linear(self.inner_dim, dim, bias=True),
+                torch.nn.Dropout(dropout),
+            ]
+        )
+        self.norm_q = torch.nn.RMSNorm(dim_head * heads, eps=eps, elementwise_affine=True)
+        self.norm_k = torch.nn.RMSNorm(dim_head * heads, eps=eps, elementwise_affine=True)
+
+        self.add_k_proj = self.add_v_proj = None
+        if added_kv_proj_dim is not None:
+            self.add_k_proj = torch.nn.Linear(added_kv_proj_dim, self.inner_dim, bias=True)
+            self.add_v_proj = torch.nn.Linear(added_kv_proj_dim, self.inner_dim, bias=True)
+            self.norm_added_k = torch.nn.RMSNorm(dim_head * heads, eps=eps)
+
+        if is_cross_attention is not None:
+            self.is_cross_attention = is_cross_attention
+        else:
+            self.is_cross_attention = cross_attention_dim_head is not None
+
+        self.set_processor(processor)
+
+        self.is_amplify_history = is_amplify_history
+        if is_amplify_history:
+            if history_scale_mode == "scalar":
+                self.history_key_scale = nn.Parameter(torch.ones(1))
+            elif history_scale_mode == "per_head":
+                self.history_key_scale = nn.Parameter(torch.ones(heads))
+            else:
+                raise ValueError(f"Unknown history_scale_mode: {history_scale_mode}")
+            self.history_scale_mode = history_scale_mode
+            self.max_scale = 10.0
+
+    def fuse_projections(self):
+        if getattr(self, "fused_projections", False):
+            return
+
+        if not self.is_cross_attention:
+            concatenated_weights = torch.cat([self.to_q.weight.data, self.to_k.weight.data, self.to_v.weight.data])
+            concatenated_bias = torch.cat([self.to_q.bias.data, self.to_k.bias.data, self.to_v.bias.data])
+            out_features, in_features = concatenated_weights.shape
+            with torch.device("meta"):
+                self.to_qkv = nn.Linear(in_features, out_features, bias=True)
+            self.to_qkv.load_state_dict(
+                {"weight": concatenated_weights, "bias": concatenated_bias}, strict=True, assign=True
+            )
+        else:
+            concatenated_weights = torch.cat([self.to_k.weight.data, self.to_v.weight.data])
+            concatenated_bias = torch.cat([self.to_k.bias.data, self.to_v.bias.data])
+            out_features, in_features = concatenated_weights.shape
+            with torch.device("meta"):
+                self.to_kv = nn.Linear(in_features, out_features, bias=True)
+            self.to_kv.load_state_dict(
+                {"weight": concatenated_weights, "bias": concatenated_bias}, strict=True, assign=True
+            )
+
+        if self.added_kv_proj_dim is not None:
+            concatenated_weights = torch.cat([self.add_k_proj.weight.data, self.add_v_proj.weight.data])
+            concatenated_bias = torch.cat([self.add_k_proj.bias.data, self.add_v_proj.bias.data])
+            out_features, in_features = concatenated_weights.shape
+            with torch.device("meta"):
+                self.to_added_kv = nn.Linear(in_features, out_features, bias=True)
+            self.to_added_kv.load_state_dict(
+                {"weight": concatenated_weights, "bias": concatenated_bias}, strict=True, assign=True
+            )
+
+        self.fused_projections = True
+
+    @torch.no_grad()
+    def unfuse_projections(self):
+        if not getattr(self, "fused_projections", False):
+            return
+
+        if hasattr(self, "to_qkv"):
+            delattr(self, "to_qkv")
+        if hasattr(self, "to_kv"):
+            delattr(self, "to_kv")
+        if hasattr(self, "to_added_kv"):
+            delattr(self, "to_added_kv")
+
+        self.fused_projections = False
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        encoder_hidden_states: torch.Tensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        rotary_emb: tuple[torch.Tensor, torch.Tensor] | None = None,
+        original_context_length: int = None,
+        **kwargs,
+    ) -> torch.Tensor:
+        return self.processor(
+            self,
+            hidden_states,
+            encoder_hidden_states,
+            attention_mask,
+            rotary_emb,
+            original_context_length,
+            **kwargs,
+        )
+
+
+class HeliosTimeTextEmbedding(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        time_freq_dim: int,
+        time_proj_dim: int,
+        text_embed_dim: int,
+    ):
+        super().__init__()
+
+        self.timesteps_proj = Timesteps(num_channels=time_freq_dim, flip_sin_to_cos=True, downscale_freq_shift=0)
+        self.time_embedder = TimestepEmbedding(in_channels=time_freq_dim, time_embed_dim=dim)
+        self.act_fn = nn.SiLU()
+        self.time_proj = nn.Linear(dim, time_proj_dim)
+        self.text_embedder = PixArtAlphaTextProjection(text_embed_dim, dim, act_fn="gelu_tanh")
+
+    def forward(
+        self,
+        timestep: torch.Tensor,
+        encoder_hidden_states: torch.Tensor | None = None,
+        is_return_encoder_hidden_states: bool = True,
+    ):
+        timestep = self.timesteps_proj(timestep)
+
+        time_embedder_dtype = next(iter(self.time_embedder.parameters())).dtype
+        if timestep.dtype != time_embedder_dtype and time_embedder_dtype != torch.int8:
+            timestep = timestep.to(time_embedder_dtype)
+        temb = self.time_embedder(timestep).type_as(encoder_hidden_states)
+        timestep_proj = self.time_proj(self.act_fn(temb))
+
+        if encoder_hidden_states is not None and is_return_encoder_hidden_states:
+            encoder_hidden_states = self.text_embedder(encoder_hidden_states)
+
+        return temb, timestep_proj, encoder_hidden_states
+
+
+class HeliosRotaryPosEmbed(nn.Module):
+    def __init__(self, rope_dim, theta):
+        super().__init__()
+        self.DT, self.DY, self.DX = rope_dim
+        self.theta = theta
+        self.register_buffer("freqs_base_t", self._get_freqs_base(self.DT), persistent=False)
+        self.register_buffer("freqs_base_y", self._get_freqs_base(self.DY), persistent=False)
+        self.register_buffer("freqs_base_x", self._get_freqs_base(self.DX), persistent=False)
+
+    def _get_freqs_base(self, dim):
+        return 1.0 / (self.theta ** (torch.arange(0, dim, 2, dtype=torch.float32)[: (dim // 2)] / dim))
+
+    @torch.no_grad()
+    def get_frequency_batched(self, freqs_base, pos):
+        freqs = torch.einsum("d,bthw->dbthw", freqs_base, pos)
+        freqs = freqs.repeat_interleave(2, dim=0)
+        return freqs.cos(), freqs.sin()
+
+    @torch.no_grad()
+    @lru_cache(maxsize=32)
+    def _get_spatial_meshgrid(self, height, width, device_str):
+        device = torch.device(device_str)
+        grid_y_coords = torch.arange(height, device=device, dtype=torch.float32)
+        grid_x_coords = torch.arange(width, device=device, dtype=torch.float32)
+        grid_y, grid_x = torch.meshgrid(grid_y_coords, grid_x_coords, indexing="ij")
+        return grid_y, grid_x
+
+    @torch.no_grad()
+    def forward(self, frame_indices, height, width, device):
+        batch_size = frame_indices.shape[0]
+        num_frames = frame_indices.shape[1]
+
+        frame_indices = frame_indices.to(device=device, dtype=torch.float32)
+        grid_y, grid_x = self._get_spatial_meshgrid(height, width, str(device))
+
+        grid_t = frame_indices[:, :, None, None].expand(batch_size, num_frames, height, width)
+        grid_y_batch = grid_y[None, None, :, :].expand(batch_size, num_frames, -1, -1)
+        grid_x_batch = grid_x[None, None, :, :].expand(batch_size, num_frames, -1, -1)
+
+        freqs_cos_t, freqs_sin_t = self.get_frequency_batched(self.freqs_base_t, grid_t)
+        freqs_cos_y, freqs_sin_y = self.get_frequency_batched(self.freqs_base_y, grid_y_batch)
+        freqs_cos_x, freqs_sin_x = self.get_frequency_batched(self.freqs_base_x, grid_x_batch)
+
+        result = torch.cat([freqs_cos_t, freqs_cos_y, freqs_cos_x, freqs_sin_t, freqs_sin_y, freqs_sin_x], dim=0)
+
+        return result.permute(1, 0, 2, 3, 4)
+
+
+@maybe_allow_in_graph
+class HeliosTransformerBlock(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        ffn_dim: int,
+        num_heads: int,
+        qk_norm: str = "rms_norm_across_heads",
+        cross_attn_norm: bool = False,
+        eps: float = 1e-6,
+        added_kv_proj_dim: int | None = None,
+        guidance_cross_attn: bool = False,
+        is_amplify_history: bool = False,
+        history_scale_mode: str = "per_head",  # [scalar, per_head]
+    ):
+        super().__init__()
+
+        # 1. Self-attention
+        self.norm1 = FP32LayerNorm(dim, eps, elementwise_affine=False)
+        self.attn1 = HeliosAttention(
+            dim=dim,
+            heads=num_heads,
+            dim_head=dim // num_heads,
+            eps=eps,
+            cross_attention_dim_head=None,
+            processor=HeliosAttnProcessor(),
+            is_amplify_history=is_amplify_history,
+            history_scale_mode=history_scale_mode,
+        )
+
+        # 2. Cross-attention
+        self.attn2 = HeliosAttention(
+            dim=dim,
+            heads=num_heads,
+            dim_head=dim // num_heads,
+            eps=eps,
+            added_kv_proj_dim=added_kv_proj_dim,
+            cross_attention_dim_head=dim // num_heads,
+            processor=HeliosAttnProcessor(),
+        )
+        self.norm2 = FP32LayerNorm(dim, eps, elementwise_affine=True) if cross_attn_norm else nn.Identity()
+
+        # 3. Feed-forward
+        self.ffn = FeedForward(dim, inner_dim=ffn_dim, activation_fn="gelu-approximate")
+        self.norm3 = FP32LayerNorm(dim, eps, elementwise_affine=False)
+
+        self.scale_shift_table = nn.Parameter(torch.randn(1, 6, dim) / dim**0.5)
+
+        # 4. Guidance cross-attention
+        self.guidance_cross_attn = guidance_cross_attn
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        encoder_hidden_states: torch.Tensor,
+        temb: torch.Tensor,
+        rotary_emb: torch.Tensor,
+        original_context_length: int = None,
+    ) -> torch.Tensor:
+        if temb.ndim == 4:
+            shift_msa, scale_msa, gate_msa, c_shift_msa, c_scale_msa, c_gate_msa = (
+                self.scale_shift_table.unsqueeze(0) + temb.float()
+            ).chunk(6, dim=2)
+            # batch_size, seq_len, 1, inner_dim
+            shift_msa = shift_msa.squeeze(2)
+            scale_msa = scale_msa.squeeze(2)
+            gate_msa = gate_msa.squeeze(2)
+            c_shift_msa = c_shift_msa.squeeze(2)
+            c_scale_msa = c_scale_msa.squeeze(2)
+            c_gate_msa = c_gate_msa.squeeze(2)
+        else:
+            shift_msa, scale_msa, gate_msa, c_shift_msa, c_scale_msa, c_gate_msa = (
+                self.scale_shift_table + temb.float()
+            ).chunk(6, dim=1)
+
+        # 1. Self-attention
+        norm_hidden_states = (self.norm1(hidden_states.float()) * (1 + scale_msa) + shift_msa).type_as(hidden_states)
+        attn_output = self.attn1(
+            norm_hidden_states,
+            None,
+            None,
+            rotary_emb,
+            original_context_length,
+        )
+        hidden_states = (hidden_states.float() + attn_output * gate_msa).type_as(hidden_states)
+
+        # 2. Cross-attention
+        if self.guidance_cross_attn:
+            history_seq_len = hidden_states.shape[1] - original_context_length
+
+            history_hidden_states, hidden_states = torch.split(
+                hidden_states, [history_seq_len, original_context_length], dim=1
+            )
+            norm_hidden_states = self.norm2(hidden_states.float()).type_as(hidden_states)
+            attn_output = self.attn2(
+                norm_hidden_states,
+                encoder_hidden_states,
+                None,
+                None,
+                original_context_length,
+            )
+            hidden_states = hidden_states + attn_output
+            hidden_states = torch.cat([history_hidden_states, hidden_states], dim=1)
+        else:
+            norm_hidden_states = self.norm2(hidden_states.float()).type_as(hidden_states)
+            attn_output = self.attn2(
+                norm_hidden_states,
+                encoder_hidden_states,
+                None,
+                None,
+                original_context_length,
+            )
+            hidden_states = hidden_states + attn_output
+
+        # 3. Feed-forward
+        norm_hidden_states = (self.norm3(hidden_states.float()) * (1 + c_scale_msa) + c_shift_msa).type_as(
+            hidden_states
+        )
+        ff_output = self.ffn(norm_hidden_states)
+        hidden_states = (hidden_states.float() + ff_output.float() * c_gate_msa).type_as(hidden_states)
+
+        return hidden_states
+
+
+class HeliosTransformer3DModel(
+    ModelMixin, ConfigMixin, PeftAdapterMixin, FromOriginalModelMixin, CacheMixin, AttentionMixin
+):
+    r"""
+    A Transformer model for video-like data used in the Helios model.
+
+    Args:
+        patch_size (`tuple[int]`, defaults to `(1, 2, 2)`):
+            3D patch dimensions for video embedding (t_patch, h_patch, w_patch).
+        num_attention_heads (`int`, defaults to `40`):
+            Fixed length for text embeddings.
+        attention_head_dim (`int`, defaults to `128`):
+            The number of channels in each head.
+        in_channels (`int`, defaults to `16`):
+            The number of channels in the input.
+        out_channels (`int`, defaults to `16`):
+            The number of channels in the output.
+        text_dim (`int`, defaults to `512`):
+            Input dimension for text embeddings.
+        freq_dim (`int`, defaults to `256`):
+            Dimension for sinusoidal time embeddings.
+        ffn_dim (`int`, defaults to `13824`):
+            Intermediate dimension in feed-forward network.
+        num_layers (`int`, defaults to `40`):
+            The number of layers of transformer blocks to use.
+        window_size (`tuple[int]`, defaults to `(-1, -1)`):
+            Window size for local attention (-1 indicates global attention).
+        cross_attn_norm (`bool`, defaults to `True`):
+            Enable cross-attention normalization.
+        qk_norm (`bool`, defaults to `True`):
+            Enable query/key normalization.
+        eps (`float`, defaults to `1e-6`):
+            Epsilon value for normalization layers.
+        add_img_emb (`bool`, defaults to `False`):
+            Whether to use img_emb.
+        added_kv_proj_dim (`int`, *optional*, defaults to `None`):
+            The number of channels to use for the added key and value projections. If `None`, no projection is used.
+    """
+
+    _supports_gradient_checkpointing = True
+    _skip_layerwise_casting_patterns = [
+        "patch_embedding",
+        "patch_short",
+        "patch_mid",
+        "patch_long",
+        "condition_embedder",
+        "norm",
+    ]
+    _no_split_modules = ["HeliosTransformerBlock", "HeliosOutputNorm"]
+    _keep_in_fp32_modules = [
+        "time_embedder",
+        "scale_shift_table",
+        "norm1",
+        "norm2",
+        "norm3",
+        "history_key_scale",
+    ]
+    _keys_to_ignore_on_load_unexpected = ["norm_added_q"]
+    _repeated_blocks = ["HeliosTransformerBlock"]
+    _cp_plan = {
+        # Input split at attn level and ffn level.
+        "blocks.*.attn1": {
+            "hidden_states": ContextParallelInput(split_dim=1, expected_dims=3, split_output=False),
+            "rotary_emb": ContextParallelInput(split_dim=1, expected_dims=3, split_output=False),
+        },
+        "blocks.*.attn2": {
+            "hidden_states": ContextParallelInput(split_dim=1, expected_dims=3, split_output=False),
+        },
+        "blocks.*.ffn": {
+            "hidden_states": ContextParallelInput(split_dim=1, expected_dims=3, split_output=False),
+        },
+        # Output gather at attn level and ffn level.
+        **{f"blocks.{i}.attn1": ContextParallelOutput(gather_dim=1, expected_dims=3) for i in range(40)},
+        **{f"blocks.{i}.attn2": ContextParallelOutput(gather_dim=1, expected_dims=3) for i in range(40)},
+        **{f"blocks.{i}.ffn": ContextParallelOutput(gather_dim=1, expected_dims=3) for i in range(40)},
+    }
+
+    @register_to_config
+    def __init__(
+        self,
+        patch_size: tuple[int, ...] = (1, 2, 2),
+        num_attention_heads: int = 40,
+        attention_head_dim: int = 128,
+        in_channels: int = 16,
+        out_channels: int = 16,
+        text_dim: int = 4096,
+        freq_dim: int = 256,
+        ffn_dim: int = 13824,
+        num_layers: int = 40,
+        cross_attn_norm: bool = True,
+        qk_norm: str | None = "rms_norm_across_heads",
+        eps: float = 1e-6,
+        added_kv_proj_dim: int | None = None,
+        rope_dim: tuple[int, ...] = (44, 42, 42),
+        rope_theta: float = 10000.0,
+        guidance_cross_attn: bool = True,
+        zero_history_timestep: bool = True,
+        has_multi_term_memory_patch: bool = True,
+        is_amplify_history: bool = False,
+        history_scale_mode: str = "per_head",  # [scalar, per_head]
+    ) -> None:
+        super().__init__()
+
+        inner_dim = num_attention_heads * attention_head_dim
+        out_channels = out_channels or in_channels
+
+        # 1. Patch & position embedding
+        self.rope = HeliosRotaryPosEmbed(rope_dim=rope_dim, theta=rope_theta)
+        self.patch_embedding = nn.Conv3d(in_channels, inner_dim, kernel_size=patch_size, stride=patch_size)
+
+        # 2. Initial Multi Term Memory Patch
+        self.zero_history_timestep = zero_history_timestep
+        self.inner_dim = inner_dim
+        if has_multi_term_memory_patch:
+            self.patch_short = nn.Conv3d(in_channels, self.inner_dim, kernel_size=patch_size, stride=patch_size)
+            self.patch_mid = nn.Conv3d(
+                in_channels,
+                self.inner_dim,
+                kernel_size=tuple(2 * p for p in patch_size),
+                stride=tuple(2 * p for p in patch_size),
+            )
+            self.patch_long = nn.Conv3d(
+                in_channels,
+                self.inner_dim,
+                kernel_size=tuple(4 * p for p in patch_size),
+                stride=tuple(4 * p for p in patch_size),
+            )
+
+        # 3. Condition embeddings
+        self.condition_embedder = HeliosTimeTextEmbedding(
+            dim=inner_dim,
+            time_freq_dim=freq_dim,
+            time_proj_dim=inner_dim * 6,
+            text_embed_dim=text_dim,
+        )
+
+        # 4. Transformer blocks
+        self.blocks = nn.ModuleList(
+            [
+                HeliosTransformerBlock(
+                    inner_dim,
+                    ffn_dim,
+                    num_attention_heads,
+                    qk_norm,
+                    cross_attn_norm,
+                    eps,
+                    added_kv_proj_dim,
+                    guidance_cross_attn=guidance_cross_attn,
+                    is_amplify_history=is_amplify_history,
+                    history_scale_mode=history_scale_mode,
+                )
+                for _ in range(num_layers)
+            ]
+        )
+
+        # 5. Output norm & projection
+        self.norm_out = HeliosOutputNorm(inner_dim, eps, elementwise_affine=False)
+        self.proj_out = nn.Linear(inner_dim, out_channels * math.prod(patch_size))
+
+        self.gradient_checkpointing = False
+
+    @apply_lora_scale("attention_kwargs")
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        timestep: torch.LongTensor,
+        encoder_hidden_states: torch.Tensor,
+        # ------------ Stage 1 ------------
+        indices_hidden_states=None,
+        indices_latents_history_short=None,
+        indices_latents_history_mid=None,
+        indices_latents_history_long=None,
+        latents_history_short=None,
+        latents_history_mid=None,
+        latents_history_long=None,
+        return_dict: bool = True,
+        attention_kwargs: dict[str, Any] | None = None,
+    ) -> torch.Tensor | dict[str, torch.Tensor]:
+        # 1. Input
+        batch_size = hidden_states.shape[0]
+        p_t, p_h, p_w = self.config.patch_size
+
+        # 2. Process noisy latents
+        hidden_states = self.patch_embedding(hidden_states)
+        _, _, post_patch_num_frames, post_patch_height, post_patch_width = hidden_states.shape
+
+        if indices_hidden_states is None:
+            indices_hidden_states = torch.arange(0, post_patch_num_frames).unsqueeze(0).expand(batch_size, -1)
+
+        hidden_states = hidden_states.flatten(2).transpose(1, 2)
+        rotary_emb = self.rope(
+            frame_indices=indices_hidden_states,
+            height=post_patch_height,
+            width=post_patch_width,
+            device=hidden_states.device,
+        )
+        rotary_emb = rotary_emb.flatten(2).transpose(1, 2)
+        original_context_length = hidden_states.shape[1]
+
+        # 3. Process short history latents
+        if latents_history_short is not None and indices_latents_history_short is not None:
+            latents_history_short = latents_history_short.to(hidden_states)
+            latents_history_short = self.patch_short(latents_history_short)
+            _, _, _, H1, W1 = latents_history_short.shape
+            latents_history_short = latents_history_short.flatten(2).transpose(1, 2)
+
+            rotary_emb_history_short = self.rope(
+                frame_indices=indices_latents_history_short,
+                height=H1,
+                width=W1,
+                device=latents_history_short.device,
+            )
+            rotary_emb_history_short = rotary_emb_history_short.flatten(2).transpose(1, 2)
+
+            hidden_states = torch.cat([latents_history_short, hidden_states], dim=1)
+            rotary_emb = torch.cat([rotary_emb_history_short, rotary_emb], dim=1)
+
+        # 4. Process mid history latents
+        if latents_history_mid is not None and indices_latents_history_mid is not None:
+            latents_history_mid = latents_history_mid.to(hidden_states)
+            latents_history_mid = pad_for_3d_conv(latents_history_mid, (2, 4, 4))
+            latents_history_mid = self.patch_mid(latents_history_mid)
+            latents_history_mid = latents_history_mid.flatten(2).transpose(1, 2)
+
+            rotary_emb_history_mid = self.rope(
+                frame_indices=indices_latents_history_mid,
+                height=H1,
+                width=W1,
+                device=latents_history_mid.device,
+            )
+            rotary_emb_history_mid = pad_for_3d_conv(rotary_emb_history_mid, (2, 2, 2))
+            rotary_emb_history_mid = center_down_sample_3d(rotary_emb_history_mid, (2, 2, 2))
+            rotary_emb_history_mid = rotary_emb_history_mid.flatten(2).transpose(1, 2)
+
+            hidden_states = torch.cat([latents_history_mid, hidden_states], dim=1)
+            rotary_emb = torch.cat([rotary_emb_history_mid, rotary_emb], dim=1)
+
+        # 5. Process long history latents
+        if latents_history_long is not None and indices_latents_history_long is not None:
+            latents_history_long = latents_history_long.to(hidden_states)
+            latents_history_long = pad_for_3d_conv(latents_history_long, (4, 8, 8))
+            latents_history_long = self.patch_long(latents_history_long)
+            latents_history_long = latents_history_long.flatten(2).transpose(1, 2)
+
+            rotary_emb_history_long = self.rope(
+                frame_indices=indices_latents_history_long,
+                height=H1,
+                width=W1,
+                device=latents_history_long.device,
+            )
+            rotary_emb_history_long = pad_for_3d_conv(rotary_emb_history_long, (4, 4, 4))
+            rotary_emb_history_long = center_down_sample_3d(rotary_emb_history_long, (4, 4, 4))
+            rotary_emb_history_long = rotary_emb_history_long.flatten(2).transpose(1, 2)
+
+            hidden_states = torch.cat([latents_history_long, hidden_states], dim=1)
+            rotary_emb = torch.cat([rotary_emb_history_long, rotary_emb], dim=1)
+
+        history_context_length = hidden_states.shape[1] - original_context_length
+
+        if indices_hidden_states is not None and self.zero_history_timestep:
+            timestep_t0 = torch.zeros((1), dtype=timestep.dtype, device=timestep.device)
+            temb_t0, timestep_proj_t0, _ = self.condition_embedder(
+                timestep_t0, encoder_hidden_states, is_return_encoder_hidden_states=False
+            )
+            temb_t0 = temb_t0.unsqueeze(1).expand(batch_size, history_context_length, -1)
+            timestep_proj_t0 = (
+                timestep_proj_t0.unflatten(-1, (6, -1))
+                .view(1, 6, 1, -1)
+                .expand(batch_size, -1, history_context_length, -1)
+            )
+
+        temb, timestep_proj, encoder_hidden_states = self.condition_embedder(timestep, encoder_hidden_states)
+        timestep_proj = timestep_proj.unflatten(-1, (6, -1))
+
+        if indices_hidden_states is not None and not self.zero_history_timestep:
+            main_repeat_size = hidden_states.shape[1]
+        else:
+            main_repeat_size = original_context_length
+        temb = temb.view(batch_size, 1, -1).expand(batch_size, main_repeat_size, -1)
+        timestep_proj = timestep_proj.view(batch_size, 6, 1, -1).expand(batch_size, 6, main_repeat_size, -1)
+
+        if indices_hidden_states is not None and self.zero_history_timestep:
+            temb = torch.cat([temb_t0, temb], dim=1)
+            timestep_proj = torch.cat([timestep_proj_t0, timestep_proj], dim=2)
+
+        if timestep_proj.ndim == 4:
+            timestep_proj = timestep_proj.permute(0, 2, 1, 3)
+
+        # 6. Transformer blocks
+        hidden_states = hidden_states.contiguous()
+        encoder_hidden_states = encoder_hidden_states.contiguous()
+        rotary_emb = rotary_emb.contiguous()
+        if torch.is_grad_enabled() and self.gradient_checkpointing:
+            for block in self.blocks:
+                hidden_states = self._gradient_checkpointing_func(
+                    block,
+                    hidden_states,
+                    encoder_hidden_states,
+                    timestep_proj,
+                    rotary_emb,
+                    original_context_length,
+                )
+        else:
+            for block in self.blocks:
+                hidden_states = block(
+                    hidden_states,
+                    encoder_hidden_states,
+                    timestep_proj,
+                    rotary_emb,
+                    original_context_length,
+                )
+
+        # 7. Normalization
+        hidden_states = self.norm_out(hidden_states, temb, original_context_length)
+        hidden_states = self.proj_out(hidden_states)
+
+        # 8. Unpatchify
+        hidden_states = hidden_states.reshape(
+            batch_size, post_patch_num_frames, post_patch_height, post_patch_width, p_t, p_h, p_w, -1
+        )
+        hidden_states = hidden_states.permute(0, 7, 1, 4, 2, 5, 3, 6)
+        output = hidden_states.flatten(6, 7).flatten(4, 5).flatten(2, 3)
+
+        if not return_dict:
+            return (output,)
+
+        return Transformer2DModelOutput(sample=output)

Helios/_DEV/helios/modules/transformer_helios.py

@@ -0,0 +1,1913 @@
+# Copyright 2025 The Helios Team and The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import glob
+import json
+import math
+import os
+from functools import lru_cache
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import einops
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from einops import rearrange
+
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.loaders import FromOriginalModelMixin, PeftAdapterMixin
+from diffusers.models._modeling_parallel import ContextParallelInput, ContextParallelOutput
+from diffusers.models.attention import AttentionMixin, AttentionModuleMixin, FeedForward
+from diffusers.models.cache_utils import CacheMixin
+from diffusers.models.embeddings import (
+    PixArtAlphaTextProjection,
+    TimestepEmbedding,
+    Timesteps,
+)
+from diffusers.models.modeling_outputs import Transformer2DModelOutput
+from diffusers.models.modeling_utils import ModelMixin
+from diffusers.models.normalization import FP32LayerNorm
+from diffusers.utils import apply_lora_scale, deprecate, logging
+from diffusers.utils.torch_utils import maybe_allow_in_graph
+
+from .helios_kernels import attn_varlen_func, create_navit_attention_masks
+
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+
+def pad_for_3d_conv(x, kernel_size):
+    b, c, t, h, w = x.shape
+    pt, ph, pw = kernel_size
+    pad_t = (pt - (t % pt)) % pt
+    pad_h = (ph - (h % ph)) % ph
+    pad_w = (pw - (w % pw)) % pw
+    return torch.nn.functional.pad(x, (0, pad_w, 0, pad_h, 0, pad_t), mode="replicate")
+
+
+def center_down_sample_3d(x, kernel_size):
+    return torch.nn.functional.avg_pool3d(x, kernel_size, stride=kernel_size)
+
+
+def apply_rotary_emb_transposed(
+    hidden_states: torch.Tensor,
+    freqs_cis: torch.Tensor,
+):
+    x_1, x_2 = hidden_states.unflatten(-1, (-1, 2)).unbind(-1)
+    cos, sin = freqs_cis.unsqueeze(-2).chunk(2, dim=-1)
+    out = torch.empty_like(hidden_states)
+    out[..., 0::2] = x_1 * cos[..., 0::2] - x_2 * sin[..., 1::2]
+    out[..., 1::2] = x_1 * sin[..., 1::2] + x_2 * cos[..., 0::2]
+    return out.type_as(hidden_states)
+
+
+def _get_qkv_projections(attn: "HeliosAttention", hidden_states: torch.Tensor, encoder_hidden_states: torch.Tensor):
+    # encoder_hidden_states is only passed for cross-attention
+    if encoder_hidden_states is None:
+        encoder_hidden_states = hidden_states
+
+    if attn.fused_projections:
+        if not attn.is_cross_attention:
+            # In self-attention layers, we can fuse the entire QKV projection into a single linear
+            query, key, value = attn.to_qkv(hidden_states).chunk(3, dim=-1)
+        else:
+            # In cross-attention layers, we can only fuse the KV projections into a single linear
+            query = attn.to_q(hidden_states)
+            key, value = attn.to_kv(encoder_hidden_states).chunk(2, dim=-1)
+    else:
+        query = attn.to_q(hidden_states)
+        key = attn.to_k(encoder_hidden_states)
+        value = attn.to_v(encoder_hidden_states)
+    return query, key, value
+
+
+class Discriminator3DHead(nn.Module):
+    def __init__(self, input_channel, cond_map_dim=768):
+        super().__init__()
+
+        self.head3d = nn.Sequential(
+            nn.Conv3d(input_channel, cond_map_dim, 3, stride=(1, 1, 1), padding=(1, 1, 1)),  # [31, 8, 8]
+            nn.GroupNorm(32, cond_map_dim),
+            nn.SiLU(False),
+            nn.Conv3d(cond_map_dim, cond_map_dim, 4, stride=[2, 2, 2], padding=(1, 1, 1)),  #  [15, 4, 4]
+            nn.GroupNorm(32, cond_map_dim),
+            nn.SiLU(False),
+            nn.Conv3d(cond_map_dim, cond_map_dim, 4, stride=[2, 2, 2], padding=(1, 1, 1)),  #  [7, 2, 2]
+            nn.GroupNorm(32, cond_map_dim),
+            nn.SiLU(False),
+            nn.Conv3d(cond_map_dim, cond_map_dim, 3, stride=[2, 1, 1], padding=(1, 1, 1)),  #  [3, 2, 2]
+            nn.GroupNorm(32, cond_map_dim),
+            nn.SiLU(False),
+            nn.Conv3d(cond_map_dim, cond_map_dim, 3, stride=[2, 1, 1], padding=(1, 1, 1)),  #  [1, 2, 2]
+            nn.GroupNorm(32, cond_map_dim),
+            nn.SiLU(False),
+            nn.Conv3d(
+                cond_map_dim, cond_map_dim, kernel_size=[1, 3, 3], stride=[1, 1, 1], padding=(0, 1, 1)
+            ),  #  [b, 768, 1, 1, 2]
+            nn.GroupNorm(32, cond_map_dim),
+            nn.SiLU(False),
+            nn.AdaptiveAvgPool3d((1, 1, 1)),
+            nn.Flatten(),
+            nn.Linear(cond_map_dim, 1),
+        )
+
+    def forward(self, x):
+        return self.head3d(x)
+
+
+class LoRALinearLayer(nn.Module):
+    def __init__(
+        self,
+        in_features: int,
+        out_features: int,
+        rank: int = 128,
+        device="cuda",
+        dtype: Optional[torch.dtype] = torch.float32,
+    ):
+        super().__init__()
+        self.down = nn.Linear(in_features, rank, bias=False, device=device, dtype=dtype)
+        self.up = nn.Linear(rank, out_features, bias=False, device=device, dtype=dtype)
+        self.rank = rank
+        self.out_features = out_features
+        self.in_features = in_features
+
+        nn.init.normal_(self.down.weight, std=1 / rank)
+        nn.init.zeros_(self.up.weight)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        orig_dtype = hidden_states.dtype
+        dtype = self.down.weight.dtype
+
+        down_hidden_states = self.down(hidden_states.to(dtype))
+        up_hidden_states = self.up(down_hidden_states)
+        return up_hidden_states.to(orig_dtype)
+
+
+class HeliosOutputNorm(nn.Module):
+    def __init__(self, dim: int, eps: float = 1e-6, elementwise_affine: bool = False):
+        super().__init__()
+        self.scale_shift_table = nn.Parameter(torch.randn(1, 2, dim) / dim**0.5)
+        self.norm = FP32LayerNorm(dim, eps, elementwise_affine=False)
+
+    def forward(self, hidden_states: torch.Tensor, temb: torch.Tensor, original_context_length: int):
+        temb = temb[:, -original_context_length:, :]
+        shift, scale = (self.scale_shift_table.unsqueeze(0).to(temb.device) + temb.unsqueeze(2)).chunk(2, dim=2)
+        shift, scale = shift.squeeze(2).to(hidden_states.device), scale.squeeze(2).to(hidden_states.device)
+        hidden_states = hidden_states[:, -original_context_length:, :]
+        hidden_states = (self.norm(hidden_states.float()) * (1 + scale) + shift).type_as(hidden_states)
+        return hidden_states
+
+
+class HeliosAttnProcessor:
+    _attention_backend = None
+    _parallel_config = None
+
+    def __init__(self):
+        if not hasattr(F, "scaled_dot_product_attention"):
+            raise ImportError(
+                "HeliosAttnProcessor requires PyTorch 2.0. To use it, please upgrade PyTorch to version 2.0 or higher."
+            )
+
+        self.kv_cache = None
+        self.cache_enabled = False
+
+    def enable_cache(self):
+        self.cache_enabled = True
+        self.kv_cache = None
+
+    def disable_cache(self):
+        self.cache_enabled = False
+        self.kv_cache = None
+
+    def clear_cache(self):
+        self.kv_cache = None
+
+    def __call__(
+        self,
+        attn: "HeliosAttention",
+        hidden_states: torch.Tensor,
+        encoder_hidden_states: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        rotary_emb: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
+        original_context_length: int = None,
+        original_context_length_list: list = None,
+        enable_navit: bool = False,
+        is_first_denoising_step: bool = False,
+    ) -> torch.Tensor:
+        use_cache = False
+        history_seq_len = None
+        enable_cross = attn.is_cross_attention
+
+        if not enable_cross:
+            history_seq_len = (hidden_states.shape[1] - original_context_length) // len(original_context_length_list)
+
+        if attn.restrict_self_attn:
+            use_cache = self.cache_enabled and not is_first_denoising_step and self.kv_cache is not None
+            assert not (use_cache and enable_navit), "Cache and NAViT are incompatible"
+
+            if use_cache:
+                key_history = self.kv_cache["key_history"]
+                value_history = self.kv_cache["value_history"]
+                history_hidden_states = self.kv_cache["history_hidden_states"]
+
+                hidden_states = hidden_states[:, history_seq_len:]
+                rotary_emb = rotary_emb[:, history_seq_len:] if rotary_emb is not None else None
+
+        query, key, value = _get_qkv_projections(attn, hidden_states, encoder_hidden_states)
+
+        query = attn.norm_q(query)
+        key = attn.norm_k(key)
+
+        if attn.restrict_self_attn and not use_cache:
+            if enable_navit:
+                seq_start = 0
+                num_seqs = len(original_context_length_list)
+                query_list = [None] * num_seqs
+                key_list = [None] * num_seqs
+                value_list = [None] * num_seqs
+                query_history_list = [None] * num_seqs
+                key_history_list = [None] * num_seqs
+                value_history_list = [None] * num_seqs
+
+                if attn.restrict_lora:
+                    history_hidden_states_list = [None] * num_seqs
+
+                if rotary_emb is not None:
+                    rotary_emb_list = [None] * num_seqs
+                    history_rotary_emb_list = [None] * num_seqs
+
+                for idx, cur_seq_len in enumerate(original_context_length_list[::-1]):
+                    seq_end = seq_start + cur_seq_len + history_seq_len
+
+                    slice_qkv = slice(seq_start, seq_end)
+                    cur_query = query[:, slice_qkv, :]
+                    cur_key = key[:, slice_qkv, :]
+                    cur_value = value[:, slice_qkv, :]
+
+                    query_history_list[idx] = cur_query[:, :history_seq_len]
+                    query_list[idx] = cur_query[:, history_seq_len:]
+
+                    key_history_list[idx] = cur_key[:, :history_seq_len]
+                    key_list[idx] = cur_key[:, history_seq_len:]
+
+                    value_history_list[idx] = cur_value[:, :history_seq_len]
+                    value_list[idx] = cur_value[:, history_seq_len:]
+
+                    if attn.restrict_lora:
+                        cur_hidden = hidden_states[:, slice_qkv, :]
+                        history_hidden_states_list[idx] = cur_hidden[:, :history_seq_len]
+
+                    if rotary_emb is not None:
+                        cur_rotary_emb = rotary_emb[:, slice_qkv, :]
+                        history_rotary_emb_list[idx] = cur_rotary_emb[:, :history_seq_len]
+                        rotary_emb_list[idx] = cur_rotary_emb[:, history_seq_len:]
+
+                    seq_start = seq_end
+
+                query = torch.cat(query_list, dim=1)
+                key = torch.cat(key_list, dim=1)
+                value = torch.cat(value_list, dim=1)
+                query_history = torch.cat(query_history_list, dim=1)
+                key_history = torch.cat(key_history_list, dim=1)
+                value_history = torch.cat(value_history_list, dim=1)
+
+                if attn.restrict_lora:
+                    history_hidden_states = torch.cat(history_hidden_states_list, dim=1)
+                    query_history = query_history + attn.q_loras(history_hidden_states)
+                    key_history = key_history + attn.k_loras(history_hidden_states)
+                    value_history = value_history + attn.v_loras(history_hidden_states)
+
+                query_history = query_history.unflatten(2, (attn.heads, -1))
+                key_history = key_history.unflatten(2, (attn.heads, -1))
+                value_history = value_history.unflatten(2, (attn.heads, -1))
+
+                if rotary_emb is not None:
+                    rotary_emb = torch.cat(rotary_emb_list, dim=1)
+                    history_rotary_emb = torch.cat(history_rotary_emb_list, dim=1)
+                    query_history = apply_rotary_emb_transposed(query_history, history_rotary_emb)
+                    key_history = apply_rotary_emb_transposed(key_history, history_rotary_emb)
+            else:
+                history_hidden_states = hidden_states[:, :history_seq_len]
+                query_history, query = query[:, :history_seq_len], query[:, history_seq_len:]
+                key_history, key = key[:, :history_seq_len], key[:, history_seq_len:]
+                value_history, value = value[:, :history_seq_len], value[:, history_seq_len:]
+
+                if attn.restrict_lora:
+                    query_history = query_history + attn.q_loras(history_hidden_states)
+                    key_history = key_history + attn.k_loras(history_hidden_states)
+                    value_history = value_history + attn.v_loras(history_hidden_states)
+
+                query_history = query_history.unflatten(2, (attn.heads, -1))
+                key_history = key_history.unflatten(2, (attn.heads, -1))
+                value_history = value_history.unflatten(2, (attn.heads, -1))
+
+                if rotary_emb is not None:
+                    history_rotary_emb, rotary_emb = (rotary_emb[:, :history_seq_len], rotary_emb[:, history_seq_len:])
+                    query_history = apply_rotary_emb_transposed(query_history, history_rotary_emb)
+                    key_history = apply_rotary_emb_transposed(key_history, history_rotary_emb)
+
+        query = query.unflatten(2, (attn.heads, -1))
+        key = key.unflatten(2, (attn.heads, -1))
+        value = value.unflatten(2, (attn.heads, -1))
+
+        if rotary_emb is not None:
+            query = apply_rotary_emb_transposed(query, rotary_emb)
+            key = apply_rotary_emb_transposed(key, rotary_emb)
+
+        if attn.restrict_self_attn:
+            if use_cache:
+                key = torch.cat([key_history, key], dim=1)
+                value = torch.cat([value_history, value], dim=1)
+            else:
+                if enable_navit:
+                    num_seqs = len(original_context_length_list)
+
+                    key_list = [None] * num_seqs
+                    value_list = [None] * num_seqs
+
+                    seq_start = 0
+                    seq_start_history = 0
+
+                    for idx, cur_seq_len in enumerate(original_context_length_list[::-1]):
+                        key_list[idx] = torch.cat(
+                            [
+                                key_history[:, seq_start_history : seq_start_history + history_seq_len, :],
+                                key[:, seq_start : seq_start + cur_seq_len, :],
+                            ],
+                            dim=1,
+                        )
+
+                        value_list[idx] = torch.cat(
+                            [
+                                value_history[:, seq_start_history : seq_start_history + history_seq_len, :],
+                                value[:, seq_start : seq_start + cur_seq_len, :],
+                            ],
+                            dim=1,
+                        )
+
+                        seq_start += cur_seq_len
+                        seq_start_history += history_seq_len
+
+                    key = torch.cat(key_list, dim=1)
+                    value = torch.cat(value_list, dim=1)
+
+                    history_hidden_states = attn_varlen_func(
+                        query_history,
+                        key_history,
+                        value_history,
+                        attention_mask=attention_mask[1],
+                    )
+                else:
+                    key = torch.cat([key_history, key], dim=1)
+                    value = torch.cat([value_history, value], dim=1)
+
+                    history_hidden_states = attn_varlen_func(
+                        query_history,
+                        key_history,
+                        value_history,
+                    )
+                history_hidden_states = history_hidden_states.flatten(2, 3)
+                history_hidden_states = history_hidden_states.type_as(query)
+
+                if self.cache_enabled and is_first_denoising_step and not enable_navit:
+                    self.kv_cache = {
+                        "key_history": key_history,
+                        "value_history": value_history,
+                        "history_hidden_states": history_hidden_states,
+                    }
+
+        if enable_cross and enable_navit:
+            key = key.repeat(1, len(original_context_length_list), 1, 1)
+            value = value.repeat(1, len(original_context_length_list), 1, 1)
+
+        if not enable_cross and history_seq_len > 0 and attn.is_amplify_history:
+            scale_key = attn.get_scale_key()
+            if attn.history_scale_mode == "per_head":
+                scale_key = scale_key.view(1, 1, -1, 1)
+
+            if enable_navit:
+                key_new = key.clone()
+                seq_start = 0
+                for cur_seq_len in original_context_length_list[::-1]:
+                    hist_slice = slice(seq_start, seq_start + history_seq_len)
+                    key_new[:, hist_slice] = key[:, hist_slice] * scale_key
+                    seq_start += history_seq_len + cur_seq_len
+                key = key_new
+            else:
+                key = torch.cat([key[:, :history_seq_len] * scale_key, key[:, history_seq_len:]], dim=1)
+
+        hidden_states = attn_varlen_func(
+            query,
+            key,
+            value,
+            attention_mask=attention_mask[0] if isinstance(attention_mask, list) else attention_mask,
+        )
+        hidden_states = hidden_states.flatten(2, 3)
+        hidden_states = hidden_states.type_as(query)
+
+        if attn.restrict_self_attn:
+            if enable_navit:
+                num_seqs = len(original_context_length_list)
+                hidden_states_list = [None] * num_seqs
+
+                seq_start = 0
+                seq_start_history = 0
+
+                for idx, cur_seq_len in enumerate(original_context_length_list[::-1]):
+                    hidden_states_list[idx] = torch.cat(
+                        [
+                            history_hidden_states[:, seq_start_history : seq_start_history + history_seq_len, :],
+                            hidden_states[:, seq_start : seq_start + cur_seq_len, :],
+                        ],
+                        dim=1,
+                    )
+
+                    seq_start += cur_seq_len
+                    seq_start_history += history_seq_len
+
+                hidden_states = torch.cat(hidden_states_list, dim=1)
+            else:
+                hidden_states = torch.cat([history_hidden_states, hidden_states], dim=1)
+
+        hidden_states = attn.to_out[0](hidden_states)
+        hidden_states = attn.to_out[1](hidden_states)
+        return hidden_states
+
+
+class HeliosAttnProcessor2_0:
+    def __new__(cls, *args, **kwargs):
+        deprecation_message = (
+            "The HeliosAttnProcessor2_0 class is deprecated and will be removed in a future version. "
+            "Please use HeliosAttnProcessor instead. "
+        )
+        deprecate("HeliosAttnProcessor2_0", "1.0.0", deprecation_message, standard_warn=False)
+        return HeliosAttnProcessor(*args, **kwargs)
+
+
+class HeliosAttention(torch.nn.Module, AttentionModuleMixin):
+    _default_processor_cls = HeliosAttnProcessor
+    _available_processors = [HeliosAttnProcessor]
+
+    def __init__(
+        self,
+        dim: int,
+        heads: int = 8,
+        dim_head: int = 64,
+        eps: float = 1e-5,
+        dropout: float = 0.0,
+        added_kv_proj_dim: Optional[int] = None,
+        cross_attention_dim_head: Optional[int] = None,
+        processor=None,
+        is_cross_attention=None,
+        restrict_self_attn=False,
+        is_train_restrict_lora=False,
+        restrict_lora=False,
+        restrict_lora_rank=128,
+        is_amplify_history=False,
+        history_scale_mode="per_head",  # [scalar, per_head]
+    ):
+        super().__init__()
+
+        self.inner_dim = dim_head * heads
+        self.heads = heads
+        self.added_kv_proj_dim = added_kv_proj_dim
+        self.cross_attention_dim_head = cross_attention_dim_head
+        self.kv_inner_dim = self.inner_dim if cross_attention_dim_head is None else cross_attention_dim_head * heads
+
+        self.to_q = torch.nn.Linear(dim, self.inner_dim, bias=True)
+        self.to_k = torch.nn.Linear(dim, self.kv_inner_dim, bias=True)
+        self.to_v = torch.nn.Linear(dim, self.kv_inner_dim, bias=True)
+        self.to_out = torch.nn.ModuleList(
+            [
+                torch.nn.Linear(self.inner_dim, dim, bias=True),
+                torch.nn.Dropout(dropout),
+            ]
+        )
+        self.norm_q = torch.nn.RMSNorm(dim_head * heads, eps=eps, elementwise_affine=True)
+        self.norm_k = torch.nn.RMSNorm(dim_head * heads, eps=eps, elementwise_affine=True)
+
+        self.add_k_proj = self.add_v_proj = None
+        if added_kv_proj_dim is not None:
+            self.add_k_proj = torch.nn.Linear(added_kv_proj_dim, self.inner_dim, bias=True)
+            self.add_v_proj = torch.nn.Linear(added_kv_proj_dim, self.inner_dim, bias=True)
+            self.norm_added_k = torch.nn.RMSNorm(dim_head * heads, eps=eps)
+
+        if is_cross_attention is not None:
+            self.is_cross_attention = is_cross_attention
+        else:
+            self.is_cross_attention = cross_attention_dim_head is not None
+
+        self.set_processor(processor)
+
+        self.restrict_self_attn = restrict_self_attn
+        self.restrict_lora = restrict_lora
+        if restrict_lora:
+            self.init_lora(is_train=is_train_restrict_lora, lora_rank=restrict_lora_rank)
+
+        self.is_amplify_history = is_amplify_history
+        if is_amplify_history:
+            if history_scale_mode == "scalar":
+                self.history_key_scale = nn.Parameter(torch.ones(1))
+            elif history_scale_mode == "per_head":
+                self.history_key_scale = nn.Parameter(torch.ones(heads))
+            else:
+                raise ValueError(f"Unknown history_scale_mode: {history_scale_mode}")
+            self.history_scale_mode = history_scale_mode
+            self.max_scale = 10.0
+            self.register_buffer("_scale_cache", None)
+
+    def get_scale_key(self):
+        if self.history_key_scale.requires_grad:
+            scale = 1.0 + torch.sigmoid(self.history_key_scale) * (self.max_scale - 1.0)
+        else:
+            if self._scale_cache is None:
+                self._scale_cache = 1.0 + torch.sigmoid(self.history_key_scale) * (self.max_scale - 1.0)
+            scale = self._scale_cache
+        return scale
+
+    def init_lora(self, is_train=False, lora_rank=128):
+        dim = self.inner_dim
+        self.q_loras = LoRALinearLayer(dim, dim, rank=lora_rank)
+        self.k_loras = LoRALinearLayer(dim, dim, rank=lora_rank)
+        self.v_loras = LoRALinearLayer(dim, dim, rank=lora_rank)
+
+        requires_grad = is_train
+        for lora in [self.q_loras, self.k_loras, self.v_loras]:
+            for param in lora.parameters():
+                param.requires_grad = requires_grad
+
+    def fuse_projections(self):
+        if getattr(self, "fused_projections", False):
+            return
+
+        if not self.is_cross_attention:
+            concatenated_weights = torch.cat([self.to_q.weight.data, self.to_k.weight.data, self.to_v.weight.data])
+            concatenated_bias = torch.cat([self.to_q.bias.data, self.to_k.bias.data, self.to_v.bias.data])
+            out_features, in_features = concatenated_weights.shape
+            with torch.device("meta"):
+                self.to_qkv = nn.Linear(in_features, out_features, bias=True)
+            self.to_qkv.load_state_dict(
+                {"weight": concatenated_weights, "bias": concatenated_bias}, strict=True, assign=True
+            )
+        else:
+            concatenated_weights = torch.cat([self.to_k.weight.data, self.to_v.weight.data])
+            concatenated_bias = torch.cat([self.to_k.bias.data, self.to_v.bias.data])
+            out_features, in_features = concatenated_weights.shape
+            with torch.device("meta"):
+                self.to_kv = nn.Linear(in_features, out_features, bias=True)
+            self.to_kv.load_state_dict(
+                {"weight": concatenated_weights, "bias": concatenated_bias}, strict=True, assign=True
+            )
+
+        if self.added_kv_proj_dim is not None:
+            concatenated_weights = torch.cat([self.add_k_proj.weight.data, self.add_v_proj.weight.data])
+            concatenated_bias = torch.cat([self.add_k_proj.bias.data, self.add_v_proj.bias.data])
+            out_features, in_features = concatenated_weights.shape
+            with torch.device("meta"):
+                self.to_added_kv = nn.Linear(in_features, out_features, bias=True)
+            self.to_added_kv.load_state_dict(
+                {"weight": concatenated_weights, "bias": concatenated_bias}, strict=True, assign=True
+            )
+
+        self.fused_projections = True
+
+    @torch.no_grad()
+    def unfuse_projections(self):
+        if not getattr(self, "fused_projections", False):
+            return
+
+        if hasattr(self, "to_qkv"):
+            delattr(self, "to_qkv")
+        if hasattr(self, "to_kv"):
+            delattr(self, "to_kv")
+        if hasattr(self, "to_added_kv"):
+            delattr(self, "to_added_kv")
+
+        self.fused_projections = False
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        encoder_hidden_states: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        rotary_emb: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
+        original_context_length: int = None,
+        original_context_length_list: list = None,
+        enable_navit: bool = False,
+        **kwargs,
+    ) -> torch.Tensor:
+        return self.processor(
+            self,
+            hidden_states,
+            encoder_hidden_states,
+            attention_mask,
+            rotary_emb,
+            original_context_length,
+            original_context_length_list,
+            enable_navit,
+            **kwargs,
+        )
+
+
+class HeliosTimeTextEmbedding(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        time_freq_dim: int,
+        time_proj_dim: int,
+        text_embed_dim: int,
+    ):
+        super().__init__()
+
+        self.timesteps_proj = Timesteps(num_channels=time_freq_dim, flip_sin_to_cos=True, downscale_freq_shift=0)
+        self.time_embedder = TimestepEmbedding(in_channels=time_freq_dim, time_embed_dim=dim)
+        self.act_fn = nn.SiLU()
+        self.time_proj = nn.Linear(dim, time_proj_dim)
+        self.text_embedder = PixArtAlphaTextProjection(text_embed_dim, dim, act_fn="gelu_tanh")
+
+    def forward(
+        self,
+        timestep: torch.Tensor,
+        encoder_hidden_states: Optional[torch.Tensor] = None,
+        is_return_encoder_hidden_states: bool = True,
+    ):
+        B = None
+        F = None
+        if timestep.ndim == 2:
+            B, F = timestep.shape
+            timestep = timestep.flatten()
+
+        timestep = self.timesteps_proj(timestep)  # torch.Size([2]) -> torch.Size([2, 256])
+
+        time_embedder_dtype = next(iter(self.time_embedder.parameters())).dtype
+        if timestep.dtype != time_embedder_dtype and time_embedder_dtype != torch.int8:
+            timestep = timestep.to(time_embedder_dtype)
+        temb = self.time_embedder(timestep).type_as(encoder_hidden_states)  # torch.Size([2, 1536])
+        timestep_proj = self.time_proj(self.act_fn(temb))  # torch.Size([2, 9216]
+
+        if B is not None and F is not None:
+            temb = temb.reshape(B, F, -1)
+            timestep_proj = timestep_proj.reshape(B, F, -1)
+
+        if encoder_hidden_states is not None and is_return_encoder_hidden_states:
+            encoder_hidden_states = self.text_embedder(encoder_hidden_states)  # torch.Size([2, 512, 1536])
+
+        return temb, timestep_proj, encoder_hidden_states
+
+
+class HeliosRotaryPosEmbed(nn.Module):
+    def __init__(self, rope_dim, theta):
+        super().__init__()
+        self.DT, self.DY, self.DX = rope_dim
+        self.theta = theta
+        self.register_buffer("freqs_base_t", self._get_freqs_base(self.DT), persistent=False)
+        self.register_buffer("freqs_base_y", self._get_freqs_base(self.DY), persistent=False)
+        self.register_buffer("freqs_base_x", self._get_freqs_base(self.DX), persistent=False)
+
+    def _get_freqs_base(self, dim):
+        return 1.0 / (self.theta ** (torch.arange(0, dim, 2, dtype=torch.float32)[: (dim // 2)] / dim))
+
+    @torch.no_grad()
+    def get_frequency_batched(self, freqs_base, pos):
+        freqs = torch.einsum("d,bthw->dbthw", freqs_base, pos)
+        freqs = freqs.repeat_interleave(2, dim=0)
+        return freqs.cos(), freqs.sin()
+
+    @torch.no_grad()
+    @lru_cache(maxsize=32)
+    def _get_spatial_meshgrid(self, height, width, device_str):
+        device = torch.device(device_str)
+        gy = torch.arange(height, device=device, dtype=torch.float32)
+        gx = torch.arange(width, device=device, dtype=torch.float32)
+        GY, GX = torch.meshgrid(gy, gx, indexing="ij")
+        return GY, GX
+
+    @torch.no_grad()
+    def forward(self, frame_indices, height, width, device):
+        B = frame_indices.shape[0]
+        T = frame_indices.shape[1]
+
+        frame_indices = frame_indices.to(device=device, dtype=torch.float32)
+        GY, GX = self._get_spatial_meshgrid(height, width, str(device))
+
+        GT = frame_indices[:, :, None, None].expand(B, T, height, width)
+        GY_batch = GY[None, None, :, :].expand(B, T, -1, -1)
+        GX_batch = GX[None, None, :, :].expand(B, T, -1, -1)
+
+        FCT, FST = self.get_frequency_batched(self.freqs_base_t, GT)
+        FCY, FSY = self.get_frequency_batched(self.freqs_base_y, GY_batch)
+        FCX, FSX = self.get_frequency_batched(self.freqs_base_x, GX_batch)
+
+        result = torch.cat([FCT, FCY, FCX, FST, FSY, FSX], dim=0)
+
+        return result.permute(1, 0, 2, 3, 4)
+
+
+@maybe_allow_in_graph
+class HeliosTransformerBlock(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        ffn_dim: int,
+        num_heads: int,
+        qk_norm: str = "rms_norm_across_heads",
+        cross_attn_norm: bool = False,
+        eps: float = 1e-6,
+        added_kv_proj_dim: Optional[int] = None,
+        restrict_self_attn: bool = False,
+        guidance_cross_attn: bool = False,
+        is_train_restrict_lora: bool = False,
+        restrict_lora: bool = False,
+        restrict_lora_rank: int = 128,
+        is_amplify_history: bool = False,
+        history_scale_mode: str = "per_head",  # [scalar, per_head],
+    ):
+        super().__init__()
+
+        # 1. Self-attention
+        self.norm1 = FP32LayerNorm(dim, eps, elementwise_affine=False)
+        self.attn1 = HeliosAttention(
+            dim=dim,
+            heads=num_heads,
+            dim_head=dim // num_heads,
+            eps=eps,
+            cross_attention_dim_head=None,
+            processor=HeliosAttnProcessor(),
+            restrict_self_attn=restrict_self_attn,
+            is_train_restrict_lora=is_train_restrict_lora,
+            restrict_lora=restrict_lora,
+            restrict_lora_rank=restrict_lora_rank,
+            is_amplify_history=is_amplify_history,
+            history_scale_mode=history_scale_mode,
+        )
+
+        # 2. Cross-attention
+        self.attn2 = HeliosAttention(
+            dim=dim,
+            heads=num_heads,
+            dim_head=dim // num_heads,
+            eps=eps,
+            added_kv_proj_dim=added_kv_proj_dim,
+            cross_attention_dim_head=dim // num_heads,
+            processor=HeliosAttnProcessor(),
+        )
+        self.norm2 = FP32LayerNorm(dim, eps, elementwise_affine=True) if cross_attn_norm else nn.Identity()
+
+        # 3. Feed-forward
+        self.ffn = FeedForward(dim, inner_dim=ffn_dim, activation_fn="gelu-approximate")
+        self.norm3 = FP32LayerNorm(dim, eps, elementwise_affine=False)
+
+        self.scale_shift_table = nn.Parameter(torch.randn(1, 6, dim) / dim**0.5)
+
+        # 4. Guidance cross-attention
+        self.guidance_cross_attn = guidance_cross_attn
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        encoder_hidden_states: torch.Tensor,
+        temb: torch.Tensor,
+        rotary_emb: torch.Tensor,
+        navit_hidden_attention_mask: Optional[torch.Tensor] = None,
+        navit_encoder_attention_mask: Optional[torch.Tensor] = None,
+        original_context_length: int = None,
+        original_context_length_list: list = None,
+        is_first_denoising_step: bool = False,
+    ) -> torch.Tensor:
+        enable_navit = False
+        if len(original_context_length_list) > 1:
+            enable_navit = True
+
+        if temb.ndim == 4:
+            shift_msa, scale_msa, gate_msa, c_shift_msa, c_scale_msa, c_gate_msa = (
+                self.scale_shift_table.unsqueeze(0) + temb.float()
+            ).chunk(6, dim=2)
+            # batch_size, seq_len, 1, inner_dim
+            shift_msa = shift_msa.squeeze(2)
+            scale_msa = scale_msa.squeeze(2)
+            gate_msa = gate_msa.squeeze(2)
+            c_shift_msa = c_shift_msa.squeeze(2)
+            c_scale_msa = c_scale_msa.squeeze(2)
+            c_gate_msa = c_gate_msa.squeeze(2)
+        else:
+            shift_msa, scale_msa, gate_msa, c_shift_msa, c_scale_msa, c_gate_msa = (
+                self.scale_shift_table + temb.float()
+            ).chunk(6, dim=1)
+
+        # 1. Self-attention
+        norm_hidden_states = (self.norm1(hidden_states.float()) * (1 + scale_msa) + shift_msa).type_as(hidden_states)
+        attn_output = self.attn1(
+            norm_hidden_states,
+            None,
+            navit_hidden_attention_mask,
+            rotary_emb,
+            original_context_length,
+            original_context_length_list,
+            enable_navit,
+            is_first_denoising_step=is_first_denoising_step,
+        )
+        hidden_states = (hidden_states.float() + attn_output * gate_msa).type_as(hidden_states)
+
+        # 2. Cross-attention
+        if self.guidance_cross_attn:
+            history_seq_len = (hidden_states.shape[1] - original_context_length) // len(original_context_length_list)
+
+            if enable_navit:
+                num_seqs = len(original_context_length_list)
+
+                hidden_states_list = [None] * num_seqs
+                history_hidden_states_list = [None] * num_seqs
+
+                seq_start = 0
+                for idx, cur_seq_len in enumerate(original_context_length_list[::-1]):
+                    seq_end = seq_start + cur_seq_len + history_seq_len
+                    cur_hidden_states = hidden_states[:, seq_start:seq_end, :]
+
+                    history_hidden_states_list[idx] = cur_hidden_states[:, :history_seq_len]
+                    hidden_states_list[idx] = cur_hidden_states[:, history_seq_len:]
+
+                    seq_start += cur_seq_len + history_seq_len
+
+                hidden_states = torch.cat(hidden_states_list, dim=1)
+
+                norm_hidden_states = self.norm2(hidden_states.float()).type_as(hidden_states)
+                attn_output = self.attn2(
+                    norm_hidden_states,
+                    encoder_hidden_states,
+                    navit_encoder_attention_mask,
+                    None,
+                    original_context_length,
+                    original_context_length_list,
+                    enable_navit,
+                )
+                hidden_states = hidden_states + attn_output
+
+                seq_start = 0
+                for idx, cur_seq_len in enumerate(original_context_length_list[::-1]):
+                    cur_hidden_states = hidden_states[:, seq_start : seq_start + cur_seq_len, :]
+
+                    hidden_states_list[idx] = torch.cat([history_hidden_states_list[idx], cur_hidden_states], dim=1)
+
+                    seq_start += cur_seq_len
+
+                hidden_states = torch.cat(hidden_states_list, dim=1)
+            else:
+                history_hidden_states, hidden_states = (
+                    hidden_states[:, :history_seq_len],
+                    hidden_states[:, history_seq_len:],
+                )
+                norm_hidden_states = self.norm2(hidden_states.float()).type_as(hidden_states)
+                attn_output = self.attn2(
+                    norm_hidden_states,
+                    encoder_hidden_states,
+                    navit_encoder_attention_mask,
+                    None,
+                    original_context_length,
+                    original_context_length_list,
+                    enable_navit,
+                )
+                hidden_states = hidden_states + attn_output
+                hidden_states = torch.cat([history_hidden_states, hidden_states], dim=1)
+        else:
+            norm_hidden_states = self.norm2(hidden_states.float()).type_as(hidden_states)
+            attn_output = self.attn2(
+                norm_hidden_states,
+                encoder_hidden_states,
+                navit_encoder_attention_mask,
+                None,
+                original_context_length,
+                original_context_length_list,
+                enable_navit,
+            )
+            hidden_states = hidden_states + attn_output
+
+        # 3. Feed-forward
+        norm_hidden_states = (self.norm3(hidden_states.float()) * (1 + c_scale_msa) + c_shift_msa).type_as(
+            hidden_states
+        )
+        ff_output = self.ffn(norm_hidden_states)
+        hidden_states = (hidden_states.float() + ff_output.float() * c_gate_msa).type_as(hidden_states)
+
+        return hidden_states
+
+
+class HeliosTransformer3DModel(
+    ModelMixin, ConfigMixin, PeftAdapterMixin, FromOriginalModelMixin, CacheMixin, AttentionMixin
+):
+    r"""
+    A Transformer model for video-like data used in the Helios model.
+
+    Args:
+        patch_size (`Tuple[int]`, defaults to `(1, 2, 2)`):
+            3D patch dimensions for video embedding (t_patch, h_patch, w_patch).
+        num_attention_heads (`int`, defaults to `40`):
+            Fixed length for text embeddings.
+        attention_head_dim (`int`, defaults to `128`):
+            The number of channels in each head.
+        in_channels (`int`, defaults to `16`):
+            The number of channels in the input.
+        out_channels (`int`, defaults to `16`):
+            The number of channels in the output.
+        text_dim (`int`, defaults to `512`):
+            Input dimension for text embeddings.
+        freq_dim (`int`, defaults to `256`):
+            Dimension for sinusoidal time embeddings.
+        ffn_dim (`int`, defaults to `13824`):
+            Intermediate dimension in feed-forward network.
+        num_layers (`int`, defaults to `40`):
+            The number of layers of transformer blocks to use.
+        window_size (`Tuple[int]`, defaults to `(-1, -1)`):
+            Window size for local attention (-1 indicates global attention).
+        cross_attn_norm (`bool`, defaults to `True`):
+            Enable cross-attention normalization.
+        qk_norm (`bool`, defaults to `True`):
+            Enable query/key normalization.
+        eps (`float`, defaults to `1e-6`):
+            Epsilon value for normalization layers.
+        add_img_emb (`bool`, defaults to `False`):
+            Whether to use img_emb.
+        added_kv_proj_dim (`int`, *optional*, defaults to `None`):
+            The number of channels to use for the added key and value projections. If `None`, no projection is used.
+    """
+
+    _supports_gradient_checkpointing = True
+    _skip_layerwise_casting_patterns = [
+        "patch_embedding",
+        "patch_short",
+        "patch_mid",
+        "patch_long",
+        "condition_embedder",
+        "norm",
+    ]
+    _no_split_modules = ["HeliosTransformerBlock", "HeliosOutputNorm"]
+    _keep_in_fp32_modules = [
+        "time_embedder",
+        "scale_shift_table",
+        "norm1",
+        "norm2",
+        "norm3",
+        "history_key_scale",
+    ]
+    _keys_to_ignore_on_load_unexpected = ["norm_added_q"]
+    _repeated_blocks = ["HeliosTransformerBlock"]
+    _cp_plan = {
+        # Input split at attn level and ffn level.
+        "blocks.*.attn1": {
+            "hidden_states": ContextParallelInput(split_dim=1, expected_dims=3, split_output=False),
+            "rotary_emb": ContextParallelInput(split_dim=1, expected_dims=3, split_output=False),
+        },
+        "blocks.*.attn2": {
+            "hidden_states": ContextParallelInput(split_dim=1, expected_dims=3, split_output=False),
+        },
+        "blocks.*.ffn": {
+            "hidden_states": ContextParallelInput(split_dim=1, expected_dims=3, split_output=False),
+        },
+        # Output gather at attn level and ffn level.
+        **{f"blocks.{i}.attn1": ContextParallelOutput(gather_dim=1, expected_dims=3) for i in range(40)},
+        **{f"blocks.{i}.attn2": ContextParallelOutput(gather_dim=1, expected_dims=3) for i in range(40)},
+        **{f"blocks.{i}.ffn": ContextParallelOutput(gather_dim=1, expected_dims=3) for i in range(40)},
+    }
+
+    @register_to_config
+    def __init__(
+        self,
+        patch_size: tuple[int, ...] = (1, 2, 2),
+        num_attention_heads: int = 40,
+        attention_head_dim: int = 128,
+        in_channels: int = 16,
+        out_channels: int = 16,
+        text_dim: int = 4096,
+        freq_dim: int = 256,
+        ffn_dim: int = 13824,
+        num_layers: int = 40,
+        cross_attn_norm: bool = True,
+        qk_norm: str | None = "rms_norm_across_heads",
+        eps: float = 1e-6,
+        image_dim: int | None = None,
+        added_kv_proj_dim: int | None = None,
+        rope_dim: tuple[int, ...] = (44, 42, 42),
+        rope_theta: float = 10000.0,
+        restrict_self_attn: bool = False,
+        guidance_cross_attn: bool = False,
+        is_train_restrict_lora: bool = False,
+        restrict_lora: bool = False,
+        restrict_lora_rank: int = 128,
+        zero_history_timestep: bool = False,
+        has_multi_term_memory_patch: bool = False,
+        is_amplify_history: bool = False,
+        history_scale_mode: str = "per_head",  # [scalar, per_head]
+        is_use_gan: bool = False,
+        is_use_gan_hooks: bool = False,
+        is_use_gan_final: bool = False,
+        gan_cond_map_dim: int = 768,
+        gan_hooks: List[int] = [5, 15, 25, 35],
+    ) -> None:
+        super().__init__()
+
+        inner_dim = num_attention_heads * attention_head_dim
+        out_channels = out_channels or in_channels
+
+        # 1. Patch & position embedding
+        self.rope = HeliosRotaryPosEmbed(rope_dim=rope_dim, theta=rope_theta)
+        self.patch_embedding = nn.Conv3d(in_channels, inner_dim, kernel_size=patch_size, stride=patch_size)
+
+        # 2. Condition embeddings
+        self.condition_embedder = HeliosTimeTextEmbedding(
+            dim=inner_dim,
+            time_freq_dim=freq_dim,
+            time_proj_dim=inner_dim * 6,
+            text_embed_dim=text_dim,
+        )
+
+        # 3. Transformer blocks
+        self.blocks = nn.ModuleList(
+            [
+                HeliosTransformerBlock(
+                    inner_dim,
+                    ffn_dim,
+                    num_attention_heads,
+                    qk_norm,
+                    cross_attn_norm,
+                    eps,
+                    added_kv_proj_dim,
+                    restrict_self_attn=restrict_self_attn,
+                    guidance_cross_attn=guidance_cross_attn,
+                    is_train_restrict_lora=is_train_restrict_lora,
+                    restrict_lora=restrict_lora,
+                    restrict_lora_rank=restrict_lora_rank,
+                    is_amplify_history=is_amplify_history,
+                    history_scale_mode=history_scale_mode,
+                )
+                for _ in range(num_layers)
+            ]
+        )
+
+        # 4. Output norm & projection
+        self.norm_out = HeliosOutputNorm(inner_dim, eps, elementwise_affine=False)
+        self.proj_out = nn.Linear(inner_dim, out_channels * math.prod(patch_size))
+
+        self.init_weights()
+
+        # 5. Initial Stage1
+        self.zero_history_timestep = zero_history_timestep
+        self.inner_dim = inner_dim
+        if has_multi_term_memory_patch:
+            self.patch_short = nn.Conv3d(in_channels, self.inner_dim, kernel_size=(1, 2, 2), stride=(1, 2, 2))
+            self.patch_mid = nn.Conv3d(in_channels, self.inner_dim, kernel_size=(2, 4, 4), stride=(2, 4, 4))
+            self.patch_long = nn.Conv3d(in_channels, self.inner_dim, kernel_size=(4, 8, 8), stride=(4, 8, 8))
+            self.initialize_weight_from_another_conv3d(self.patch_embedding)
+
+        # 6. Initial Gan
+        self.is_use_gan = is_use_gan
+        if is_use_gan:
+            self.is_use_gan_hooks = is_use_gan_hooks
+            self.is_use_gan_final = is_use_gan_final
+            if is_use_gan_hooks:
+                gan_heads = []
+                self.gan_hooks = gan_hooks
+                for hook in self.gan_hooks:
+                    gan_heads.append((str(hook), Discriminator3DHead(inner_dim, gan_cond_map_dim)))
+                self.gan_heads = nn.ModuleDict(gan_heads)
+            if is_use_gan_final:
+                self.gan_final_head = Discriminator3DHead(out_channels, gan_cond_map_dim)
+
+        self.gradient_checkpointing = False
+
+    @torch.no_grad()
+    def initialize_weight_from_another_conv3d(self, another_layer):
+        weight = another_layer.weight.detach().clone()
+        bias = another_layer.bias.detach().clone()
+
+        weight = weight[:, :16, :, :, :]
+
+        sd = {
+            "patch_short.weight": weight.clone(),
+            "patch_short.bias": bias.clone(),
+            "patch_mid.weight": einops.repeat(weight, "b c t h w -> b c (t tk) (h hk) (w wk)", tk=2, hk=2, wk=2) / 8.0,
+            "patch_mid.bias": bias.clone(),
+            "patch_long.weight": einops.repeat(weight, "b c t h w -> b c (t tk) (h hk) (w wk)", tk=4, hk=4, wk=4)
+            / 64.0,
+            "patch_long.bias": bias.clone(),
+        }
+
+        sd = {k: v.clone() for k, v in sd.items()}
+
+        self.load_state_dict(sd, strict=False)
+
+    def gradient_checkpointing_method(self, block, *args):
+        if torch.is_grad_enabled() and self.gradient_checkpointing:
+            result = self._gradient_checkpointing_func(block, *args)
+        else:
+            result = block(*args)
+        return result
+
+    def enable_kv_cache(self):
+        for block in self.blocks:
+            if hasattr(block.attn1, "processor") and hasattr(block.attn1.processor, "enable_cache"):
+                block.attn1.processor.enable_cache()
+
+    def disable_kv_cache(self):
+        for block in self.blocks:
+            if hasattr(block.attn1, "processor") and hasattr(block.attn1.processor, "disable_cache"):
+                block.attn1.processor.disable_cache()
+
+    def clear_kv_cache(self):
+        for block in self.blocks:
+            if hasattr(block.attn1, "processor") and hasattr(block.attn1.processor, "clear_cache"):
+                block.attn1.processor.clear_cache()
+
+    def process_input_hidden_states(
+        self,
+        latents,
+        indices_hidden_states=None,
+        indices_latents_history_short=None,
+        indices_latents_history_mid=None,
+        indices_latents_history_long=None,
+        latents_history_short=None,
+        latents_history_mid=None,
+        latents_history_long=None,
+    ):
+        height_list = []
+        width_list = []
+        temporal_list = []
+        seq_list = []
+        if isinstance(latents, list):
+            hidden_states = None
+            rope_freqs = None
+            for idx, cur_hidden_states in enumerate(latents):
+                cur_hidden_states = self.gradient_checkpointing_method(
+                    self.patch_embedding, cur_hidden_states.to(self.device, dtype=self.dtype)
+                )
+                B, C, T, H, W = cur_hidden_states.shape
+
+                cur_hidden_states = cur_hidden_states.flatten(2).transpose(1, 2)
+
+                if indices_hidden_states is None:
+                    indices_hidden_states = torch.arange(0, T).unsqueeze(0).expand(B, -1)
+
+                cur_indices_latents = indices_hidden_states
+                cur_rope_freqs = self.rope(
+                    frame_indices=cur_indices_latents, height=H, width=W, device=cur_hidden_states.device
+                )
+                cur_rope_freqs = cur_rope_freqs.flatten(2).transpose(1, 2)
+
+                height_list.append(H)
+                width_list.append(W)
+                temporal_list.append(T)
+                seq_list.append(cur_hidden_states.shape[1])
+
+                if hidden_states is None:
+                    hidden_states = cur_hidden_states
+                    rope_freqs = cur_rope_freqs
+                else:
+                    hidden_states = torch.cat([cur_hidden_states, hidden_states], dim=1)
+                    rope_freqs = torch.cat([cur_rope_freqs, rope_freqs], dim=1)
+        else:
+            hidden_states = self.gradient_checkpointing_method(self.patch_embedding, latents)
+            B, C, T, H, W = hidden_states.shape
+
+            if indices_hidden_states is None:
+                indices_hidden_states = torch.arange(0, T).unsqueeze(0).expand(B, -1)
+
+            hidden_states = hidden_states.flatten(2).transpose(
+                1, 2
+            )  # torch.Size([1, 3072, 9, 44, 34]) -> torch.Size([1, 13464, 3072])
+
+            rope_freqs = self.rope(
+                frame_indices=indices_hidden_states,
+                height=H,
+                width=W,
+                device=hidden_states.device,
+            )  # torch.Size([1, 9]) -> torch.Size([1, 256, 9, 44, 34])
+            rope_freqs = rope_freqs.flatten(2).transpose(1, 2)  # torch.Size([1, 13464, 256])
+
+            height_list.append(H)
+            width_list.append(W)
+            temporal_list.append(T)
+            seq_list.append(hidden_states.shape[1])
+
+        # Process short history latents
+        if latents_history_short is not None and indices_latents_history_short is not None:
+            latents_history_short = latents_history_short.to(hidden_states)
+            latents_history_short = self.gradient_checkpointing_method(self.patch_short, latents_history_short)
+            _, _, _, H1, W1 = latents_history_short.shape
+            latents_history_short = latents_history_short.flatten(2).transpose(1, 2)
+
+            rope_freqs_history_short = self.rope(
+                frame_indices=indices_latents_history_short,
+                height=H1,
+                width=W1,
+                device=latents_history_short.device,
+            )
+            rope_freqs_history_short = rope_freqs_history_short.flatten(2).transpose(1, 2)
+
+            hidden_states = torch.cat([latents_history_short, hidden_states], dim=1)
+            rope_freqs = torch.cat([rope_freqs_history_short, rope_freqs], dim=1)
+
+        # Process mid history latents
+        if latents_history_mid is not None and indices_latents_history_mid is not None:
+            latents_history_mid = latents_history_mid.to(hidden_states)
+            latents_history_mid = pad_for_3d_conv(latents_history_mid, (2, 4, 4))
+            latents_history_mid = self.gradient_checkpointing_method(self.patch_mid, latents_history_mid)
+            latents_history_mid = latents_history_mid.flatten(2).transpose(1, 2)
+
+            rope_freqs_history_mid = self.rope(
+                frame_indices=indices_latents_history_mid,
+                height=H1,
+                width=W1,
+                device=latents_history_mid.device,
+            )
+            rope_freqs_history_mid = pad_for_3d_conv(rope_freqs_history_mid, (2, 2, 2))
+            rope_freqs_history_mid = center_down_sample_3d(rope_freqs_history_mid, (2, 2, 2))
+            rope_freqs_history_mid = rope_freqs_history_mid.flatten(2).transpose(1, 2)
+
+            hidden_states = torch.cat([latents_history_mid, hidden_states], dim=1)
+            rope_freqs = torch.cat([rope_freqs_history_mid, rope_freqs], dim=1)
+
+        # Process long history latents
+        if latents_history_long is not None and indices_latents_history_long is not None:
+            latents_history_long = latents_history_long.to(hidden_states)
+            latents_history_long = pad_for_3d_conv(latents_history_long, (4, 8, 8))
+            latents_history_long = self.gradient_checkpointing_method(self.patch_long, latents_history_long)
+            latents_history_long = latents_history_long.flatten(2).transpose(1, 2)
+
+            rope_freqs_history_long = self.rope(
+                frame_indices=indices_latents_history_long,
+                height=H1,
+                width=W1,
+                device=latents_history_long.device,
+            )
+            rope_freqs_history_long = pad_for_3d_conv(rope_freqs_history_long, (4, 4, 4))
+            rope_freqs_history_long = center_down_sample_3d(rope_freqs_history_long, (4, 4, 4))
+            rope_freqs_history_long = rope_freqs_history_long.flatten(2).transpose(1, 2)
+
+            hidden_states = torch.cat([latents_history_long, hidden_states], dim=1)
+            rope_freqs = torch.cat([rope_freqs_history_long, rope_freqs], dim=1)
+
+        return (
+            hidden_states,
+            rope_freqs,
+            height_list,
+            width_list,
+            temporal_list,
+            seq_list,
+        )
+
+    @apply_lora_scale("attention_kwargs")
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        timestep: torch.LongTensor,
+        encoder_hidden_states: torch.Tensor,
+        # ------------ Stage 1 ------------
+        indices_hidden_states=None,
+        indices_latents_history_short=None,
+        indices_latents_history_mid=None,
+        indices_latents_history_long=None,
+        latents_history_short=None,
+        latents_history_mid=None,
+        latents_history_long=None,
+        is_first_denoising_step: bool = False,
+        # ------------ GAN ------------
+        gan_mode: bool = False,
+        return_dict: bool = True,
+        attention_kwargs: dict[str, Any] | None = None,
+    ) -> Union[torch.Tensor, Dict[str, torch.Tensor]]:
+        assert (
+            len(
+                {
+                    x is None
+                    for x in [
+                        indices_hidden_states,
+                        indices_latents_history_short,
+                        indices_latents_history_mid,
+                        indices_latents_history_long,
+                        latents_history_short,
+                        latents_history_mid,
+                        latents_history_long,
+                    ]
+                }
+            )
+            == 1
+        ), "All history latents and indices must either all exist or all be None"
+
+        if indices_hidden_states is not None and indices_hidden_states.ndim == 1:
+            indices_hidden_states = indices_hidden_states.unsqueeze(0)
+        if indices_latents_history_short is not None and indices_latents_history_short.ndim == 1:
+            indices_latents_history_short = indices_latents_history_short.unsqueeze(0)
+        if indices_latents_history_mid is not None and indices_latents_history_mid.ndim == 1:
+            indices_latents_history_mid = indices_latents_history_mid.unsqueeze(0)
+        if indices_latents_history_long is not None and indices_latents_history_long.ndim == 1:
+            indices_latents_history_long = indices_latents_history_long.unsqueeze(0)
+
+        if gan_mode:
+            assert self.is_use_gan
+
+        if isinstance(hidden_states, list):
+            assert gan_mode is False and self.is_use_gan is False
+            enable_navit = True
+            navit_len = len(hidden_states)
+            batch_size = hidden_states[0].shape[0]
+        else:
+            enable_navit = False
+            batch_size = hidden_states.shape[0]
+        p_t, p_h, p_w = self.config.patch_size
+
+        (
+            hidden_states,
+            rotary_emb,
+            post_patch_height_list,
+            post_patch_width_list,
+            post_patch_num_frames_list,
+            original_context_length_list,
+        ) = self.process_input_hidden_states(
+            latents=hidden_states,
+            indices_hidden_states=indices_hidden_states,
+            indices_latents_history_short=indices_latents_history_short,
+            indices_latents_history_mid=indices_latents_history_mid,
+            indices_latents_history_long=indices_latents_history_long,
+            latents_history_short=latents_history_short,
+            latents_history_mid=latents_history_mid,
+            latents_history_long=latents_history_long,
+        )  # hidden: [high, mid, low] -> [low, mid, high]
+        post_patch_num_frames = sum(post_patch_num_frames_list)
+        post_patch_height = sum(post_patch_height_list)
+        post_patch_width = sum(post_patch_width_list)
+        original_context_length = sum(original_context_length_list)
+        history_context_length = hidden_states.shape[1] - original_context_length
+
+        if indices_hidden_states is not None and self.zero_history_timestep:
+            if isinstance(timestep, list):
+                timestep_t0 = torch.zeros((1), dtype=timestep[0].dtype, device=timestep[0].device)
+            else:
+                timestep_t0 = torch.zeros((1), dtype=timestep.dtype, device=timestep.device)
+            temb_t0, timestep_proj_t0, _ = self.condition_embedder(
+                timestep_t0, encoder_hidden_states, is_return_encoder_hidden_states=False
+            )
+            temb_t0 = temb_t0.unsqueeze(1).expand(batch_size, history_context_length, -1)
+            timestep_proj_t0 = (
+                timestep_proj_t0.unflatten(-1, (6, -1))
+                .view(1, 6, 1, -1)
+                .expand(batch_size, -1, history_context_length, -1)
+            )
+
+        navit_hidden_attention_mask = None
+        navit_encoder_attention_mask = None
+        if enable_navit:
+            assert navit_len == len(original_context_length_list)
+            navit_hidden_attention_mask, navit_encoder_attention_mask, navit_history_hidden_attention_mask = (
+                create_navit_attention_masks(
+                    batch_size=batch_size,
+                    original_context_length_list=original_context_length_list[::-1],
+                    history_context_length=history_context_length,
+                    encoder_hidden_states_seq_len=encoder_hidden_states.shape[1],
+                    device=hidden_states.device,
+                    restrict_self_attn=self.config.restrict_self_attn,
+                    guidance_cross_attn=self.config.guidance_cross_attn,
+                )
+            )
+            navit_hidden_attention_mask = [navit_hidden_attention_mask, navit_history_hidden_attention_mask]
+
+            history_hidden_states, hidden_states = (
+                hidden_states[:, :history_context_length],
+                hidden_states[:, history_context_length:],
+            )
+            history_rotary_emb, rotary_emb = (
+                rotary_emb[:, :history_context_length],
+                rotary_emb[:, history_context_length:],
+            )
+            timestep = timestep[::-1]
+
+            hidden_states_list = [None] * navit_len
+            rotary_emb_list = [None] * navit_len
+            temb_list = [None] * navit_len
+            timestep_proj_list = [None] * navit_len
+
+            seq_start = 0
+            for idx, cur_seq_len in zip(range(navit_len), original_context_length_list[::-1]):
+                cur_hidden_states = hidden_states[:, seq_start : seq_start + cur_seq_len, :]
+                cur_rotary_emb = rotary_emb[:, seq_start : seq_start + cur_seq_len, :]
+
+                hidden_states_list[idx] = torch.cat([history_hidden_states, cur_hidden_states], dim=1)
+                rotary_emb_list[idx] = torch.cat([history_rotary_emb, cur_rotary_emb], dim=1)
+
+                seq_start += cur_seq_len
+
+                if idx == 0:
+                    cur_temb, cur_timestep_proj, encoder_hidden_states = self.condition_embedder(
+                        timestep[idx], encoder_hidden_states
+                    )
+                else:
+                    cur_temb, cur_timestep_proj, _ = self.condition_embedder(
+                        timestep[idx], encoder_hidden_states, is_return_encoder_hidden_states=False
+                    )
+
+                cur_temb = cur_temb.view(batch_size, 1, -1).expand(-1, cur_seq_len, -1)
+                cur_timestep_proj = cur_timestep_proj.view(batch_size, 6, 1, -1).expand(-1, -1, cur_seq_len, -1)
+
+                if self.zero_history_timestep:
+                    temb_list[idx] = torch.cat([temb_t0, cur_temb], dim=1)
+                    timestep_proj_list[idx] = torch.cat([timestep_proj_t0, cur_timestep_proj], dim=2)
+                else:
+                    temb_list[idx] = cur_temb
+                    timestep_proj_list[idx] = cur_timestep_proj
+
+            hidden_states = torch.cat(hidden_states_list, dim=1)
+            rotary_emb = torch.cat(rotary_emb_list, dim=1)
+            temb = torch.cat(temb_list, dim=1)
+            timestep_proj = torch.cat(timestep_proj_list, dim=2)
+        else:
+            temb, timestep_proj, encoder_hidden_states = self.condition_embedder(timestep, encoder_hidden_states)
+            timestep_proj = timestep_proj.unflatten(-1, (6, -1))
+
+            if indices_hidden_states is not None and not self.zero_history_timestep:
+                main_repeat_size = hidden_states.shape[1]
+            else:
+                main_repeat_size = original_context_length
+            temb = temb.view(batch_size, 1, -1).expand(batch_size, main_repeat_size, -1)
+            timestep_proj = timestep_proj.view(batch_size, 6, 1, -1).expand(batch_size, 6, main_repeat_size, -1)
+
+            if indices_hidden_states is not None and self.zero_history_timestep:
+                temb = torch.cat([temb_t0, temb], dim=1)
+                timestep_proj = torch.cat([timestep_proj_t0, timestep_proj], dim=2)
+
+        if timestep_proj.ndim == 4:
+            timestep_proj = timestep_proj.permute(0, 2, 1, 3)
+
+        # 4. Transformer blocks
+        logits_hidden = []
+        hidden_states = hidden_states.contiguous()
+        encoder_hidden_states = encoder_hidden_states.contiguous()
+        rotary_emb = rotary_emb.contiguous()
+        if torch.is_grad_enabled() and self.gradient_checkpointing:
+            for iidx, block in enumerate(self.blocks):
+                hidden_states = self._gradient_checkpointing_func(
+                    block,
+                    hidden_states,
+                    encoder_hidden_states,
+                    timestep_proj,
+                    rotary_emb,
+                    navit_hidden_attention_mask,
+                    navit_encoder_attention_mask,
+                    original_context_length,
+                    original_context_length_list,
+                    is_first_denoising_step,
+                )
+                if gan_mode and self.is_use_gan and self.is_use_gan_hooks and iidx in self.gan_hooks:
+                    logits_hidden.append(hidden_states[:, -original_context_length:, :])
+        else:
+            for iidx, block in enumerate(self.blocks):
+                hidden_states = block(
+                    hidden_states,
+                    encoder_hidden_states,
+                    timestep_proj,
+                    rotary_emb,
+                    navit_hidden_attention_mask,
+                    navit_encoder_attention_mask,
+                    original_context_length,
+                    original_context_length_list,
+                    is_first_denoising_step,
+                )
+                if gan_mode and self.is_use_gan and self.is_use_gan_hooks and iidx in self.gan_hooks:
+                    logits_hidden.append(hidden_states[:, -original_context_length:, :])
+
+        # 5. Output norm, projection & unpatchify
+        if temb.ndim == 3:
+            if not enable_navit:
+                temb = temb[:, -original_context_length:, :]
+            shift, scale = (self.norm_out.scale_shift_table.unsqueeze(0).to(temb.device) + temb.unsqueeze(2)).chunk(
+                2, dim=2
+            )
+            shift = shift.squeeze(2)
+            scale = scale.squeeze(2)
+        else:
+            # batch_size, inner_dim
+            shift, scale = (self.norm_out.scale_shift_table.to(temb.device) + temb.unsqueeze(1)).chunk(2, dim=1)
+
+        # Move the shift and scale tensors to the same device as hidden_states.
+        # When using multi-GPU inference via accelerate these will be on the
+        # first device rather than the last device, which hidden_states ends up
+        # on.
+        shift = shift.to(hidden_states.device)
+        scale = scale.to(hidden_states.device)
+
+        if enable_navit:
+            hidden_states = (self.norm_out.norm(hidden_states.float()) * (1 + scale) + shift).type_as(hidden_states)
+
+            output = []
+            seq_start = 0
+            for (
+                cur_original_context_length,
+                cur_post_patch_num_frames,
+                cur_post_patch_height,
+                cur_post_patch_width,
+            ) in zip(
+                reversed(original_context_length_list),
+                reversed(post_patch_num_frames_list),
+                reversed(post_patch_height_list),
+                reversed(post_patch_width_list),
+            ):
+                cur_hidden_states = hidden_states[
+                    :, seq_start : seq_start + cur_original_context_length + history_context_length, :
+                ]  # (B, T*H*W, C)
+                cur_hidden_states = cur_hidden_states[:, history_context_length:, :]
+                cur_hidden_states = self.proj_out(cur_hidden_states)
+                seq_start += cur_original_context_length + history_context_length
+
+                cur_hidden_states = cur_hidden_states.reshape(
+                    batch_size,
+                    cur_post_patch_num_frames,
+                    cur_post_patch_height,
+                    cur_post_patch_width,
+                    p_t,
+                    p_h,
+                    p_w,
+                    -1,
+                )
+                cur_hidden_states = cur_hidden_states.permute(0, 7, 1, 4, 2, 5, 3, 6)
+                cur_hidden_states = cur_hidden_states.flatten(6, 7).flatten(4, 5).flatten(2, 3)
+
+                output.append(cur_hidden_states)
+
+            output = output[::-1]
+        else:
+            hidden_states = hidden_states[:, -original_context_length:, :]
+            hidden_states = (self.norm_out.norm(hidden_states.float()) * (1 + scale) + shift).type_as(hidden_states)
+            hidden_states = self.proj_out(hidden_states)
+            hidden_states = hidden_states.reshape(
+                batch_size, post_patch_num_frames, post_patch_height, post_patch_width, p_t, p_h, p_w, -1
+            )
+            hidden_states = hidden_states.permute(0, 7, 1, 4, 2, 5, 3, 6)
+            output = hidden_states.flatten(6, 7).flatten(4, 5).flatten(2, 3)
+
+        logits = []
+        if gan_mode and self.is_use_gan:
+            if self.is_use_gan_final:
+                logits.append(self.gradient_checkpointing_method(self.gan_final_head, output))
+            if self.is_use_gan_hooks:
+                for idx, (_, gan_head) in enumerate(self.gan_heads.items()):
+                    activation = rearrange(
+                        logits_hidden[idx],
+                        "b (f h w) c -> b c f h w",
+                        f=post_patch_num_frames,
+                        h=post_patch_height,
+                        w=post_patch_width,
+                    )
+                    logits.append(self.gradient_checkpointing_method(gan_head, activation.contiguous()))
+            logits = torch.cat(logits, dim=1) if len(logits) > 1 else logits[0]
+            logits_hidden = None
+            del logits_hidden
+
+        if not return_dict:
+            return (output, logits)
+
+        return Transformer2DModelOutput(sample=output, logits=logits)
+
+    def init_weights(self):
+        r"""
+        Initialize model parameters using Xavier initialization.
+        """
+
+        # basic init
+        for m in self.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight)
+                if m.bias is not None:
+                    nn.init.zeros_(m.bias)
+
+        # init embeddings
+        nn.init.xavier_uniform_(self.patch_embedding.weight.flatten(1))
+        for m in self.condition_embedder.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.normal_(m.weight, std=0.02)
+
+        # init output layer
+        nn.init.zeros_(self.proj_out.weight)
+
+    @classmethod
+    def from_pretrained(
+        cls,
+        pretrained_model_path,
+        subfolder=None,
+        transformer_additional_kwargs={},
+        low_cpu_mem_usage=False,
+        torch_dtype=torch.float32,
+        device_map="cpu",
+        max_workers=8,
+        use_default_loader=False,
+    ):
+        if use_default_loader:
+            return super().from_pretrained(
+                pretrained_model_path, subfolder=subfolder, device_map=device_map, torch_dtype=torch_dtype
+            )
+
+        import os
+        from concurrent.futures import ThreadPoolExecutor, as_completed
+
+        from huggingface_hub import snapshot_download
+
+        from diffusers.utils import WEIGHTS_NAME
+
+        if os.path.exists(pretrained_model_path):
+            if subfolder is not None:
+                pretrained_model_path = os.path.join(pretrained_model_path, subfolder)
+        else:
+            print(f"Downloading from Hugging Face Hub: {pretrained_model_path}")
+            cache_dir = snapshot_download(
+                repo_id=pretrained_model_path,
+                # allow_patterns=["*.json", "*.safetensors", "*.bin"],
+            )
+            pretrained_model_path = cache_dir
+            if subfolder is not None:
+                pretrained_model_path = os.path.join(cache_dir, subfolder)
+
+        print(f"loaded 3D transformer's pretrained weights from {pretrained_model_path} ...")
+
+        config_file = os.path.join(pretrained_model_path, "config.json")
+        if not os.path.isfile(config_file):
+            raise RuntimeError(f"{config_file} does not exist")
+        with open(config_file, "r") as f:
+            config = json.load(f)
+
+        model_file = os.path.join(pretrained_model_path, WEIGHTS_NAME)
+        model_file_safetensors = model_file.replace(".bin", ".safetensors")
+
+        if "dict_mapping" in transformer_additional_kwargs.keys():
+            for key in transformer_additional_kwargs["dict_mapping"]:
+                transformer_additional_kwargs[transformer_additional_kwargs["dict_mapping"][key]] = config[key]
+
+        def remap_state_dict_keys(state_dict):
+            """Remap old key names to new key names for compatibility."""
+            remapped = {}
+            for key, value in state_dict.items():
+                new_key = key
+                # Only remap top-level scale_shift_table, not blocks.*.scale_shift_table
+                if key == "scale_shift_table":
+                    new_key = "norm_out.scale_shift_table"
+                    print(f"Remapping key: {key} -> {new_key}")
+                remapped[new_key] = value
+            return remapped
+
+        if low_cpu_mem_usage:
+            try:
+                import re
+
+                from diffusers import __version__ as diffusers_version
+                from diffusers.models.model_loading_utils import load_model_dict_into_meta
+                from diffusers.utils import is_accelerate_available
+
+                if is_accelerate_available():
+                    import accelerate
+
+                # Instantiate model with empty weights
+                with accelerate.init_empty_weights():
+                    model = cls.from_config(config, **transformer_additional_kwargs)
+
+                param_device = "cpu"
+                if os.path.exists(model_file):
+                    state_dict = torch.load(model_file, map_location="cpu")
+                elif os.path.exists(model_file_safetensors):
+                    from safetensors.torch import load_file
+
+                    state_dict = load_file(model_file_safetensors)
+                else:
+                    from safetensors.torch import load_file
+
+                    model_files_safetensors = glob.glob(os.path.join(pretrained_model_path, "*.safetensors"))
+                    state_dict = {}
+                    print(f"Loading {len(model_files_safetensors)} safetensors files with {max_workers} workers...")
+                    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                        future_to_file = {executor.submit(load_file, f): f for f in model_files_safetensors}
+                        for future in as_completed(future_to_file):
+                            _state_dict = future.result()
+                            state_dict.update(_state_dict)
+
+                # Remap keys before loading into meta model
+                state_dict = remap_state_dict_keys(state_dict)
+
+                if diffusers_version >= "0.33.0":
+                    # Diffusers has refactored `load_model_dict_into_meta` since version 0.33.0 in this commit:
+                    # https://github.com/huggingface/diffusers/commit/f5929e03060d56063ff34b25a8308833bec7c785.
+                    load_model_dict_into_meta(
+                        model,
+                        state_dict,
+                        dtype=torch_dtype,
+                        model_name_or_path=pretrained_model_path,
+                        keep_in_fp32_modules=cls._keep_in_fp32_modules,
+                    )
+                else:
+                    model._convert_deprecated_attention_blocks(state_dict)
+                    # move the params from meta device to cpu
+                    missing_keys = set(model.state_dict().keys()) - set(state_dict.keys())
+                    if len(missing_keys) > 0:
+                        raise ValueError(
+                            f"Cannot load {cls} from {pretrained_model_path} because the following keys are"
+                            f" missing: \n {', '.join(missing_keys)}. \n Please make sure to pass"
+                            " `low_cpu_mem_usage=False` and `device_map=None` if you want to randomly initialize"
+                            " those weights or else make sure your checkpoint file is correct."
+                        )
+
+                    unexpected_keys = load_model_dict_into_meta(
+                        model,
+                        state_dict,
+                        device=param_device,
+                        dtype=torch_dtype,
+                        model_name_or_path=pretrained_model_path,
+                    )
+
+                    if cls._keys_to_ignore_on_load_unexpected is not None:
+                        for pat in cls._keys_to_ignore_on_load_unexpected:
+                            unexpected_keys = [k for k in unexpected_keys if re.search(pat, k) is None]
+
+                    if len(unexpected_keys) > 0:
+                        print(
+                            f"Some weights of the model checkpoint were not used when initializing {cls.__name__}: \n {[', '.join(unexpected_keys)]}"
+                        )
+
+                return model
+            except Exception as e:
+                print(f"The low_cpu_mem_usage mode is not work because {e}. Use low_cpu_mem_usage=False instead.")
+
+        model = cls.from_config(config, **transformer_additional_kwargs)
+        if os.path.exists(model_file):
+            state_dict = torch.load(model_file, map_location="cpu")
+        elif os.path.exists(model_file_safetensors):
+            from safetensors.torch import load_file
+
+            state_dict = load_file(model_file_safetensors)
+        else:
+            from safetensors.torch import load_file
+
+            model_files_safetensors = glob.glob(os.path.join(pretrained_model_path, "*.safetensors"))
+            state_dict = {}
+            print(f"Loading {len(model_files_safetensors)} safetensors files with {max_workers} workers...")
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                future_to_file = {executor.submit(load_file, f): f for f in model_files_safetensors}
+                for future in as_completed(future_to_file):
+                    _state_dict = future.result()
+                    state_dict.update(_state_dict)
+
+        # Remap keys before size check and loading
+        state_dict = remap_state_dict_keys(state_dict)
+
+        tmp_state_dict = {}
+        for key in state_dict:
+            if key in model.state_dict().keys() and model.state_dict()[key].size() == state_dict[key].size():
+                tmp_state_dict[key] = state_dict[key]
+            else:
+                print(key, "Size don't match, skip")
+
+        state_dict = tmp_state_dict
+
+        m, u = model.load_state_dict(state_dict, strict=False)
+        print(f"### missing keys: {len(m)}; \n### unexpected keys: {len(u)};")
+        print(m)
+
+        for name, param in model.named_parameters():
+            should_keep_fp32 = any(pattern in name for pattern in cls._keep_in_fp32_modules)
+            if should_keep_fp32:
+                param.data = param.data.to(torch.float32)
+                # print(f"Keeping parameter {name} in fp32")
+            else:
+                param.data = param.data.to(torch_dtype)
+        model = model.to(device_map)
+
+        params = [p.numel() if "." in n else 0 for n, p in model.named_parameters()]
+        print(f"### All Parameters: {sum(params) / 1e6} M")
+
+        params = [p.numel() if "attn1." in n else 0 for n, p in model.named_parameters()]
+        print(f"### attn1 Parameters: {sum(params) / 1e6} M")
+
+        params = [p.numel() if "attn2." in n else 0 for n, p in model.named_parameters()]
+        print(f"### attn2 Parameters: {sum(params) / 1e6} M")
+
+        return model
+
+
+if __name__ == "__main__":
+    import os
+
+    os.environ["HF_ENABLE_PARALLEL_LOADING"] = "yes"
+    os.environ["DIFFUSERS_ENABLE_HUB_KERNELS"] = "yes"
+    # export DIFFUSERS_ENABLE_HUB_KERNELS=yes
+
+    # def compare_models(model1, model2):
+    #     for (name1, param1), (name2, param2) in zip(model1.named_parameters(), model2.named_parameters()):
+    #         if name1 != name2:
+    #             print(f"参数名不同: {name1} vs {name2}")
+    #             return False
+    #         if not torch.equal(param1, param2):
+    #             print(f"参数 {name1} 的值不同")
+    #             print(f"最大差异: {torch.max(torch.abs(param1 - param2))}")
+    #             return False
+    #     print("所有参数完全相同！")
+    #     return True
+    # compare_models(transformer, transformer1)
+
+    gan_mode = False
+    is_use_gan_hooks = False
+    transformer_additional_kwargs = {
+        "has_multi_term_memory_patch": True,
+        "zero_history_timestep": True,
+        "guidance_cross_attn": True,
+        "restrict_self_attn": False,
+        "restrict_lora": False,
+        "is_train_restrict_lora": False,
+        "is_amplify_history": False,
+        "history_scale_mode": "per_head",  # [scalar, per_head]
+        "is_use_gan": gan_mode,
+        "is_use_gan_hooks": is_use_gan_hooks,
+        "gan_hooks": [13, 21, 29],
+        "gan_cond_map_dim": 768,
+        # "gan_hooks": [10, 20, 30],
+        # "gan_cond_map_dim": 512,
+    }
+    # transformer_additional_kwargs={}
+
+    device = "cuda"
+    weight_dtype = torch.bfloat16
+    transformer = HeliosTransformer3DModel.from_pretrained(
+        "Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
+        subfolder="transformer",
+        torch_dtype=torch.bfloat16,
+        transformer_additional_kwargs=transformer_additional_kwargs,
+    )
+    transformer.requires_grad_(False)
+    transformer.eval()
+    transformer = transformer.to(device, dtype=weight_dtype)
+
+    # import sys
+    # from argparse import Namespace
+    # sys.path.append("../../")
+    # from helios.utils.utils_helios_base import save_extra_components, load_extra_components
+    # args = Namespace()
+    # args.training_config = Namespace()
+    # args.training_config.is_enable_stage1 = True
+    # args.training_config.is_train_restrict_lora = True
+    # save_extra_components(args, transformer, "./temp")
+    # load_extra_components(args, transformer, "./temp/transformer_partial.pth")
+
+    is_navit = False
+    batch_size = 4
+    max_length = 512
+    if is_navit:
+        noisy_model_input = [
+            torch.randn(batch_size, 16, 9, 12, 20),
+            torch.randn(batch_size, 16, 9, 24, 40),
+            torch.randn(batch_size, 16, 9, 48, 80),
+        ]
+        timesteps = [
+            torch.randint(0, 1000, (batch_size,)).to(device),
+            torch.randint(0, 1000, (batch_size,)).to(device),
+            torch.randint(0, 1000, (batch_size,)).to(device),
+        ]
+    else:
+        noisy_model_input = torch.randn(batch_size, 16, 9, 48, 80).to(device, dtype=weight_dtype)
+        timesteps = torch.randint(0, 1000, (batch_size,)).to(device)
+
+    prompt_embeds = torch.randn(batch_size, max_length, 4096).to(device, dtype=weight_dtype)
+    indices_hidden_states = torch.randint(0, 10, (batch_size, 9)).to(device)
+    indices_latents_history_short = torch.randint(0, 3, (batch_size, 2)).to(device)
+    indices_latents_history_mid = torch.randint(0, 3, (batch_size, 2)).to(device)
+    indices_latents_history_long = torch.randint(0, 17, (batch_size, 16)).to(device)
+    latents_history_short = torch.randn(batch_size, 16, 2, 48, 80).to(device, dtype=weight_dtype)
+    latents_history_mid = torch.randn(batch_size, 16, 2, 48, 80).to(device, dtype=weight_dtype)
+    latents_history_long = torch.randn(batch_size, 16, 16, 48, 80).to(device, dtype=weight_dtype)
+
+    # 16 2 2: 2400
+    # 16 2 3: 3360
+    # 16 4 2: 2640
+    # 16 4 3: 3600
+    #  8 2 2: 2280
+    #  8 2 3: 3240
+
+    # noisy_model_input_1 = torch.randn(batch_size, 16, 9, 12, 20).to(device, dtype=weight_dtype)
+    # timesteps_1 = torch.randint(0, 1000, (batch_size,)).to(device)
+    # noisy_model_input = [noisy_model_input_1, noisy_model_input_1, noisy_model_input_1]
+    # timesteps = [timesteps_1, timesteps_1, torch.randint(0, 1000, (batch_size,)).to(device)]
+
+    model_pred = transformer(
+        hidden_states=noisy_model_input,
+        timestep=timesteps,
+        encoder_hidden_states=prompt_embeds,
+        indices_hidden_states=indices_hidden_states,
+        indices_latents_history_short=indices_latents_history_short,
+        indices_latents_history_mid=indices_latents_history_mid,
+        indices_latents_history_long=indices_latents_history_long,
+        latents_history_short=latents_history_short.to(weight_dtype),
+        latents_history_mid=latents_history_mid.to(weight_dtype),
+        latents_history_long=latents_history_long.to(weight_dtype),
+        gan_mode=gan_mode,
+        return_dict=False,
+    )[0]

Helios/_DEV/helios/pipelines/pipeline_helios.py

@@ -0,0 +1,1535 @@
+# Copyright 2025 The Helios Team and The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import html
+import math
+from enum import Enum
+from itertools import accumulate
+from typing import Any, Callable, Dict, List, Literal, Optional, Union
+
+import regex as re
+import torch
+import torch.nn.functional as F
+from einops import rearrange
+from transformers import AutoTokenizer, UMT5EncoderModel
+
+from diffusers.callbacks import MultiPipelineCallbacks, PipelineCallback
+from diffusers.image_processor import PipelineImageInput
+from diffusers.loaders import WanLoraLoaderMixin
+from diffusers.models import AutoencoderKLWan
+from diffusers.pipelines.pipeline_utils import DiffusionPipeline
+from diffusers.schedulers import UniPCMultistepScheduler
+from diffusers.utils import is_ftfy_available, is_torch_xla_available, logging, replace_example_docstring
+from diffusers.utils.torch_utils import randn_tensor
+from diffusers.video_processor import VideoProcessor
+
+from ..modules.transformer_helios import HeliosTransformer3DModel
+from ..scheduler.scheduling_helios import HeliosScheduler
+from ..utils.utils_base import AdaptiveAntiDrifting, apply_schedule_shift
+from ..utils.utils_helios_post import add_noise, convert_flow_pred_to_x0
+from .pipeline_output import HeliosPipelineOutput
+
+
+if is_torch_xla_available():
+    import torch_xla.core.xla_model as xm
+
+    XLA_AVAILABLE = True
+else:
+    XLA_AVAILABLE = False
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+if is_ftfy_available():
+    import ftfy
+
+
+EXAMPLE_DOC_STRING = """
+    Examples:
+        ```python
+        >>> import torch
+        >>> from diffusers.utils import export_to_video
+        >>> from diffusers import AutoencoderKLWan, HeliosPipeline
+
+        >>> # Available models: BestWishYsh/Helios-Base, BestWishYsh/Helios-Mid, BestWishYsh/Helios-Distilled
+        >>> model_id = "BestWishYsh/Helios-Base"
+        >>> vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", torch_dtype=torch.float32)
+        >>> pipe = HeliosPipeline.from_pretrained(model_id, vae=vae, torch_dtype=torch.bfloat16)
+        >>> pipe.to("cuda")
+
+        >>> prompt = "A cat and a dog baking a cake together in a kitchen. The cat is carefully measuring flour, while the dog is stirring the batter with a wooden spoon. The kitchen is cozy, with sunlight streaming through the window."
+        >>> negative_prompt = "Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards"
+
+        >>> output = pipe(
+        ...     prompt=prompt,
+        ...     negative_prompt=negative_prompt,
+        ...     height=384,
+        ...     width=640,
+        ...     num_frames=132,
+        ...     guidance_scale=5.0,
+        ... ).frames[0]
+        >>> export_to_video(output, "output.mp4", fps=24)
+        ```
+"""
+
+
+@torch.amp.autocast("cuda", dtype=torch.float32)
+def optimized_scale(positive_flat, negative_flat):
+    # Calculate dot production
+    dot_product = torch.sum(positive_flat * negative_flat, dim=1, keepdim=True)
+
+    # Squared norm of uncondition
+    squared_norm = torch.sum(negative_flat**2, dim=1, keepdim=True) + 1e-8
+
+    # st_star = v_cond^T * v_uncond / ||v_uncond||^2
+    st_star = dot_product / squared_norm
+
+    return st_star
+
+
+def basic_clean(text):
+    text = ftfy.fix_text(text)
+    text = html.unescape(html.unescape(text))
+    return text.strip()
+
+
+def whitespace_clean(text):
+    text = re.sub(r"\s+", " ", text)
+    text = text.strip()
+    return text
+
+
+def prompt_clean(text):
+    text = whitespace_clean(basic_clean(text))
+    return text
+
+
+class VAEDecodeType(str, Enum):
+    DEFAULT = "default"
+    DEFAULT_BATCH = "default_batch"
+
+
+class HeliosPipeline(DiffusionPipeline, WanLoraLoaderMixin):
+    r"""
+    Pipeline for text-to-video / image-to-video / video-to-video generation using Helios.
+
+    This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods
+    implemented for all pipelines (downloading, saving, running on a particular device, etc.).
+
+    Args:
+        tokenizer ([`T5Tokenizer`]):
+            Tokenizer from [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer),
+            specifically the [google/umt5-xxl](https://huggingface.co/google/umt5-xxl) variant.
+        text_encoder ([`T5EncoderModel`]):
+            [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), specifically
+            the [google/umt5-xxl](https://huggingface.co/google/umt5-xxl) variant.
+        transformer ([`HeliosTransformer3DModel`]):
+            Conditional Transformer to denoise the input latents.
+        scheduler ([`UniPCMultistepScheduler`]):
+            A scheduler to be used in combination with `transformer` to denoise the encoded image latents.
+        vae ([`AutoencoderKLWan`]):
+            Variational Auto-Encoder (VAE) Model to encode and decode videos to and from latent representations.
+    """
+
+    model_cpu_offload_seq = "text_encoder->transformer->vae"
+    _callback_tensor_inputs = ["latents", "prompt_embeds", "negative_prompt_embeds"]
+    _optional_components = ["transformer"]
+
+    def __init__(
+        self,
+        tokenizer: AutoTokenizer,
+        text_encoder: UMT5EncoderModel,
+        vae: AutoencoderKLWan,
+        scheduler: UniPCMultistepScheduler | HeliosScheduler,
+        transformer: HeliosTransformer3DModel,
+    ):
+        super().__init__()
+
+        self.register_modules(
+            vae=vae,
+            text_encoder=text_encoder,
+            tokenizer=tokenizer,
+            transformer=transformer,
+            scheduler=scheduler,
+        )
+        self.vae_scale_factor_temporal = self.vae.config.scale_factor_temporal if getattr(self, "vae", None) else 4
+        self.vae_scale_factor_spatial = self.vae.config.scale_factor_spatial if getattr(self, "vae", None) else 8
+        self.video_processor = VideoProcessor(vae_scale_factor=self.vae_scale_factor_spatial)
+
+    def _get_t5_prompt_embeds(
+        self,
+        prompt: Union[str, List[str]] = None,
+        num_videos_per_prompt: int = 1,
+        max_sequence_length: int = 226,
+        device: Optional[torch.device] = None,
+        dtype: Optional[torch.dtype] = None,
+    ):
+        device = device or self._execution_device
+        dtype = dtype or self.text_encoder.dtype
+
+        prompt = [prompt] if isinstance(prompt, str) else prompt
+        prompt = [prompt_clean(u) for u in prompt]
+        batch_size = len(prompt)
+
+        text_inputs = self.tokenizer(
+            prompt,
+            padding="max_length",
+            max_length=max_sequence_length,
+            truncation=True,
+            add_special_tokens=True,
+            return_attention_mask=True,
+            return_tensors="pt",
+        )
+        text_input_ids, mask = text_inputs.input_ids, text_inputs.attention_mask
+        seq_lens = mask.gt(0).sum(dim=1).long()
+
+        prompt_embeds = self.text_encoder(text_input_ids.to(device), mask.to(device)).last_hidden_state
+        prompt_embeds = prompt_embeds.to(dtype=dtype, device=device)
+        prompt_embeds = [u[:v] for u, v in zip(prompt_embeds, seq_lens)]
+        prompt_embeds = torch.stack(
+            [torch.cat([u, u.new_zeros(max_sequence_length - u.size(0), u.size(1))]) for u in prompt_embeds], dim=0
+        )
+
+        # duplicate text embeddings for each generation per prompt, using mps friendly method
+        _, seq_len, _ = prompt_embeds.shape
+        prompt_embeds = prompt_embeds.repeat(1, num_videos_per_prompt, 1)
+        prompt_embeds = prompt_embeds.view(batch_size * num_videos_per_prompt, seq_len, -1)
+
+        return prompt_embeds, text_inputs.attention_mask.bool()
+
+    def encode_prompt(
+        self,
+        prompt: Union[str, List[str]],
+        negative_prompt: Optional[Union[str, List[str]]] = None,
+        do_classifier_free_guidance: bool = True,
+        num_videos_per_prompt: int = 1,
+        prompt_embeds: Optional[torch.Tensor] = None,
+        negative_prompt_embeds: Optional[torch.Tensor] = None,
+        max_sequence_length: int = 226,
+        device: Optional[torch.device] = None,
+        dtype: Optional[torch.dtype] = None,
+    ):
+        r"""
+        Encodes the prompt into text encoder hidden states.
+
+        Args:
+            prompt (`str` or `List[str]`, *optional*):
+                prompt to be encoded
+            negative_prompt (`str` or `List[str]`, *optional*):
+                The prompt or prompts not to guide the image generation. If not defined, one has to pass
+                `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is
+                less than `1`).
+            do_classifier_free_guidance (`bool`, *optional*, defaults to `True`):
+                Whether to use classifier free guidance or not.
+            num_videos_per_prompt (`int`, *optional*, defaults to 1):
+                Number of videos that should be generated per prompt. torch device to place the resulting embeddings on
+            prompt_embeds (`torch.Tensor`, *optional*):
+                Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not
+                provided, text embeddings will be generated from `prompt` input argument.
+            negative_prompt_embeds (`torch.Tensor`, *optional*):
+                Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt
+                weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input
+                argument.
+            device: (`torch.device`, *optional*):
+                torch device
+            dtype: (`torch.dtype`, *optional*):
+                torch dtype
+        """
+        device = device or self._execution_device
+
+        prompt = [prompt] if isinstance(prompt, str) else prompt
+        if prompt is not None:
+            batch_size = len(prompt)
+        else:
+            batch_size = prompt_embeds.shape[0]
+
+        if prompt_embeds is None:
+            prompt_embeds, prompt_attention_mask = self._get_t5_prompt_embeds(
+                prompt=prompt,
+                num_videos_per_prompt=num_videos_per_prompt,
+                max_sequence_length=max_sequence_length,
+                device=device,
+                dtype=dtype,
+            )
+
+        negative_prompt_attention_mask = None
+        if do_classifier_free_guidance and negative_prompt_embeds is None:
+            negative_prompt = negative_prompt or ""
+            negative_prompt = batch_size * [negative_prompt] if isinstance(negative_prompt, str) else negative_prompt
+
+            if prompt is not None and type(prompt) is not type(negative_prompt):
+                raise TypeError(
+                    f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
+                    f" {type(prompt)}."
+                )
+            elif batch_size != len(negative_prompt):
+                raise ValueError(
+                    f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
+                    f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
+                    " the batch size of `prompt`."
+                )
+
+            negative_prompt_embeds, negative_prompt_attention_mask = self._get_t5_prompt_embeds(
+                prompt=negative_prompt,
+                num_videos_per_prompt=num_videos_per_prompt,
+                max_sequence_length=max_sequence_length,
+                device=device,
+                dtype=dtype,
+            )
+
+        return prompt_embeds, prompt_attention_mask, negative_prompt_embeds, negative_prompt_attention_mask
+
+    def check_inputs(
+        self,
+        prompt,
+        negative_prompt,
+        height,
+        width,
+        prompt_embeds=None,
+        negative_prompt_embeds=None,
+        callback_on_step_end_tensor_inputs=None,
+    ):
+        if height % 16 != 0 or width % 16 != 0:
+            raise ValueError(f"`height` and `width` have to be divisible by 16 but are {height} and {width}.")
+
+        if callback_on_step_end_tensor_inputs is not None and not all(
+            k in self._callback_tensor_inputs for k in callback_on_step_end_tensor_inputs
+        ):
+            raise ValueError(
+                f"`callback_on_step_end_tensor_inputs` has to be in {self._callback_tensor_inputs}, but found {[k for k in callback_on_step_end_tensor_inputs if k not in self._callback_tensor_inputs]}"
+            )
+
+        if prompt is not None and prompt_embeds is not None:
+            raise ValueError(
+                f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to"
+                " only forward one of the two."
+            )
+        elif negative_prompt is not None and negative_prompt_embeds is not None:
+            raise ValueError(
+                f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`: {negative_prompt_embeds}. Please make sure to"
+                " only forward one of the two."
+            )
+        elif prompt is None and prompt_embeds is None:
+            raise ValueError(
+                "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined."
+            )
+        elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)):
+            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
+        elif negative_prompt is not None and (
+            not isinstance(negative_prompt, str) and not isinstance(negative_prompt, list)
+        ):
+            raise ValueError(f"`negative_prompt` has to be of type `str` or `list` but is {type(negative_prompt)}")
+
+    def prepare_latents(
+        self,
+        batch_size: int,
+        num_channels_latents: int = 16,
+        height: int = 480,
+        width: int = 832,
+        num_frames: int = 81,
+        dtype: Optional[torch.dtype] = None,
+        device: Optional[torch.device] = None,
+        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
+        latents: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        if latents is not None:
+            return latents.to(device=device, dtype=dtype)
+
+        num_latent_frames = (num_frames - 1) // self.vae_scale_factor_temporal + 1
+        shape = (
+            batch_size,
+            num_channels_latents,
+            num_latent_frames,
+            int(height) // self.vae_scale_factor_spatial,
+            int(width) // self.vae_scale_factor_spatial,
+        )
+        if isinstance(generator, list) and len(generator) != batch_size:
+            raise ValueError(
+                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
+                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
+            )
+
+        latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
+        return latents
+
+    def prepare_image_latents(
+        self,
+        image: torch.Tensor,
+        latents_mean: torch.Tensor,
+        latents_std: torch.Tensor,
+        dtype: Optional[torch.dtype] = None,
+        device: Optional[torch.device] = None,
+        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
+        latents: Optional[torch.Tensor] = None,
+        fake_latents: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        device = device or self._execution_device
+        if latents is None:
+            image = image.unsqueeze(2).to(device=device, dtype=self.vae.dtype)
+            latents = self.vae.encode(image).latent_dist.sample(generator=generator)
+            latents = (latents - latents_mean) * latents_std
+        if fake_latents is None:
+            fake_video = image.repeat(1, 1, 33, 1, 1).to(device=device, dtype=self.vae.dtype)
+            fake_latents_full = self.vae.encode(fake_video).latent_dist.sample(generator=generator)
+            fake_latents_full = (fake_latents_full - latents_mean) * latents_std
+            fake_latents = fake_latents_full[:, :, -1:, :, :]
+        return latents.to(device=device, dtype=dtype), fake_latents.to(device=device, dtype=dtype)
+
+    def prepare_video_latents(
+        self,
+        video: torch.Tensor,
+        latents_mean: torch.Tensor,
+        latents_std: torch.Tensor,
+        latent_window_size: int,
+        dtype: Optional[torch.dtype] = None,
+        device: Optional[torch.device] = None,
+        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
+        latents: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        device = device or self._execution_device
+        video = video.to(device=device, dtype=self.vae.dtype)
+        if latents is None:
+            num_frames = video.shape[2]
+            min_frames = (latent_window_size - 1) * 4 + 1
+            num_chunks = num_frames // min_frames
+            if num_chunks == 0:
+                raise ValueError(
+                    f"Video must have at least {min_frames} frames "
+                    f"(got {num_frames} frames). "
+                    f"Required: (latent_window_size - 1) * 4 + 1 = ({latent_window_size} - 1) * 4 + 1 = {min_frames}"
+                )
+            total_valid_frames = num_chunks * min_frames
+            start_frame = num_frames - total_valid_frames
+
+            first_frame = video[:, :, 0:1, :, :]
+            first_frame_latent = self.vae.encode(first_frame).latent_dist.sample(generator=generator)
+            first_frame_latent = (first_frame_latent - latents_mean) * latents_std
+
+            latents_chunks = []
+            for i in range(num_chunks - 1, -1, -1):
+                chunk_start = start_frame + i * min_frames
+                chunk_end = chunk_start + min_frames
+                video_chunk = video[:, :, chunk_start:chunk_end, :, :]
+                chunk_latents = self.vae.encode(video_chunk).latent_dist.sample(generator=generator)
+                chunk_latents = (chunk_latents - latents_mean) * latents_std
+                latents_chunks.insert(0, chunk_latents)
+            latents = torch.cat(latents_chunks, dim=2)
+        return first_frame_latent.to(device=device, dtype=dtype), latents.to(device=device, dtype=dtype)
+
+    def interpolate_prompt_embeds(
+        self,
+        prompt_embeds_1: torch.Tensor,
+        prompt_embeds_2: torch.Tensor,
+        interpolation_steps: int = 4,
+    ):
+        x = torch.lerp(
+            prompt_embeds_1,
+            prompt_embeds_2,
+            torch.linspace(0, 1, steps=interpolation_steps).unsqueeze(1).unsqueeze(2).to(prompt_embeds_1),
+        )
+        interpolated_prompt_embeds = list(x.chunk(interpolation_steps, dim=0))
+        return interpolated_prompt_embeds
+
+    def sample_block_noise(
+        self,
+        batch_size,
+        channel,
+        num_frames,
+        height,
+        width,
+        patch_size: tuple[int, ...] = (1, 2, 2),
+        device: torch.device | None = None,
+        generator: torch.Generator | None = None,
+    ):
+        # NOTE: A generator must be provided to ensure correct and reproducible results.
+        # Creating a default generator here is a fallback only — without a fixed seed,
+        # the output will be non-deterministic and may produce incorrect results in CP context.
+        if generator is None:
+            generator = torch.Generator(device=device)
+        elif isinstance(generator, list):
+            generator = generator[0]
+
+        gamma = self.scheduler.config.gamma
+        _, ph, pw = patch_size
+        block_size = ph * pw
+
+        cov = (
+            torch.eye(block_size, device=device) * (1 + gamma)
+            - torch.ones(block_size, block_size, device=device) * gamma
+        )
+        cov += torch.eye(block_size, device=device) * 1e-8
+        cov = cov.float()  # Upcast to fp32 for numerical stability — cholesky is unreliable in fp16/bf16.
+
+        L = torch.linalg.cholesky(cov)
+        block_number = batch_size * channel * num_frames * (height // ph) * (width // pw)
+        z = torch.randn(block_number, block_size, generator=generator, device=generator.device).to(device=device)
+        noise = z @ L.T
+
+        noise = noise.view(batch_size, channel, num_frames, height // ph, width // pw, ph, pw)
+        noise = noise.permute(0, 1, 2, 3, 5, 4, 6).reshape(batch_size, channel, num_frames, height, width)
+
+        return noise
+
+    def stage1_sample(
+        self,
+        latents: torch.Tensor = None,
+        prompt_embeds: torch.Tensor = None,
+        negative_prompt_embeds: torch.Tensor = None,
+        timesteps: torch.Tensor = None,
+        guidance_scale: Optional[float] = 5.0,
+        indices_hidden_states: torch.Tensor = None,
+        indices_latents_history_short: torch.Tensor = None,
+        indices_latents_history_mid: torch.Tensor = None,
+        indices_latents_history_long: torch.Tensor = None,
+        latents_history_short: torch.Tensor = None,
+        latents_history_mid: torch.Tensor = None,
+        latents_history_long: torch.Tensor = None,
+        attention_kwargs: Optional[dict] = None,
+        device: Optional[torch.device] = None,
+        transformer_dtype: torch.dtype = None,
+        generator: Optional[torch.Generator] = None,
+        # ------------ CFG Zero ------------
+        use_cfg_zero_star: Optional[bool] = False,
+        use_zero_init: Optional[bool] = True,
+        zero_steps: Optional[int] = 1,
+        # -------------- DMD --------------
+        use_dmd: bool = False,
+        dmd_sigmas: torch.Tensor = None,
+        dmd_timesteps: torch.Tensor = None,
+        is_amplify_first_chunk: bool = False,
+        # ------------ Callback ------------
+        callback_on_step_end: Optional[callable] = None,
+        callback_on_step_end_tensor_inputs: list = None,
+        progress_bar=None,
+    ):
+        batch_size = latents.shape[0]
+
+        for i, t in enumerate(timesteps):
+            is_first_step = i == 0
+
+            if self.interrupt:
+                continue
+
+            self._current_timestep = t
+            timestep = t.expand(latents.shape[0])
+
+            latent_model_input = latents.to(transformer_dtype)
+            with self.transformer.cache_context("cond"):
+                noise_pred = self.transformer(
+                    hidden_states=latent_model_input,
+                    timestep=timestep,
+                    encoder_hidden_states=prompt_embeds,
+                    indices_hidden_states=indices_hidden_states,
+                    indices_latents_history_short=indices_latents_history_short,
+                    indices_latents_history_mid=indices_latents_history_mid,
+                    indices_latents_history_long=indices_latents_history_long,
+                    latents_history_short=latents_history_short.to(transformer_dtype),
+                    latents_history_mid=latents_history_mid.to(transformer_dtype),
+                    latents_history_long=latents_history_long.to(transformer_dtype),
+                    is_first_denoising_step=is_first_step,
+                    attention_kwargs=attention_kwargs,
+                    return_dict=False,
+                )[0]
+
+            if self.do_classifier_free_guidance and not use_dmd:
+                with self.transformer.cache_context("uncond"):
+                    noise_uncond = self.transformer(
+                        hidden_states=latent_model_input,
+                        timestep=timestep,
+                        encoder_hidden_states=negative_prompt_embeds,
+                        indices_hidden_states=indices_hidden_states,
+                        indices_latents_history_short=indices_latents_history_short,
+                        indices_latents_history_mid=indices_latents_history_mid,
+                        indices_latents_history_long=indices_latents_history_long,
+                        latents_history_short=latents_history_short.to(transformer_dtype),
+                        latents_history_mid=latents_history_mid.to(transformer_dtype),
+                        latents_history_long=latents_history_long.to(transformer_dtype),
+                        is_first_denoising_step=is_first_step,
+                        attention_kwargs=attention_kwargs,
+                        return_dict=False,
+                    )[0]
+
+                if use_cfg_zero_star:
+                    noise_pred_text = noise_pred
+                    positive_flat = noise_pred_text.view(batch_size, -1)
+                    negative_flat = noise_uncond.view(batch_size, -1)
+
+                    alpha = optimized_scale(positive_flat, negative_flat)
+                    alpha = alpha.view(batch_size, *([1] * (len(noise_pred_text.shape) - 1)))
+                    alpha = alpha.to(noise_pred_text.dtype)
+
+                    if (i <= zero_steps) and use_zero_init:
+                        noise_pred = noise_pred_text * 0.0
+                    else:
+                        noise_pred = noise_uncond * alpha + guidance_scale * (noise_pred_text - noise_uncond * alpha)
+                else:
+                    noise_pred = noise_uncond + guidance_scale * (noise_pred - noise_uncond)
+
+            if use_dmd:
+                pred_image_or_video = convert_flow_pred_to_x0(
+                    flow_pred=noise_pred,
+                    xt=latent_model_input,
+                    timestep=t * torch.ones(batch_size, dtype=torch.long, device=noise_pred.device),
+                    sigmas=dmd_sigmas,
+                    timesteps=dmd_timesteps,
+                )
+                if i < len(timesteps) - 1:
+                    latents = add_noise(
+                        pred_image_or_video,
+                        randn_tensor(pred_image_or_video.shape, generator=generator, device=device),
+                        timesteps[i + 1] * torch.ones(batch_size, dtype=torch.long, device=noise_pred.device),
+                        sigmas=dmd_sigmas,
+                        timesteps=dmd_timesteps,
+                    )
+                else:
+                    latents = pred_image_or_video
+            else:
+                # compute the previous noisy sample x_t -> x_t-1
+                latents = self.scheduler.step(noise_pred, t, latents, return_dict=False)[0]
+
+            if callback_on_step_end is not None:
+                callback_kwargs = {}
+                for k in callback_on_step_end_tensor_inputs:
+                    callback_kwargs[k] = locals()[k]
+                callback_outputs = callback_on_step_end(self, i, t, callback_kwargs)
+
+                latents = callback_outputs.pop("latents", latents)
+                prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds)
+                negative_prompt_embeds = callback_outputs.pop("negative_prompt_embeds", negative_prompt_embeds)
+
+            progress_bar.update()
+
+            if XLA_AVAILABLE:
+                xm.mark_step()
+
+        return latents
+
+    def stage2_sample(
+        self,
+        latents: torch.Tensor = None,
+        stage2_num_stages: int = None,
+        stage2_num_inference_steps_list: List[int] = None,
+        prompt_embeds: torch.Tensor = None,
+        negative_prompt_embeds: torch.Tensor = None,
+        guidance_scale: Optional[float] = 5.0,
+        indices_hidden_states: torch.Tensor = None,
+        indices_latents_history_short: torch.Tensor = None,
+        indices_latents_history_mid: torch.Tensor = None,
+        indices_latents_history_long: torch.Tensor = None,
+        latents_history_short: torch.Tensor = None,
+        latents_history_mid: torch.Tensor = None,
+        latents_history_long: torch.Tensor = None,
+        attention_kwargs: Optional[dict] = None,
+        device: Optional[torch.device] = None,
+        transformer_dtype: torch.dtype = None,
+        scheduler_type: str = "unipc",  # unipc, euler
+        use_dynamic_shifting: bool = False,
+        time_shift_type: Literal["exponential", "linear"] = "linear",
+        generator: torch.Generator | list[torch.Generator] | None = None,
+        # ------------ CFG Zero ------------
+        use_cfg_zero_star: Optional[bool] = False,
+        use_zero_init: Optional[bool] = True,
+        zero_steps: Optional[int] = 1,
+        # -------------- DMD --------------
+        use_dmd: bool = False,
+        is_amplify_first_chunk: bool = False,
+        # ------------ Callback ------------
+        callback_on_step_end: Optional[callable] = None,
+        callback_on_step_end_tensor_inputs: list = None,
+        progress_bar=None,
+    ):
+        num_frames, height, width = (
+            latents.shape[-3],
+            latents.shape[-2],
+            latents.shape[-1],
+        )
+        latents = rearrange(latents, "b c t h w -> (b t) c h w")
+        for _ in range(stage2_num_stages - 1):
+            height //= 2
+            width //= 2
+            latents = (
+                F.interpolate(
+                    latents,
+                    size=(height, width),
+                    mode="bilinear",
+                )
+                * 2
+            )
+        latents = rearrange(latents, "(b t) c h w -> b c t h w", t=num_frames)
+
+        batch_size = latents.shape[0]
+        if use_dmd:
+            start_point_list = [latents]
+
+        i = 0
+        for i_s in range(stage2_num_stages):
+            if use_dmd:
+                if is_amplify_first_chunk:
+                    self.scheduler.set_timesteps(stage2_num_inference_steps_list[i_s] * 2 + 1, i_s, device=device)
+                else:
+                    self.scheduler.set_timesteps(stage2_num_inference_steps_list[i_s] + 1, i_s, device=device)
+                self.scheduler.timesteps = self.scheduler.timesteps[:-1]
+                self.scheduler.sigmas = torch.cat([self.scheduler.sigmas[:-2], self.scheduler.sigmas[-1:]])
+            else:
+                self.scheduler.set_timesteps(stage2_num_inference_steps_list[i_s], i_s, device=device)
+
+            if i_s > 0:
+                height *= 2
+                width *= 2
+                num_frames = latents.shape[2]
+                latents = rearrange(latents, "b c t h w -> (b t) c h w")
+                latents = F.interpolate(latents, size=(height, width), mode="nearest")
+                latents = rearrange(latents, "(b t) c h w -> b c t h w", t=num_frames)
+                # Fix the stage
+                ori_sigma = 1 - self.scheduler.ori_start_sigmas[i_s]  # the original coeff of signal
+                gamma = self.scheduler.config.gamma
+                alpha = 1 / (math.sqrt(1 + (1 / gamma)) * (1 - ori_sigma) + ori_sigma)
+                beta = alpha * (1 - ori_sigma) / math.sqrt(gamma)
+
+                batch_size, channel, num_frames, height, width = latents.shape
+                noise = self.sample_block_noise(
+                    batch_size,
+                    channel,
+                    num_frames,
+                    height,
+                    width,
+                    self.transformer.config.patch_size,
+                    device,
+                    generator,
+                )
+                noise = noise.to(device=device, dtype=transformer_dtype)
+                latents = alpha * latents + beta * noise  # To fix the block artifact
+
+                if use_dmd:
+                    start_point_list.append(latents)
+
+            if use_dynamic_shifting:
+                temp_sigmas = apply_schedule_shift(
+                    self.scheduler.sigmas,
+                    latents,
+                    base_seq_len=self.scheduler.config.get("base_image_seq_len", 256),
+                    max_seq_len=self.scheduler.config.get("max_image_seq_len", 4096),
+                    base_shift=self.scheduler.config.get("base_shift", 0.5),
+                    max_shift=self.scheduler.config.get("max_shift", 1.15),
+                    time_shift_type=time_shift_type,
+                )
+                temp_timesteps = self.scheduler.timesteps_per_stage[i_s].min() + temp_sigmas[:-1] * (
+                    self.scheduler.timesteps_per_stage[i_s].max() - self.scheduler.timesteps_per_stage[i_s].min()
+                )
+
+                self.scheduler.sigmas = temp_sigmas
+                self.scheduler.timesteps = temp_timesteps
+
+            timesteps = self.scheduler.timesteps
+
+            for idx, t in enumerate(timesteps):
+                is_first_step = i_s == 0 and idx == 0
+
+                timestep = t.expand(latents.shape[0]).to(torch.int64)
+
+                with self.transformer.cache_context("cond"):
+                    noise_pred = self.transformer(
+                        hidden_states=latents.to(transformer_dtype),
+                        timestep=timestep,
+                        encoder_hidden_states=prompt_embeds,
+                        attention_kwargs=attention_kwargs,
+                        return_dict=False,
+                        indices_hidden_states=indices_hidden_states,
+                        indices_latents_history_short=indices_latents_history_short,
+                        indices_latents_history_mid=indices_latents_history_mid,
+                        indices_latents_history_long=indices_latents_history_long,
+                        latents_history_short=latents_history_short.to(transformer_dtype),
+                        latents_history_mid=latents_history_mid.to(transformer_dtype),
+                        latents_history_long=latents_history_long.to(transformer_dtype),
+                        is_first_denoising_step=is_first_step,
+                    )[0]
+
+                if self.do_classifier_free_guidance:
+                    with self.transformer.cache_context("cond_uncond"):
+                        noise_uncond = self.transformer(
+                            hidden_states=latents.to(transformer_dtype),
+                            timestep=timestep,
+                            encoder_hidden_states=negative_prompt_embeds,
+                            attention_kwargs=attention_kwargs,
+                            return_dict=False,
+                            indices_hidden_states=indices_hidden_states,
+                            indices_latents_history_short=indices_latents_history_short,
+                            indices_latents_history_mid=indices_latents_history_mid,
+                            indices_latents_history_long=indices_latents_history_long,
+                            latents_history_short=latents_history_short.to(transformer_dtype),
+                            latents_history_mid=latents_history_mid.to(transformer_dtype),
+                            latents_history_long=latents_history_long.to(transformer_dtype),
+                            is_first_denoising_step=is_first_step,
+                        )[0]
+
+                    if use_cfg_zero_star:
+                        noise_pred_text = noise_pred
+                        positive_flat = noise_pred_text.view(batch_size, -1)
+                        negative_flat = noise_uncond.view(batch_size, -1)
+
+                        alpha = optimized_scale(positive_flat, negative_flat)
+                        alpha = alpha.view(batch_size, *([1] * (len(noise_pred_text.shape) - 1)))
+                        alpha = alpha.to(noise_pred_text.dtype)
+
+                        if (i_s == 0 and idx <= zero_steps) and use_zero_init:
+                            noise_pred = noise_pred_text * 0.0
+                        else:
+                            noise_pred = noise_uncond * alpha + guidance_scale * (
+                                noise_pred_text - noise_uncond * alpha
+                            )
+                    else:
+                        noise_pred = noise_uncond + guidance_scale * (noise_pred - noise_uncond)
+
+                if use_dmd:
+                    pred_image_or_video = convert_flow_pred_to_x0(
+                        flow_pred=noise_pred,
+                        xt=latents,
+                        timestep=timestep,
+                        sigmas=self.scheduler.sigmas,
+                        timesteps=self.scheduler.timesteps,
+                    )
+                    if idx < len(timesteps) - 1:
+                        latents = add_noise(
+                            pred_image_or_video,
+                            start_point_list[i_s],
+                            timesteps[idx + 1] * torch.ones(batch_size, dtype=torch.long, device=noise_pred.device),
+                            sigmas=self.scheduler.sigmas,
+                            timesteps=self.scheduler.timesteps,
+                        )
+                    else:
+                        latents = pred_image_or_video
+                else:
+                    if scheduler_type == "unipc":
+                        latents = self.scheduler.step_unipc(noise_pred.float(), t, latents, return_dict=False)[0]
+                    else:
+                        latents = self.scheduler.step(noise_pred.float(), t, latents, return_dict=False)[0]
+
+                if callback_on_step_end is not None:
+                    callback_kwargs = {}
+                    for k in callback_on_step_end_tensor_inputs:
+                        callback_kwargs[k] = locals()[k]
+                    callback_outputs = callback_on_step_end(self, i, t, callback_kwargs)
+
+                    latents = callback_outputs.pop("latents", latents)
+                    prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds)
+                    negative_prompt_embeds = callback_outputs.pop("negative_prompt_embeds", negative_prompt_embeds)
+
+                progress_bar.update()
+
+                if XLA_AVAILABLE:
+                    xm.mark_step()
+
+                i += 1
+
+        return latents
+
+    @property
+    def guidance_scale(self):
+        return self._guidance_scale
+
+    @property
+    def do_classifier_free_guidance(self):
+        return self._guidance_scale > 1.0
+
+    @property
+    def num_timesteps(self):
+        return self._num_timesteps
+
+    @property
+    def current_timestep(self):
+        return self._current_timestep
+
+    @property
+    def interrupt(self):
+        return self._interrupt
+
+    @property
+    def attention_kwargs(self):
+        return self._attention_kwargs
+
+    @torch.no_grad()
+    @replace_example_docstring(EXAMPLE_DOC_STRING)
+    def __call__(
+        self,
+        prompt: Union[str, List[str]] = None,
+        negative_prompt: Union[str, List[str]] = None,
+        height: int = 384,
+        width: int = 640,
+        num_frames: int = 73,
+        num_inference_steps: int = 50,
+        guidance_scale: float = 5.0,
+        num_videos_per_prompt: Optional[int] = 1,
+        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
+        latents: Optional[torch.Tensor] = None,
+        prompt_embeds: Optional[torch.Tensor] = None,
+        negative_prompt_embeds: Optional[torch.Tensor] = None,
+        output_type: Optional[str] = "np",
+        return_dict: bool = True,
+        attention_kwargs: Optional[Dict[str, Any]] = None,
+        callback_on_step_end: Optional[
+            Union[Callable[[int, int, Dict], None], PipelineCallback, MultiPipelineCallbacks]
+        ] = None,
+        callback_on_step_end_tensor_inputs: List[str] = ["latents"],
+        max_sequence_length: int = 512,
+        # ------------ I2V ------------
+        image: Optional[PipelineImageInput] = None,
+        image_latents: Optional[torch.Tensor] = None,
+        fake_image_latents: Optional[torch.Tensor] = None,
+        add_noise_to_image_latents: bool = True,
+        image_noise_sigma_min: float = 0.111,
+        image_noise_sigma_max: float = 0.135,
+        # ------------ V2V ------------
+        video: Optional[PipelineImageInput] = None,
+        video_latents: Optional[torch.Tensor] = None,
+        add_noise_to_video_latents: bool = True,
+        video_noise_sigma_min: float = 0.111,
+        video_noise_sigma_max: float = 0.135,
+        # ------------ Interactive ------------
+        use_interpolate_prompt: bool = False,
+        interpolate_time_list: list = [7, 7, 7],
+        interpolation_steps: int = 3,
+        # ------------ Stage 1 ------------
+        history_sizes: list = [16, 2, 1],
+        latent_window_size: int = 9,
+        use_dynamic_shifting: bool = False,
+        time_shift_type: Literal["exponential", "linear"] = "linear",
+        is_keep_x0: bool = True,
+        # ------------ Stage 2 ------------
+        is_enable_stage2: bool = False,
+        stage2_num_stages: int = 3,
+        stage2_num_inference_steps_list: list = [10, 10, 10],
+        scheduler_type: str = "unipc",  # unipc, euler
+        # ------------ CFG Zero ------------
+        use_cfg_zero_star: Optional[bool] = False,
+        use_zero_init: Optional[bool] = True,
+        zero_steps: Optional[int] = 1,
+        # ------------ DMD ------------
+        use_dmd: bool = False,
+        is_skip_first_section: bool = False,
+        is_amplify_first_chunk: bool = False,
+        # ------------ Adaptive Anti-Drifting ------------
+        use_adaptive_anti_drifting: bool = False,
+        anti_drift_rho_mu: float = 0.9,
+        anti_drift_rho_sigma: float = 0.9,
+        anti_drift_delta_mu: float = 0.15,
+        anti_drift_delta_sigma: float = 0.15,
+        anti_drift_corruption_strength: float = 0.1,
+        # ------------ other ------------
+        use_kv_cache: bool = False,
+        vae_decode_type: VAEDecodeType = "default",  # "default", "default_batch"
+    ):
+        r"""
+        The call function to the pipeline for generation.
+
+        Args:
+            prompt (`str` or `List[str]`, *optional*):
+                The prompt or prompts to guide the image generation. If not defined, pass `prompt_embeds` instead.
+            negative_prompt (`str` or `List[str]`, *optional*):
+                The prompt or prompts to avoid during image generation. If not defined, pass `negative_prompt_embeds`
+                instead. Ignored when not using guidance (`guidance_scale` < `1`).
+            height (`int`, defaults to `480`):
+                The height in pixels of the generated image.
+            width (`int`, defaults to `832`):
+                The width in pixels of the generated image.
+            num_frames (`int`, defaults to `81`):
+                The number of frames in the generated video.
+            num_inference_steps (`int`, defaults to `50`):
+                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
+                expense of slower inference.
+            guidance_scale (`float`, defaults to `5.0`):
+                Guidance scale as defined in [Classifier-Free Diffusion
+                Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` is defined as `w` of equation 2.
+                of [Imagen Paper](https://huggingface.co/papers/2205.11487). Guidance scale is enabled by setting
+                `guidance_scale > 1`. Higher guidance scale encourages to generate images that are closely linked to
+                the text `prompt`, usually at the expense of lower image quality.
+            num_videos_per_prompt (`int`, *optional*, defaults to 1):
+                The number of images to generate per prompt.
+            generator (`torch.Generator` or `List[torch.Generator]`, *optional*):
+                A [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make
+                generation deterministic.
+            latents (`torch.Tensor`, *optional*):
+                Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for image
+                generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
+                tensor is generated by sampling using the supplied random `generator`.
+            prompt_embeds (`torch.Tensor`, *optional*):
+                Pre-generated text embeddings. Can be used to easily tweak text inputs (prompt weighting). If not
+                provided, text embeddings are generated from the `prompt` input argument.
+            output_type (`str`, *optional*, defaults to `"np"`):
+                The output format of the generated image. Choose between `PIL.Image` or `np.array`.
+            return_dict (`bool`, *optional*, defaults to `True`):
+                Whether or not to return a [`HeliosPipelineOutput`] instead of a plain tuple.
+            attention_kwargs (`dict`, *optional*):
+                A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under
+                `self.processor` in
+                [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
+            callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *optional*):
+                A function or a subclass of `PipelineCallback` or `MultiPipelineCallbacks` that is called at the end of
+                each denoising step during the inference. with the following arguments: `callback_on_step_end(self:
+                DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` will include a
+                list of all tensors as specified by `callback_on_step_end_tensor_inputs`.
+            callback_on_step_end_tensor_inputs (`List`, *optional*):
+                The list of tensor inputs for the `callback_on_step_end` function. The tensors specified in the list
+                will be passed as `callback_kwargs` argument. You will only be able to include variables listed in the
+                `._callback_tensor_inputs` attribute of your pipeline class.
+            max_sequence_length (`int`, defaults to `512`):
+                The maximum sequence length of the text encoder. If the prompt is longer than this, it will be
+                truncated. If the prompt is shorter, it will be padded to this length.
+
+        Examples:
+
+        Returns:
+            [`~HeliosPipelineOutput`] or `tuple`:
+                If `return_dict` is `True`, [`HeliosPipelineOutput`] is returned, otherwise a `tuple` is returned where
+                the first element is a list with the generated images and the second element is a list of `bool`s
+                indicating whether the corresponding generated image contains "not-safe-for-work" (nsfw) content.
+        """
+
+        if image is not None and video is not None:
+            raise ValueError("image and video cannot be provided simultaneously")
+
+        if use_kv_cache:
+            self.transformer.enable_kv_cache()
+
+        if use_interpolate_prompt:
+            assert num_videos_per_prompt == 1, f"num_videos_per_prompt must be 1, got {num_videos_per_prompt}"
+            assert isinstance(prompt, list), "prompt must be a list"
+            assert len(prompt) == len(interpolate_time_list), (
+                f"Length mismatch: {len(prompt)} vs {len(interpolate_time_list)}"
+            )
+            assert min(interpolate_time_list) > interpolation_steps, (
+                f"Minimum value {min(interpolate_time_list)} must be greater than {interpolation_steps}"
+            )
+            interpolate_interval_idx = None
+            interpolate_embeds = None
+            interpolate_cumulative_list = list(accumulate(interpolate_time_list))
+
+        anti_drifting_helper = None
+        if use_adaptive_anti_drifting:
+            anti_drifting_helper = AdaptiveAntiDrifting(
+                rho_mu=anti_drift_rho_mu,
+                rho_sigma=anti_drift_rho_sigma,
+                delta_mu=anti_drift_delta_mu,
+                delta_sigma=anti_drift_delta_sigma,
+                device=self._execution_device,
+                dtype=torch.float32,
+            )
+
+        history_sizes = sorted(history_sizes, reverse=True)  # From big to small
+
+        latents_mean = (
+            torch.tensor(self.vae.config.latents_mean)
+            .view(1, self.vae.config.z_dim, 1, 1, 1)
+            .to(self.vae.device, self.vae.dtype)
+        )
+        latents_std = 1.0 / torch.tensor(self.vae.config.latents_std).view(1, self.vae.config.z_dim, 1, 1, 1).to(
+            self.vae.device, self.vae.dtype
+        )
+
+        if isinstance(callback_on_step_end, (PipelineCallback, MultiPipelineCallbacks)):
+            callback_on_step_end_tensor_inputs = callback_on_step_end.tensor_inputs
+
+        # 1. Check inputs. Raise error if not correct
+        self.check_inputs(
+            prompt,
+            negative_prompt,
+            height,
+            width,
+            prompt_embeds,
+            negative_prompt_embeds,
+            callback_on_step_end_tensor_inputs,
+        )
+
+        num_frames = max(num_frames, 1)
+
+        self._guidance_scale = guidance_scale
+        self._attention_kwargs = attention_kwargs
+        self._current_timestep = None
+        self._interrupt = False
+
+        device = self._execution_device
+        vae_dtype = self.vae.dtype
+
+        # 2. Define call parameters
+        if use_interpolate_prompt or (prompt is not None and isinstance(prompt, str)):
+            batch_size = 1
+        elif prompt is not None and isinstance(prompt, list):
+            batch_size = len(prompt)
+        else:
+            batch_size = prompt_embeds.shape[0]
+
+        # 3. Encode input prompt
+        all_prompt_embeds, prompt_attention_mask, negative_prompt_embeds, negative_prompt_attention_mask = (
+            self.encode_prompt(
+                prompt=prompt,
+                negative_prompt=negative_prompt,
+                do_classifier_free_guidance=self.do_classifier_free_guidance,
+                num_videos_per_prompt=num_videos_per_prompt,
+                prompt_embeds=prompt_embeds,
+                negative_prompt_embeds=negative_prompt_embeds,
+                max_sequence_length=max_sequence_length,
+                device=device,
+            )
+        )
+
+        transformer_dtype = self.transformer.dtype
+        all_prompt_embeds = all_prompt_embeds.to(transformer_dtype)
+        if negative_prompt_embeds is not None:
+            if use_interpolate_prompt:
+                negative_prompt_embeds = negative_prompt_embeds[0].unsqueeze(0)
+            negative_prompt_embeds = negative_prompt_embeds.to(transformer_dtype)
+
+        # 4. Prepare image
+        if image is not None:
+            image = self.video_processor.preprocess(image, height=height, width=width)
+            image_latents, fake_image_latents = self.prepare_image_latents(
+                image,
+                latents_mean=latents_mean,
+                latents_std=latents_std,
+                dtype=torch.float32,
+                device=device,
+                generator=generator,
+                latents=image_latents,
+                fake_latents=fake_image_latents,
+            )
+
+        if image_latents is not None and add_noise_to_image_latents:
+            image_noise_sigma = (
+                torch.rand(1, device=device, generator=generator) * (image_noise_sigma_max - image_noise_sigma_min)
+                + image_noise_sigma_min
+            )
+            image_latents = (
+                image_noise_sigma * randn_tensor(image_latents.shape, generator=generator, device=device)
+                + (1 - image_noise_sigma) * image_latents
+            )
+            fake_image_noise_sigma = (
+                torch.rand(1, device=device, generator=generator) * (video_noise_sigma_max - video_noise_sigma_min)
+                + video_noise_sigma_min
+            )
+            fake_image_latents = (
+                fake_image_noise_sigma * randn_tensor(fake_image_latents.shape, generator=generator, device=device)
+                + (1 - fake_image_noise_sigma) * fake_image_latents
+            )
+
+        if video is not None:
+            video = self.video_processor.preprocess_video(video, height=height, width=width)
+            image_latents, video_latents = self.prepare_video_latents(
+                video,
+                latents_mean=latents_mean,
+                latents_std=latents_std,
+                latent_window_size=latent_window_size,
+                dtype=torch.float32,
+                device=device,
+                generator=generator,
+                latents=video_latents,
+            )
+
+        if video_latents is not None and add_noise_to_video_latents:
+            image_noise_sigma = (
+                torch.rand(1, device=device, generator=generator) * (image_noise_sigma_max - image_noise_sigma_min)
+                + image_noise_sigma_min
+            )
+            image_latents = (
+                image_noise_sigma * randn_tensor(image_latents.shape, generator=generator, device=device)
+                + (1 - image_noise_sigma) * image_latents
+            )
+
+            noisy_latents_chunks = []
+            num_latent_chunks = video_latents.shape[2] // latent_window_size
+            for i in range(num_latent_chunks):
+                chunk_start = i * latent_window_size
+                chunk_end = chunk_start + latent_window_size
+                latent_chunk = video_latents[:, :, chunk_start:chunk_end, :, :]
+
+                chunk_frames = latent_chunk.shape[2]
+                frame_sigmas = (
+                    torch.rand(chunk_frames, device=device, generator=generator)
+                    * (video_noise_sigma_max - video_noise_sigma_min)
+                    + video_noise_sigma_min
+                )
+                frame_sigmas = frame_sigmas.view(1, 1, chunk_frames, 1, 1)
+
+                noisy_chunk = (
+                    frame_sigmas * randn_tensor(latent_chunk.shape, generator=generator, device=device)
+                    + (1 - frame_sigmas) * latent_chunk
+                )
+                noisy_latents_chunks.append(noisy_chunk)
+            video_latents = torch.cat(noisy_latents_chunks, dim=2)
+
+        # 5. Prepare latent variables
+        num_channels_latents = self.transformer.config.in_channels
+        window_num_frames = (latent_window_size - 1) * self.vae_scale_factor_temporal + 1
+        num_latent_sections = max(1, (num_frames + window_num_frames - 1) // window_num_frames)
+        history_video = None
+        total_generated_latent_frames = 0
+
+        if not is_keep_x0:
+            history_sizes[-1] = history_sizes[-1] + 1
+        history_latents = torch.zeros(
+            batch_size,
+            num_channels_latents,
+            sum(history_sizes),
+            height // self.vae_scale_factor_spatial,
+            width // self.vae_scale_factor_spatial,
+            device=device,
+            dtype=torch.float32,
+        )
+        if fake_image_latents is not None:
+            history_latents = torch.cat([history_latents, fake_image_latents], dim=2)
+            total_generated_latent_frames += 1
+        if video_latents is not None:
+            history_frames = history_latents.shape[2]
+            video_frames = video_latents.shape[2]
+            if video_frames < history_frames:
+                keep_frames = history_frames - video_frames
+                history_latents = torch.cat([history_latents[:, :, :keep_frames, :, :], video_latents], dim=2)
+            else:
+                history_latents = video_latents
+            total_generated_latent_frames += video_latents.shape[2]
+
+        # 6. Denoising loop
+        if use_interpolate_prompt:
+            if num_latent_sections < max(interpolate_cumulative_list):
+                num_latent_sections = sum(interpolate_cumulative_list)
+                print(f"Update num_latent_sections to: {num_latent_sections}")
+
+        for k in range(num_latent_sections):
+            if use_interpolate_prompt:
+                assert num_latent_sections >= max(interpolate_cumulative_list)
+
+                current_interval_idx = 0
+                for idx, cumulative_val in enumerate(interpolate_cumulative_list):
+                    if k < cumulative_val:
+                        current_interval_idx = idx
+                        break
+
+                if current_interval_idx == 0:
+                    prompt_embeds = all_prompt_embeds[0].unsqueeze(0)
+                else:
+                    interval_start = interpolate_cumulative_list[current_interval_idx - 1]
+                    position_in_interval = k - interval_start
+
+                    if position_in_interval < interpolation_steps:
+                        if interpolate_embeds is None or interpolate_interval_idx != current_interval_idx:
+                            interpolate_embeds = self.interpolate_prompt_embeds(
+                                prompt_embeds_1=all_prompt_embeds[current_interval_idx - 1].unsqueeze(0),
+                                prompt_embeds_2=all_prompt_embeds[current_interval_idx].unsqueeze(0),
+                                interpolation_steps=interpolation_steps,
+                            )
+                            interpolate_interval_idx = current_interval_idx
+
+                        prompt_embeds = interpolate_embeds[position_in_interval]
+                    else:
+                        prompt_embeds = all_prompt_embeds[current_interval_idx].unsqueeze(0)
+            else:
+                prompt_embeds = all_prompt_embeds
+
+            is_first_section = k == 0
+            is_second_section = k == 1
+            if is_keep_x0:
+                if is_first_section:
+                    history_sizes_first_section = [1] + history_sizes.copy()
+                    history_latents_first_section = torch.zeros(
+                        batch_size,
+                        num_channels_latents,
+                        sum(history_sizes_first_section),
+                        height // self.vae_scale_factor_spatial,
+                        width // self.vae_scale_factor_spatial,
+                        device=device,
+                        dtype=torch.float32,
+                    )
+                    if fake_image_latents is not None:
+                        history_latents_first_section = torch.cat(
+                            [history_latents_first_section, fake_image_latents], dim=2
+                        )
+                    if video_latents is not None:
+                        history_frames = history_latents_first_section.shape[2]
+                        video_frames = video_latents.shape[2]
+                        if video_frames < history_frames:
+                            keep_frames = history_frames - video_frames
+                            history_latents_first_section = torch.cat(
+                                [history_latents_first_section[:, :, :keep_frames, :, :], video_latents], dim=2
+                            )
+                        else:
+                            history_latents_first_section = video_latents
+
+                    indices = torch.arange(0, sum([1, *history_sizes, latent_window_size]))
+                    (
+                        indices_prefix,
+                        indices_latents_history_long,
+                        indices_latents_history_mid,
+                        indices_latents_history_1x,
+                        indices_hidden_states,
+                    ) = indices.split([1, *history_sizes, latent_window_size], dim=0)
+                    indices_latents_history_short = torch.cat([indices_prefix, indices_latents_history_1x], dim=0)
+
+                    latents_prefix, latents_history_long, latents_history_mid, latents_history_1x = (
+                        history_latents_first_section[:, :, -sum(history_sizes_first_section) :].split(
+                            history_sizes_first_section, dim=2
+                        )
+                    )
+                    if image_latents is not None:
+                        latents_prefix = image_latents
+                    latents_history_short = torch.cat([latents_prefix, latents_history_1x], dim=2)
+                else:
+                    indices = torch.arange(0, sum([1, *history_sizes, latent_window_size]))
+                    (
+                        indices_prefix,
+                        indices_latents_history_long,
+                        indices_latents_history_mid,
+                        indices_latents_history_1x,
+                        indices_hidden_states,
+                    ) = indices.split([1, *history_sizes, latent_window_size], dim=0)
+                    indices_latents_history_short = torch.cat([indices_prefix, indices_latents_history_1x], dim=0)
+
+                    latents_prefix = image_latents
+                    latents_history_long, latents_history_mid, latents_history_1x = history_latents[
+                        :, :, -sum(history_sizes) :
+                    ].split(history_sizes, dim=2)
+                    latents_history_short = torch.cat([latents_prefix, latents_history_1x], dim=2)
+            else:
+                indices = torch.arange(0, sum([*history_sizes, latent_window_size]))
+                (
+                    indices_latents_history_long,
+                    indices_latents_history_mid,
+                    indices_latents_history_short,
+                    indices_hidden_states,
+                ) = indices.split([*history_sizes, latent_window_size], dim=0)
+                latents_history_long, latents_history_mid, latents_history_short = history_latents[
+                    :, :, -sum(history_sizes) :
+                ].split(history_sizes, dim=2)
+
+            latents = self.prepare_latents(
+                batch_size,
+                num_channels_latents,
+                height,
+                width,
+                window_num_frames,
+                dtype=torch.float32,
+                device=device,
+                generator=generator,
+                latents=None,
+            )
+
+            if not is_enable_stage2:
+                self.scheduler.set_timesteps(num_inference_steps, mu=1, device=device)
+
+                if use_dynamic_shifting:
+                    sigmas = torch.linspace(
+                        0.999, 0.0, steps=num_inference_steps + 1, dtype=torch.float32, device=device
+                    )[:-1]
+                    sigmas = apply_schedule_shift(
+                        sigmas=sigmas,
+                        noise=latents,
+                        base_seq_len=self.scheduler.config.get("base_image_seq_len", 256),
+                        max_seq_len=self.scheduler.config.get("max_image_seq_len", 4096),
+                        base_shift=self.scheduler.config.get("base_shift", 0.5),
+                        max_shift=self.scheduler.config.get("max_shift", 1.15),
+                        time_shift_type=time_shift_type,
+                    )
+                    timesteps = sigmas * 1000.0  # rescale to [0, 1000.0)
+                    timesteps = timesteps.to(device)
+                    sigmas = torch.cat([sigmas, torch.zeros(1, device=sigmas.device)])
+                    self.scheduler.timesteps = timesteps
+                    self.scheduler.sigmas = sigmas
+
+                timesteps = self.scheduler.timesteps
+
+                dmd_sigmas = None
+                dmd_timesteps = None
+                if use_dmd:
+                    dmd_sigmas = self.scheduler.sigmas.to(self.transformer.device)
+                    dmd_timesteps = self.scheduler.timesteps.to(self.transformer.device)
+
+                self._num_timesteps = len(timesteps)
+            else:
+                num_inference_steps = (
+                    sum(stage2_num_inference_steps_list) * 2
+                    if is_amplify_first_chunk and use_dmd and is_first_section
+                    else sum(stage2_num_inference_steps_list)
+                )
+
+            with self.progress_bar(total=num_inference_steps) as progress_bar:
+                if is_enable_stage2:
+                    latents = self.stage2_sample(
+                        latents=latents,
+                        stage2_num_stages=stage2_num_stages,
+                        stage2_num_inference_steps_list=stage2_num_inference_steps_list,
+                        prompt_embeds=prompt_embeds,
+                        negative_prompt_embeds=negative_prompt_embeds,
+                        guidance_scale=guidance_scale,
+                        indices_hidden_states=indices_hidden_states,
+                        indices_latents_history_short=indices_latents_history_short,
+                        indices_latents_history_mid=indices_latents_history_mid,
+                        indices_latents_history_long=indices_latents_history_long,
+                        latents_history_short=latents_history_short,
+                        latents_history_mid=latents_history_mid,
+                        latents_history_long=latents_history_long,
+                        attention_kwargs=attention_kwargs,
+                        device=device,
+                        transformer_dtype=transformer_dtype,
+                        scheduler_type=scheduler_type,
+                        use_dynamic_shifting=use_dynamic_shifting,
+                        time_shift_type=time_shift_type,
+                        generator=generator,
+                        # ------------ CFG Zero ------------
+                        use_cfg_zero_star=use_cfg_zero_star,
+                        use_zero_init=use_zero_init,
+                        zero_steps=zero_steps,
+                        # -------------- DMD --------------
+                        use_dmd=use_dmd,
+                        is_amplify_first_chunk=is_amplify_first_chunk and is_first_section,
+                        # ------------ Callback ------------
+                        callback_on_step_end=callback_on_step_end,
+                        callback_on_step_end_tensor_inputs=callback_on_step_end_tensor_inputs,
+                        progress_bar=progress_bar,
+                    )
+                else:
+                    latents = self.stage1_sample(
+                        latents=latents,
+                        prompt_embeds=prompt_embeds,
+                        negative_prompt_embeds=negative_prompt_embeds,
+                        timesteps=timesteps,
+                        guidance_scale=guidance_scale,
+                        indices_hidden_states=indices_hidden_states,
+                        indices_latents_history_short=indices_latents_history_short,
+                        indices_latents_history_mid=indices_latents_history_mid,
+                        indices_latents_history_long=indices_latents_history_long,
+                        latents_history_short=latents_history_short,
+                        latents_history_mid=latents_history_mid,
+                        latents_history_long=latents_history_long,
+                        attention_kwargs=attention_kwargs,
+                        device=device,
+                        transformer_dtype=transformer_dtype,
+                        generator=generator,
+                        # ------------ CFG Zero ------------
+                        use_cfg_zero_star=use_cfg_zero_star,
+                        use_zero_init=use_zero_init,
+                        zero_steps=zero_steps,
+                        # -------------- DMD --------------
+                        use_dmd=use_dmd,
+                        dmd_sigmas=dmd_sigmas,
+                        dmd_timesteps=dmd_timesteps,
+                        is_amplify_first_chunk=is_amplify_first_chunk and is_first_section,
+                        # ------------ Callback ------------
+                        callback_on_step_end=callback_on_step_end,
+                        callback_on_step_end_tensor_inputs=callback_on_step_end_tensor_inputs,
+                        progress_bar=progress_bar,
+                    )
+
+                if use_kv_cache:
+                    self.transformer.clear_kv_cache()
+
+                if use_adaptive_anti_drifting:
+                    current_mean, current_var = anti_drifting_helper.compute_latent_statistics(latents)
+                    anti_drifting_helper.update_global_statistics(current_mean, current_var)
+                    has_drift = anti_drifting_helper.detect_drift(current_mean, current_var)
+
+                    if has_drift and k < num_latent_sections - 1:
+                        print(
+                            f"Drift detected at chunk {k + 1}/{num_latent_sections}. Applying Frame-Aware Corruption."
+                        )
+                        latents = anti_drifting_helper.apply_frame_aware_corruption(
+                            latents,
+                            corruption_strength=anti_drift_corruption_strength,
+                            generator=generator,
+                        )
+
+                if is_keep_x0 and (
+                    (is_first_section and image_latents is None) or (is_skip_first_section and is_second_section)
+                ):
+                    image_latents = latents[:, :, 0:1, :, :]
+
+                total_generated_latent_frames += latents.shape[2]
+                history_latents = torch.cat([history_latents, latents], dim=2)
+                real_history_latents = history_latents[:, :, -total_generated_latent_frames:]
+                index_slice = (
+                    slice(None),
+                    slice(None),
+                    slice(-latent_window_size, None),
+                )
+
+                if vae_decode_type == "default":
+                    current_latents = real_history_latents[index_slice].to(vae_dtype) / latents_std + latents_mean
+                    current_video = self.vae.decode(current_latents, return_dict=False)[0]
+
+                    if history_video is None:
+                        history_video = current_video
+                    else:
+                        history_video = torch.cat([history_video, current_video], dim=2)
+
+        self._current_timestep = None
+
+        if output_type != "latent":
+            if vae_decode_type == "default_batch":
+                total_latent_frames = real_history_latents.shape[2]
+                batch_size = real_history_latents.shape[0]
+                num_chunks = total_latent_frames // latent_window_size
+
+                chunks = (
+                    real_history_latents.reshape(
+                        batch_size,
+                        -1,
+                        num_chunks,
+                        latent_window_size,
+                        real_history_latents.shape[-2],
+                        real_history_latents.shape[-1],
+                    )
+                    .permute(0, 2, 1, 3, 4, 5)
+                    .reshape(
+                        batch_size * num_chunks,
+                        -1,
+                        latent_window_size,
+                        real_history_latents.shape[-2],
+                        real_history_latents.shape[-1],
+                    )
+                )
+
+                chunks = chunks.to(vae_dtype) / latents_std + latents_mean
+                batch_video = self.vae.decode(chunks, return_dict=False)[0]
+
+                video_frames_per_chunk = batch_video.shape[2]
+                history_video = (
+                    batch_video.reshape(
+                        batch_size,
+                        num_chunks,
+                        -1,
+                        video_frames_per_chunk,
+                        batch_video.shape[-2],
+                        batch_video.shape[-1],
+                    )
+                    .permute(0, 2, 1, 3, 4, 5)
+                    .reshape(
+                        batch_size,
+                        -1,
+                        num_chunks * video_frames_per_chunk,
+                        batch_video.shape[-2],
+                        batch_video.shape[-1],
+                    )
+                )
+
+            generated_frames = history_video.size(2)
+            generated_frames = (
+                generated_frames - 1
+            ) // self.vae_scale_factor_temporal * self.vae_scale_factor_temporal + 1
+            history_video = history_video[:, :, :generated_frames]
+            video = self.video_processor.postprocess_video(history_video, output_type=output_type)
+        else:
+            video = real_history_latents
+
+        # Offload all models
+        self.maybe_free_model_hooks()
+
+        if not return_dict:
+            return (video,)
+
+        return HeliosPipelineOutput(frames=video)

Helios/_DEV/helios/pipelines/pipeline_helios_ode.py

@@ -0,0 +1,1510 @@
+# Copyright 2025 The Helios Team and The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import html
+import math
+from enum import Enum
+from itertools import accumulate
+from typing import Any, Callable, Dict, List, Literal, Optional, Union
+
+import regex as re
+import torch
+import torch.nn.functional as F
+from einops import rearrange
+from transformers import AutoTokenizer, UMT5EncoderModel
+
+from diffusers.callbacks import MultiPipelineCallbacks, PipelineCallback
+from diffusers.image_processor import PipelineImageInput
+from diffusers.loaders import WanLoraLoaderMixin
+from diffusers.models import AutoencoderKLWan
+from diffusers.pipelines.pipeline_utils import DiffusionPipeline
+from diffusers.schedulers import UniPCMultistepScheduler
+from diffusers.utils import is_ftfy_available, is_torch_xla_available, logging, replace_example_docstring
+from diffusers.utils.torch_utils import randn_tensor
+from diffusers.video_processor import VideoProcessor
+
+from ..modules.transformer_helios import HeliosTransformer3DModel
+from ..scheduler.scheduling_helios import HeliosScheduler
+from ..utils.utils_base import AdaptiveAntiDrifting, apply_schedule_shift
+from ..utils.utils_helios_post import add_noise, convert_flow_pred_to_x0
+
+
+if is_torch_xla_available():
+    import torch_xla.core.xla_model as xm
+
+    XLA_AVAILABLE = True
+else:
+    XLA_AVAILABLE = False
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+if is_ftfy_available():
+    import ftfy
+
+
+EXAMPLE_DOC_STRING = """
+    Examples:
+        ```python
+        >>> import torch
+        >>> from diffusers.utils import export_to_video
+        >>> from diffusers import AutoencoderKLWan, HeliosPipeline
+
+        >>> # Available models: BestWishYsh/Helios-Base, BestWishYsh/Helios-Mid, BestWishYsh/Helios-Distilled
+        >>> model_id = "BestWishYsh/Helios-Base"
+        >>> vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", torch_dtype=torch.float32)
+        >>> pipe = HeliosPipeline.from_pretrained(model_id, vae=vae, torch_dtype=torch.bfloat16)
+        >>> pipe.to("cuda")
+
+        >>> prompt = "A cat and a dog baking a cake together in a kitchen. The cat is carefully measuring flour, while the dog is stirring the batter with a wooden spoon. The kitchen is cozy, with sunlight streaming through the window."
+        >>> negative_prompt = "Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards"
+
+        >>> output = pipe(
+        ...     prompt=prompt,
+        ...     negative_prompt=negative_prompt,
+        ...     height=384,
+        ...     width=640,
+        ...     num_frames=132,
+        ...     guidance_scale=5.0,
+        ... ).frames[0]
+        >>> export_to_video(output, "output.mp4", fps=24)
+        ```
+"""
+
+
+@torch.amp.autocast("cuda", dtype=torch.float32)
+def optimized_scale(positive_flat, negative_flat):
+    # Calculate dot production
+    dot_product = torch.sum(positive_flat * negative_flat, dim=1, keepdim=True)
+
+    # Squared norm of uncondition
+    squared_norm = torch.sum(negative_flat**2, dim=1, keepdim=True) + 1e-8
+
+    # st_star = v_cond^T * v_uncond / ||v_uncond||^2
+    st_star = dot_product / squared_norm
+
+    return st_star
+
+
+def basic_clean(text):
+    text = ftfy.fix_text(text)
+    text = html.unescape(html.unescape(text))
+    return text.strip()
+
+
+def whitespace_clean(text):
+    text = re.sub(r"\s+", " ", text)
+    text = text.strip()
+    return text
+
+
+def prompt_clean(text):
+    text = whitespace_clean(basic_clean(text))
+    return text
+
+
+class VAEDecodeType(str, Enum):
+    DEFAULT = "default"
+    DEFAULT_BATCH = "default_batch"
+
+
+class HeliosPipeline(DiffusionPipeline, WanLoraLoaderMixin):
+    r"""
+    Pipeline for text-to-video / image-to-video / video-to-video generation using Helios.
+
+    This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods
+    implemented for all pipelines (downloading, saving, running on a particular device, etc.).
+
+    Args:
+        tokenizer ([`T5Tokenizer`]):
+            Tokenizer from [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer),
+            specifically the [google/umt5-xxl](https://huggingface.co/google/umt5-xxl) variant.
+        text_encoder ([`T5EncoderModel`]):
+            [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), specifically
+            the [google/umt5-xxl](https://huggingface.co/google/umt5-xxl) variant.
+        transformer ([`HeliosTransformer3DModel`]):
+            Conditional Transformer to denoise the input latents.
+        scheduler ([`UniPCMultistepScheduler`]):
+            A scheduler to be used in combination with `transformer` to denoise the encoded image latents.
+        vae ([`AutoencoderKLWan`]):
+            Variational Auto-Encoder (VAE) Model to encode and decode videos to and from latent representations.
+    """
+
+    model_cpu_offload_seq = "text_encoder->transformer->vae"
+    _callback_tensor_inputs = ["latents", "prompt_embeds", "negative_prompt_embeds"]
+    _optional_components = ["transformer"]
+
+    def __init__(
+        self,
+        tokenizer: AutoTokenizer,
+        text_encoder: UMT5EncoderModel,
+        vae: AutoencoderKLWan,
+        scheduler: UniPCMultistepScheduler | HeliosScheduler,
+        transformer: HeliosTransformer3DModel,
+    ):
+        super().__init__()
+
+        self.register_modules(
+            vae=vae,
+            text_encoder=text_encoder,
+            tokenizer=tokenizer,
+            transformer=transformer,
+            scheduler=scheduler,
+        )
+        self.vae_scale_factor_temporal = self.vae.config.scale_factor_temporal if getattr(self, "vae", None) else 4
+        self.vae_scale_factor_spatial = self.vae.config.scale_factor_spatial if getattr(self, "vae", None) else 8
+        self.video_processor = VideoProcessor(vae_scale_factor=self.vae_scale_factor_spatial)
+
+    def _get_t5_prompt_embeds(
+        self,
+        prompt: Union[str, List[str]] = None,
+        num_videos_per_prompt: int = 1,
+        max_sequence_length: int = 226,
+        device: Optional[torch.device] = None,
+        dtype: Optional[torch.dtype] = None,
+    ):
+        device = device or self._execution_device
+        dtype = dtype or self.text_encoder.dtype
+
+        prompt = [prompt] if isinstance(prompt, str) else prompt
+        prompt = [prompt_clean(u) for u in prompt]
+        batch_size = len(prompt)
+
+        text_inputs = self.tokenizer(
+            prompt,
+            padding="max_length",
+            max_length=max_sequence_length,
+            truncation=True,
+            add_special_tokens=True,
+            return_attention_mask=True,
+            return_tensors="pt",
+        )
+        text_input_ids, mask = text_inputs.input_ids, text_inputs.attention_mask
+        seq_lens = mask.gt(0).sum(dim=1).long()
+
+        prompt_embeds = self.text_encoder(text_input_ids.to(device), mask.to(device)).last_hidden_state
+        prompt_embeds = prompt_embeds.to(dtype=dtype, device=device)
+        prompt_embeds = [u[:v] for u, v in zip(prompt_embeds, seq_lens)]
+        prompt_embeds = torch.stack(
+            [torch.cat([u, u.new_zeros(max_sequence_length - u.size(0), u.size(1))]) for u in prompt_embeds], dim=0
+        )
+
+        # duplicate text embeddings for each generation per prompt, using mps friendly method
+        _, seq_len, _ = prompt_embeds.shape
+        prompt_embeds = prompt_embeds.repeat(1, num_videos_per_prompt, 1)
+        prompt_embeds = prompt_embeds.view(batch_size * num_videos_per_prompt, seq_len, -1)
+
+        return prompt_embeds, text_inputs.attention_mask.bool()
+
+    def encode_prompt(
+        self,
+        prompt: Union[str, List[str]],
+        negative_prompt: Optional[Union[str, List[str]]] = None,
+        do_classifier_free_guidance: bool = True,
+        num_videos_per_prompt: int = 1,
+        prompt_embeds: Optional[torch.Tensor] = None,
+        negative_prompt_embeds: Optional[torch.Tensor] = None,
+        max_sequence_length: int = 226,
+        device: Optional[torch.device] = None,
+        dtype: Optional[torch.dtype] = None,
+    ):
+        r"""
+        Encodes the prompt into text encoder hidden states.
+
+        Args:
+            prompt (`str` or `List[str]`, *optional*):
+                prompt to be encoded
+            negative_prompt (`str` or `List[str]`, *optional*):
+                The prompt or prompts not to guide the image generation. If not defined, one has to pass
+                `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is
+                less than `1`).
+            do_classifier_free_guidance (`bool`, *optional*, defaults to `True`):
+                Whether to use classifier free guidance or not.
+            num_videos_per_prompt (`int`, *optional*, defaults to 1):
+                Number of videos that should be generated per prompt. torch device to place the resulting embeddings on
+            prompt_embeds (`torch.Tensor`, *optional*):
+                Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not
+                provided, text embeddings will be generated from `prompt` input argument.
+            negative_prompt_embeds (`torch.Tensor`, *optional*):
+                Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt
+                weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input
+                argument.
+            device: (`torch.device`, *optional*):
+                torch device
+            dtype: (`torch.dtype`, *optional*):
+                torch dtype
+        """
+        device = device or self._execution_device
+
+        prompt = [prompt] if isinstance(prompt, str) else prompt
+        if prompt is not None:
+            batch_size = len(prompt)
+        else:
+            batch_size = prompt_embeds.shape[0]
+
+        if prompt_embeds is None:
+            prompt_embeds, prompt_attention_mask = self._get_t5_prompt_embeds(
+                prompt=prompt,
+                num_videos_per_prompt=num_videos_per_prompt,
+                max_sequence_length=max_sequence_length,
+                device=device,
+                dtype=dtype,
+            )
+
+        negative_prompt_attention_mask = None
+        if do_classifier_free_guidance and negative_prompt_embeds is None:
+            negative_prompt = negative_prompt or ""
+            negative_prompt = batch_size * [negative_prompt] if isinstance(negative_prompt, str) else negative_prompt
+
+            if prompt is not None and type(prompt) is not type(negative_prompt):
+                raise TypeError(
+                    f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
+                    f" {type(prompt)}."
+                )
+            elif batch_size != len(negative_prompt):
+                raise ValueError(
+                    f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
+                    f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
+                    " the batch size of `prompt`."
+                )
+
+            negative_prompt_embeds, negative_prompt_attention_mask = self._get_t5_prompt_embeds(
+                prompt=negative_prompt,
+                num_videos_per_prompt=num_videos_per_prompt,
+                max_sequence_length=max_sequence_length,
+                device=device,
+                dtype=dtype,
+            )
+
+        return prompt_embeds, prompt_attention_mask, negative_prompt_embeds, negative_prompt_attention_mask
+
+    def check_inputs(
+        self,
+        prompt,
+        negative_prompt,
+        height,
+        width,
+        prompt_embeds=None,
+        negative_prompt_embeds=None,
+        callback_on_step_end_tensor_inputs=None,
+    ):
+        if height % 16 != 0 or width % 16 != 0:
+            raise ValueError(f"`height` and `width` have to be divisible by 16 but are {height} and {width}.")
+
+        if callback_on_step_end_tensor_inputs is not None and not all(
+            k in self._callback_tensor_inputs for k in callback_on_step_end_tensor_inputs
+        ):
+            raise ValueError(
+                f"`callback_on_step_end_tensor_inputs` has to be in {self._callback_tensor_inputs}, but found {[k for k in callback_on_step_end_tensor_inputs if k not in self._callback_tensor_inputs]}"
+            )
+
+        if prompt is not None and prompt_embeds is not None:
+            raise ValueError(
+                f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to"
+                " only forward one of the two."
+            )
+        elif negative_prompt is not None and negative_prompt_embeds is not None:
+            raise ValueError(
+                f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`: {negative_prompt_embeds}. Please make sure to"
+                " only forward one of the two."
+            )
+        elif prompt is None and prompt_embeds is None:
+            raise ValueError(
+                "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined."
+            )
+        elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)):
+            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
+        elif negative_prompt is not None and (
+            not isinstance(negative_prompt, str) and not isinstance(negative_prompt, list)
+        ):
+            raise ValueError(f"`negative_prompt` has to be of type `str` or `list` but is {type(negative_prompt)}")
+
+    def prepare_latents(
+        self,
+        batch_size: int,
+        num_channels_latents: int = 16,
+        height: int = 480,
+        width: int = 832,
+        num_frames: int = 81,
+        dtype: Optional[torch.dtype] = None,
+        device: Optional[torch.device] = None,
+        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
+        latents: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        if latents is not None:
+            return latents.to(device=device, dtype=dtype)
+
+        num_latent_frames = (num_frames - 1) // self.vae_scale_factor_temporal + 1
+        shape = (
+            batch_size,
+            num_channels_latents,
+            num_latent_frames,
+            int(height) // self.vae_scale_factor_spatial,
+            int(width) // self.vae_scale_factor_spatial,
+        )
+        if isinstance(generator, list) and len(generator) != batch_size:
+            raise ValueError(
+                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
+                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
+            )
+
+        latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
+        return latents
+
+    def prepare_image_latents(
+        self,
+        image: torch.Tensor,
+        latents_mean: torch.Tensor,
+        latents_std: torch.Tensor,
+        dtype: Optional[torch.dtype] = None,
+        device: Optional[torch.device] = None,
+        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
+        latents: Optional[torch.Tensor] = None,
+        fake_latents: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        device = device or self._execution_device
+        if latents is None:
+            image = image.unsqueeze(2).to(device=device, dtype=self.vae.dtype)
+            latents = self.vae.encode(image).latent_dist.sample(generator=generator)
+            latents = (latents - latents_mean) * latents_std
+        if fake_latents is None:
+            fake_video = image.repeat(1, 1, 33, 1, 1).to(device=device, dtype=self.vae.dtype)
+            fake_latents_full = self.vae.encode(fake_video).latent_dist.sample(generator=generator)
+            fake_latents_full = (fake_latents_full - latents_mean) * latents_std
+            fake_latents = fake_latents_full[:, :, -1:, :, :]
+        return latents.to(device=device, dtype=dtype), fake_latents.to(device=device, dtype=dtype)
+
+    def prepare_video_latents(
+        self,
+        video: torch.Tensor,
+        latents_mean: torch.Tensor,
+        latents_std: torch.Tensor,
+        latent_window_size: int,
+        dtype: Optional[torch.dtype] = None,
+        device: Optional[torch.device] = None,
+        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
+        latents: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        device = device or self._execution_device
+        video = video.to(device=device, dtype=self.vae.dtype)
+        if latents is None:
+            num_frames = video.shape[2]
+            min_frames = (latent_window_size - 1) * 4 + 1
+            num_chunks = num_frames // min_frames
+            if num_chunks == 0:
+                raise ValueError(
+                    f"Video must have at least {min_frames} frames "
+                    f"(got {num_frames} frames). "
+                    f"Required: (latent_window_size - 1) * 4 + 1 = ({latent_window_size} - 1) * 4 + 1 = {min_frames}"
+                )
+            total_valid_frames = num_chunks * min_frames
+            start_frame = num_frames - total_valid_frames
+
+            first_frame = video[:, :, 0:1, :, :]
+            first_frame_latent = self.vae.encode(first_frame).latent_dist.sample(generator=generator)
+            first_frame_latent = (first_frame_latent - latents_mean) * latents_std
+
+            latents_chunks = []
+            for i in range(num_chunks - 1, -1, -1):
+                chunk_start = start_frame + i * min_frames
+                chunk_end = chunk_start + min_frames
+                video_chunk = video[:, :, chunk_start:chunk_end, :, :]
+                chunk_latents = self.vae.encode(video_chunk).latent_dist.sample(generator=generator)
+                chunk_latents = (chunk_latents - latents_mean) * latents_std
+                latents_chunks.insert(0, chunk_latents)
+            latents = torch.cat(latents_chunks, dim=2)
+        return first_frame_latent.to(device=device, dtype=dtype), latents.to(device=device, dtype=dtype)
+
+    def interpolate_prompt_embeds(
+        self,
+        prompt_embeds_1: torch.Tensor,
+        prompt_embeds_2: torch.Tensor,
+        interpolation_steps: int = 4,
+    ):
+        x = torch.lerp(
+            prompt_embeds_1,
+            prompt_embeds_2,
+            torch.linspace(0, 1, steps=interpolation_steps).unsqueeze(1).unsqueeze(2).to(prompt_embeds_1),
+        )
+        interpolated_prompt_embeds = list(x.chunk(interpolation_steps, dim=0))
+        return interpolated_prompt_embeds
+
+    def sample_block_noise(
+        self,
+        batch_size,
+        channel,
+        num_frames,
+        height,
+        width,
+        patch_size: tuple[int, ...] = (1, 2, 2),
+        device: torch.device | None = None,
+        generator: torch.Generator | None = None,
+    ):
+        # NOTE: A generator must be provided to ensure correct and reproducible results.
+        # Creating a default generator here is a fallback only — without a fixed seed,
+        # the output will be non-deterministic and may produce incorrect results in CP context.
+        if generator is None:
+            generator = torch.Generator(device=device)
+        elif isinstance(generator, list):
+            generator = generator[0]
+
+        gamma = self.scheduler.config.gamma
+        _, ph, pw = patch_size
+        block_size = ph * pw
+
+        cov = (
+            torch.eye(block_size, device=device) * (1 + gamma)
+            - torch.ones(block_size, block_size, device=device) * gamma
+        )
+        cov += torch.eye(block_size, device=device) * 1e-8
+        cov = cov.float()  # Upcast to fp32 for numerical stability — cholesky is unreliable in fp16/bf16.
+
+        L = torch.linalg.cholesky(cov)
+        block_number = batch_size * channel * num_frames * (height // ph) * (width // pw)
+        z = torch.randn(block_number, block_size, generator=generator, device=generator.device).to(device=device)
+        noise = z @ L.T
+
+        noise = noise.view(batch_size, channel, num_frames, height // ph, width // pw, ph, pw)
+        noise = noise.permute(0, 1, 2, 3, 5, 4, 6).reshape(batch_size, channel, num_frames, height, width)
+
+        return noise
+
+    def stage1_sample(
+        self,
+        latents: torch.Tensor = None,
+        prompt_embeds: torch.Tensor = None,
+        negative_prompt_embeds: torch.Tensor = None,
+        timesteps: torch.Tensor = None,
+        guidance_scale: Optional[float] = 5.0,
+        indices_hidden_states: torch.Tensor = None,
+        indices_latents_history_short: torch.Tensor = None,
+        indices_latents_history_mid: torch.Tensor = None,
+        indices_latents_history_long: torch.Tensor = None,
+        latents_history_short: torch.Tensor = None,
+        latents_history_mid: torch.Tensor = None,
+        latents_history_long: torch.Tensor = None,
+        attention_kwargs: Optional[dict] = None,
+        device: Optional[torch.device] = None,
+        transformer_dtype: torch.dtype = None,
+        generator: Optional[torch.Generator] = None,
+        # ------------ CFG Zero ------------
+        use_cfg_zero_star: Optional[bool] = False,
+        use_zero_init: Optional[bool] = True,
+        zero_steps: Optional[int] = 1,
+        # -------------- DMD --------------
+        use_dmd: bool = False,
+        dmd_sigmas: torch.Tensor = None,
+        dmd_timesteps: torch.Tensor = None,
+        # ------------ Callback ------------
+        callback_on_step_end: Optional[callable] = None,
+        callback_on_step_end_tensor_inputs: list = None,
+        progress_bar=None,
+    ):
+        batch_size = latents.shape[0]
+
+        for i, t in enumerate(timesteps):
+            is_first_step = i == 0
+
+            if self.interrupt:
+                continue
+
+            self._current_timestep = t
+            timestep = t.expand(latents.shape[0])
+
+            latent_model_input = latents.to(transformer_dtype)
+            with self.transformer.cache_context("cond"):
+                noise_pred = self.transformer(
+                    hidden_states=latent_model_input,
+                    timestep=timestep,
+                    encoder_hidden_states=prompt_embeds,
+                    indices_hidden_states=indices_hidden_states,
+                    indices_latents_history_short=indices_latents_history_short,
+                    indices_latents_history_mid=indices_latents_history_mid,
+                    indices_latents_history_long=indices_latents_history_long,
+                    latents_history_short=latents_history_short.to(transformer_dtype),
+                    latents_history_mid=latents_history_mid.to(transformer_dtype),
+                    latents_history_long=latents_history_long.to(transformer_dtype),
+                    is_first_denoising_step=is_first_step,
+                    attention_kwargs=attention_kwargs,
+                    return_dict=False,
+                )[0]
+
+            if self.do_classifier_free_guidance and not use_dmd:
+                with self.transformer.cache_context("uncond"):
+                    noise_uncond = self.transformer(
+                        hidden_states=latent_model_input,
+                        timestep=timestep,
+                        encoder_hidden_states=negative_prompt_embeds,
+                        indices_hidden_states=indices_hidden_states,
+                        indices_latents_history_short=indices_latents_history_short,
+                        indices_latents_history_mid=indices_latents_history_mid,
+                        indices_latents_history_long=indices_latents_history_long,
+                        latents_history_short=latents_history_short.to(transformer_dtype),
+                        latents_history_mid=latents_history_mid.to(transformer_dtype),
+                        latents_history_long=latents_history_long.to(transformer_dtype),
+                        is_first_denoising_step=is_first_step,
+                        attention_kwargs=attention_kwargs,
+                        return_dict=False,
+                    )[0]
+
+                if use_cfg_zero_star:
+                    noise_pred_text = noise_pred
+                    positive_flat = noise_pred_text.view(batch_size, -1)
+                    negative_flat = noise_uncond.view(batch_size, -1)
+
+                    alpha = optimized_scale(positive_flat, negative_flat)
+                    alpha = alpha.view(batch_size, *([1] * (len(noise_pred_text.shape) - 1)))
+                    alpha = alpha.to(noise_pred_text.dtype)
+
+                    if (i <= zero_steps) and use_zero_init:
+                        noise_pred = noise_pred_text * 0.0
+                    else:
+                        noise_pred = noise_uncond * alpha + guidance_scale * (noise_pred_text - noise_uncond * alpha)
+                else:
+                    noise_pred = noise_uncond + guidance_scale * (noise_pred - noise_uncond)
+
+            if use_dmd:
+                pred_image_or_video = convert_flow_pred_to_x0(
+                    flow_pred=noise_pred,
+                    xt=latent_model_input,
+                    timestep=t * torch.ones(batch_size, dtype=torch.long, device=noise_pred.device),
+                    sigmas=dmd_sigmas,
+                    timesteps=dmd_timesteps,
+                )
+                if i < len(timesteps) - 1:
+                    latents = add_noise(
+                        pred_image_or_video,
+                        randn_tensor(pred_image_or_video.shape, generator=generator, device=device),
+                        timesteps[i + 1] * torch.ones(batch_size, dtype=torch.long, device=noise_pred.device),
+                        sigmas=dmd_sigmas,
+                        timesteps=dmd_timesteps,
+                    )
+                else:
+                    latents = pred_image_or_video
+            else:
+                # compute the previous noisy sample x_t -> x_t-1
+                latents = self.scheduler.step(noise_pred, t, latents, return_dict=False)[0]
+
+            if callback_on_step_end is not None:
+                callback_kwargs = {}
+                for k in callback_on_step_end_tensor_inputs:
+                    callback_kwargs[k] = locals()[k]
+                callback_outputs = callback_on_step_end(self, i, t, callback_kwargs)
+
+                latents = callback_outputs.pop("latents", latents)
+                prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds)
+                negative_prompt_embeds = callback_outputs.pop("negative_prompt_embeds", negative_prompt_embeds)
+
+            progress_bar.update()
+
+            if XLA_AVAILABLE:
+                xm.mark_step()
+
+        return latents
+
+    def stage2_sample(
+        self,
+        is_first_section,
+        latents: torch.Tensor = None,
+        stage2_num_stages: int = None,
+        stage2_num_inference_steps_list: List[int] = None,
+        prompt_embeds: torch.Tensor = None,
+        negative_prompt_embeds: torch.Tensor = None,
+        guidance_scale: Optional[float] = 5.0,
+        indices_hidden_states: torch.Tensor = None,
+        indices_latents_history_short: torch.Tensor = None,
+        indices_latents_history_mid: torch.Tensor = None,
+        indices_latents_history_long: torch.Tensor = None,
+        latents_history_short: torch.Tensor = None,
+        latents_history_mid: torch.Tensor = None,
+        latents_history_long: torch.Tensor = None,
+        attention_kwargs: Optional[dict] = None,
+        device: Optional[torch.device] = None,
+        transformer_dtype: torch.dtype = None,
+        scheduler_type: str = "unipc",  # unipc, euler
+        use_dynamic_shifting: bool = False,
+        time_shift_type: Literal["exponential", "linear"] = "linear",
+        generator: torch.Generator | list[torch.Generator] | None = None,
+        # ------------ CFG Zero ------------
+        use_cfg_zero_star: Optional[bool] = False,
+        use_zero_init: Optional[bool] = True,
+        zero_steps: Optional[int] = 1,
+        # -------------- DMD --------------
+        use_dmd: bool = False,
+        # ------------ Callback ------------
+        callback_on_step_end: Optional[callable] = None,
+        callback_on_step_end_tensor_inputs: list = None,
+        progress_bar=None,
+    ):
+        num_frames, height, width = (
+            latents.shape[-3],
+            latents.shape[-2],
+            latents.shape[-1],
+        )
+        latents = rearrange(latents, "b c t h w -> (b t) c h w")
+        for _ in range(stage2_num_stages - 1):
+            height //= 2
+            width //= 2
+            latents = (
+                F.interpolate(
+                    latents,
+                    size=(height, width),
+                    mode="bilinear",
+                )
+                * 2
+            )
+        latents = rearrange(latents, "(b t) c h w -> b c t h w", t=num_frames)
+
+        batch_size = latents.shape[0]
+        if use_dmd:
+            start_point_list = [latents]
+
+        ode_stages_tensor = []
+
+        for i_s in range(stage2_num_stages):
+            num_steps = stage2_num_inference_steps_list[i_s]
+            ode_stages_tensor.append(
+                {
+                    "latents": None,
+                    "timesteps": None,
+                    "noise_pred": None,
+                }
+            )
+
+        i = 0
+        for i_s in range(stage2_num_stages):
+            if use_dmd:
+                self.scheduler.set_timesteps(stage2_num_inference_steps_list[i_s] + 1, i_s, device=device)
+                self.scheduler.timesteps = self.scheduler.timesteps[:-1]
+                self.scheduler.sigmas = torch.cat([self.scheduler.sigmas[:-2], self.scheduler.sigmas[-1:]])
+            else:
+                self.scheduler.set_timesteps(stage2_num_inference_steps_list[i_s], i_s, device=device)
+
+            if i_s > 0:
+                height *= 2
+                width *= 2
+                num_frames = latents.shape[2]
+                latents = rearrange(latents, "b c t h w -> (b t) c h w")
+                latents = F.interpolate(latents, size=(height, width), mode="nearest")
+                latents = rearrange(latents, "(b t) c h w -> b c t h w", t=num_frames)
+                # Fix the stage
+                ori_sigma = 1 - self.scheduler.ori_start_sigmas[i_s]  # the original coeff of signal
+                gamma = self.scheduler.config.gamma
+                alpha = 1 / (math.sqrt(1 + (1 / gamma)) * (1 - ori_sigma) + ori_sigma)
+                beta = alpha * (1 - ori_sigma) / math.sqrt(gamma)
+
+                batch_size, channel, num_frames, height, width = latents.shape
+                noise = self.sample_block_noise(
+                    batch_size,
+                    channel,
+                    num_frames,
+                    height,
+                    width,
+                    self.transformer.config.patch_size,
+                    device,
+                    generator,
+                )
+                noise = noise.to(device=device, dtype=transformer_dtype)
+                latents = alpha * latents + beta * noise  # To fix the block artifact
+
+                if use_dmd:
+                    start_point_list.append(latents)
+
+            if is_first_section:
+                if i_s == 0:
+                    target_timesteps = [999.0000, 935.1279, 871.2559, 807.3838]
+                elif i_s == 1:
+                    target_timesteps = [743.2560, 653.9349, 564.6138, 475.2927]
+                elif i_s == 2:
+                    target_timesteps = [385.6140, 289.5564, 193.4988, 97.4412]
+            else:
+                if i_s == 0:
+                    target_timesteps = [999.0000, 871.2559]
+                elif i_s == 1:
+                    target_timesteps = [743.2560, 564.6138]
+                elif i_s == 2:
+                    target_timesteps = [385.6140, 193.4988]
+
+            current_timesteps = self.scheduler.timesteps
+            target_tensor = torch.tensor(target_timesteps, device=device, dtype=current_timesteps.dtype)
+
+            mask = torch.all(torch.abs(current_timesteps.unsqueeze(0) - target_tensor.unsqueeze(1)) >= 1e-4, dim=1)
+            new_timesteps = target_tensor[mask]
+            if len(new_timesteps) > 0:
+                timestep_id = torch.argmin(
+                    (
+                        new_timesteps.unsqueeze(1)
+                        - self.scheduler.timesteps_per_stage[i_s].unsqueeze(0).to(new_timesteps.device)
+                    ).abs(),
+                    dim=1,
+                )
+                new_sigmas = self.scheduler.sigmas_per_stage[i_s].to(new_timesteps.device)[timestep_id]
+
+                merged_timesteps = torch.cat([current_timesteps, new_timesteps])
+                merged_sigmas = torch.cat([self.scheduler.sigmas[:-1], new_sigmas])
+
+                sorted_indices = torch.argsort(merged_timesteps, descending=True)
+                self.scheduler.timesteps = merged_timesteps[sorted_indices]
+                self.scheduler.sigmas = torch.cat([merged_sigmas[sorted_indices], self.scheduler.sigmas[-1:]])
+
+            if use_dynamic_shifting:
+                temp_sigmas = apply_schedule_shift(
+                    self.scheduler.sigmas,
+                    latents,
+                    base_seq_len=self.scheduler.config.get("base_image_seq_len", 256),
+                    max_seq_len=self.scheduler.config.get("max_image_seq_len", 4096),
+                    base_shift=self.scheduler.config.get("base_shift", 0.5),
+                    max_shift=self.scheduler.config.get("max_shift", 1.15),
+                    time_shift_type=time_shift_type,
+                )
+                temp_timesteps = self.scheduler.timesteps_per_stage[i_s].min() + temp_sigmas[:-1] * (
+                    self.scheduler.timesteps_per_stage[i_s].max() - self.scheduler.timesteps_per_stage[i_s].min()
+                )
+
+                self.scheduler.sigmas = temp_sigmas
+                self.scheduler.timesteps = temp_timesteps
+
+            timesteps = self.scheduler.timesteps
+
+            num_steps = len(timesteps)
+            ode_stages_tensor[i_s]["timesteps"] = torch.zeros(num_steps, dtype=torch.float32, device="cpu")
+
+            for idx, t in enumerate(timesteps):
+                if idx == 0:
+                    batch_size, c, t_dim, h, w = latents.shape
+                    num_steps = len(timesteps)
+
+                    ode_stages_tensor[i_s]["latents"] = torch.zeros(
+                        num_steps + 1, batch_size, c, t_dim, h, w, dtype=torch.float32, device="cpu"
+                    )
+                    ode_stages_tensor[i_s]["noise_pred"] = torch.zeros(
+                        num_steps, batch_size, c, t_dim, h, w, dtype=torch.float32, device="cpu"
+                    )
+
+                is_first_step = i_s == 0 and idx == 0
+
+                timestep = t.expand(latents.shape[0]).to(torch.int64)
+
+                ode_stages_tensor[i_s]["latents"][idx] = latents.detach().cpu()
+                ode_stages_tensor[i_s]["timesteps"][idx] = t.item()
+
+                with self.transformer.cache_context("cond"):
+                    noise_pred = self.transformer(
+                        hidden_states=latents.to(transformer_dtype),
+                        timestep=timestep,
+                        encoder_hidden_states=prompt_embeds,
+                        attention_kwargs=attention_kwargs,
+                        return_dict=False,
+                        indices_hidden_states=indices_hidden_states,
+                        indices_latents_history_short=indices_latents_history_short,
+                        indices_latents_history_mid=indices_latents_history_mid,
+                        indices_latents_history_long=indices_latents_history_long,
+                        latents_history_short=latents_history_short.to(transformer_dtype),
+                        latents_history_mid=latents_history_mid.to(transformer_dtype),
+                        latents_history_long=latents_history_long.to(transformer_dtype),
+                        is_first_denoising_step=is_first_step,
+                    )[0]
+
+                if self.do_classifier_free_guidance:
+                    with self.transformer.cache_context("cond_uncond"):
+                        noise_uncond = self.transformer(
+                            hidden_states=latents.to(transformer_dtype),
+                            timestep=timestep,
+                            encoder_hidden_states=negative_prompt_embeds,
+                            attention_kwargs=attention_kwargs,
+                            return_dict=False,
+                            indices_hidden_states=indices_hidden_states,
+                            indices_latents_history_short=indices_latents_history_short,
+                            indices_latents_history_mid=indices_latents_history_mid,
+                            indices_latents_history_long=indices_latents_history_long,
+                            latents_history_short=latents_history_short.to(transformer_dtype),
+                            latents_history_mid=latents_history_mid.to(transformer_dtype),
+                            latents_history_long=latents_history_long.to(transformer_dtype),
+                            is_first_denoising_step=is_first_step,
+                        )[0]
+
+                    if use_cfg_zero_star:
+                        noise_pred_text = noise_pred
+                        positive_flat = noise_pred_text.view(batch_size, -1)
+                        negative_flat = noise_uncond.view(batch_size, -1)
+
+                        alpha = optimized_scale(positive_flat, negative_flat)
+                        alpha = alpha.view(batch_size, *([1] * (len(noise_pred_text.shape) - 1)))
+                        alpha = alpha.to(noise_pred_text.dtype)
+
+                        if (i_s == 0 and idx <= zero_steps) and use_zero_init:
+                            noise_pred = noise_pred_text * 0.0
+                        else:
+                            noise_pred = noise_uncond * alpha + guidance_scale * (
+                                noise_pred_text - noise_uncond * alpha
+                            )
+                    else:
+                        noise_pred = noise_uncond + guidance_scale * (noise_pred - noise_uncond)
+
+                if use_dmd:
+                    pred_image_or_video = convert_flow_pred_to_x0(
+                        flow_pred=noise_pred,
+                        xt=latents,
+                        timestep=timestep,
+                        sigmas=self.scheduler.sigmas,
+                        timesteps=self.scheduler.timesteps,
+                    )
+                    if idx < len(timesteps) - 1:
+                        latents = add_noise(
+                            pred_image_or_video,
+                            start_point_list[i_s],
+                            timesteps[idx + 1] * torch.ones(batch_size, dtype=torch.long, device=noise_pred.device),
+                            sigmas=self.scheduler.sigmas,
+                            timesteps=self.scheduler.timesteps,
+                        )
+                    else:
+                        latents = pred_image_or_video
+                else:
+                    if scheduler_type == "unipc":
+                        latents = self.scheduler.step_unipc(noise_pred.float(), t, latents, return_dict=False)[0]
+                    else:
+                        latents = self.scheduler.step(noise_pred.float(), t, latents, return_dict=False)[0]
+
+                ode_stages_tensor[i_s]["noise_pred"][idx] = noise_pred.detach().cpu()
+
+                if callback_on_step_end is not None:
+                    callback_kwargs = {}
+                    for k in callback_on_step_end_tensor_inputs:
+                        callback_kwargs[k] = locals()[k]
+                    callback_outputs = callback_on_step_end(self, i, t, callback_kwargs)
+
+                    latents = callback_outputs.pop("latents", latents)
+                    prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds)
+                    negative_prompt_embeds = callback_outputs.pop("negative_prompt_embeds", negative_prompt_embeds)
+
+                progress_bar.update()
+
+                if XLA_AVAILABLE:
+                    xm.mark_step()
+
+                i += 1
+
+            ode_stages_tensor[i_s]["latents"][num_steps] = latents.detach().cpu()
+
+        return latents, ode_stages_tensor
+
+    @property
+    def guidance_scale(self):
+        return self._guidance_scale
+
+    @property
+    def do_classifier_free_guidance(self):
+        return self._guidance_scale > 1.0
+
+    @property
+    def num_timesteps(self):
+        return self._num_timesteps
+
+    @property
+    def current_timestep(self):
+        return self._current_timestep
+
+    @property
+    def interrupt(self):
+        return self._interrupt
+
+    @property
+    def attention_kwargs(self):
+        return self._attention_kwargs
+
+    @torch.no_grad()
+    @replace_example_docstring(EXAMPLE_DOC_STRING)
+    def __call__(
+        self,
+        prompt: Union[str, List[str]] = None,
+        negative_prompt: Union[str, List[str]] = None,
+        height: int = 384,
+        width: int = 640,
+        num_frames: int = 73,
+        num_inference_steps: int = 50,
+        guidance_scale: float = 5.0,
+        num_videos_per_prompt: Optional[int] = 1,
+        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
+        latents: Optional[torch.Tensor] = None,
+        prompt_embeds: Optional[torch.Tensor] = None,
+        negative_prompt_embeds: Optional[torch.Tensor] = None,
+        output_type: Optional[str] = "np",
+        return_dict: bool = True,
+        attention_kwargs: Optional[Dict[str, Any]] = None,
+        callback_on_step_end: Optional[
+            Union[Callable[[int, int, Dict], None], PipelineCallback, MultiPipelineCallbacks]
+        ] = None,
+        callback_on_step_end_tensor_inputs: List[str] = ["latents"],
+        max_sequence_length: int = 512,
+        # ------------ I2V ------------
+        image: Optional[PipelineImageInput] = None,
+        image_latents: Optional[torch.Tensor] = None,
+        fake_image_latents: Optional[torch.Tensor] = None,
+        add_noise_to_image_latents: bool = True,
+        image_noise_sigma_min: float = 0.111,
+        image_noise_sigma_max: float = 0.135,
+        # ------------ V2V ------------
+        video: Optional[PipelineImageInput] = None,
+        video_latents: Optional[torch.Tensor] = None,
+        add_noise_to_video_latents: bool = True,
+        video_noise_sigma_min: float = 0.111,
+        video_noise_sigma_max: float = 0.135,
+        # ------------ Interactive ------------
+        use_interpolate_prompt: bool = False,
+        interpolate_time_list: list = [7, 7, 7],
+        interpolation_steps: int = 3,
+        # ------------ Stage 1 ------------
+        history_sizes: list = [16, 2, 1],
+        latent_window_size: int = 9,
+        use_dynamic_shifting: bool = False,
+        time_shift_type: Literal["exponential", "linear"] = "linear",
+        is_keep_x0: bool = True,
+        # ------------ Stage 2 ------------
+        is_enable_stage2: bool = False,
+        stage2_num_stages: int = 3,
+        stage2_num_inference_steps_list: list = [10, 10, 10],
+        scheduler_type: str = "unipc",  # unipc, euler
+        # ------------ CFG Zero ------------
+        use_cfg_zero_star: Optional[bool] = False,
+        use_zero_init: Optional[bool] = True,
+        zero_steps: Optional[int] = 1,
+        # ------------ DMD ------------
+        use_dmd: bool = False,
+        is_skip_first_section: bool = False,
+        # ------------ Adaptive Anti-Drifting ------------
+        use_adaptive_anti_drifting: bool = False,
+        anti_drift_rho_mu: float = 0.9,
+        anti_drift_rho_sigma: float = 0.9,
+        anti_drift_delta_mu: float = 0.15,
+        anti_drift_delta_sigma: float = 0.15,
+        anti_drift_corruption_strength: float = 0.1,
+        # ------------ other ------------
+        use_kv_cache: bool = False,
+        vae_decode_type: VAEDecodeType = "default",  # "default", "default_batch"
+    ):
+        r"""
+        The call function to the pipeline for generation.
+
+        Args:
+            prompt (`str` or `List[str]`, *optional*):
+                The prompt or prompts to guide the image generation. If not defined, pass `prompt_embeds` instead.
+            negative_prompt (`str` or `List[str]`, *optional*):
+                The prompt or prompts to avoid during image generation. If not defined, pass `negative_prompt_embeds`
+                instead. Ignored when not using guidance (`guidance_scale` < `1`).
+            height (`int`, defaults to `480`):
+                The height in pixels of the generated image.
+            width (`int`, defaults to `832`):
+                The width in pixels of the generated image.
+            num_frames (`int`, defaults to `81`):
+                The number of frames in the generated video.
+            num_inference_steps (`int`, defaults to `50`):
+                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
+                expense of slower inference.
+            guidance_scale (`float`, defaults to `5.0`):
+                Guidance scale as defined in [Classifier-Free Diffusion
+                Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` is defined as `w` of equation 2.
+                of [Imagen Paper](https://huggingface.co/papers/2205.11487). Guidance scale is enabled by setting
+                `guidance_scale > 1`. Higher guidance scale encourages to generate images that are closely linked to
+                the text `prompt`, usually at the expense of lower image quality.
+            num_videos_per_prompt (`int`, *optional*, defaults to 1):
+                The number of images to generate per prompt.
+            generator (`torch.Generator` or `List[torch.Generator]`, *optional*):
+                A [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make
+                generation deterministic.
+            latents (`torch.Tensor`, *optional*):
+                Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for image
+                generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
+                tensor is generated by sampling using the supplied random `generator`.
+            prompt_embeds (`torch.Tensor`, *optional*):
+                Pre-generated text embeddings. Can be used to easily tweak text inputs (prompt weighting). If not
+                provided, text embeddings are generated from the `prompt` input argument.
+            output_type (`str`, *optional*, defaults to `"np"`):
+                The output format of the generated image. Choose between `PIL.Image` or `np.array`.
+            return_dict (`bool`, *optional*, defaults to `True`):
+                Whether or not to return a [`HeliosPipelineOutput`] instead of a plain tuple.
+            attention_kwargs (`dict`, *optional*):
+                A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under
+                `self.processor` in
+                [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
+            callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *optional*):
+                A function or a subclass of `PipelineCallback` or `MultiPipelineCallbacks` that is called at the end of
+                each denoising step during the inference. with the following arguments: `callback_on_step_end(self:
+                DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` will include a
+                list of all tensors as specified by `callback_on_step_end_tensor_inputs`.
+            callback_on_step_end_tensor_inputs (`List`, *optional*):
+                The list of tensor inputs for the `callback_on_step_end` function. The tensors specified in the list
+                will be passed as `callback_kwargs` argument. You will only be able to include variables listed in the
+                `._callback_tensor_inputs` attribute of your pipeline class.
+            max_sequence_length (`int`, defaults to `512`):
+                The maximum sequence length of the text encoder. If the prompt is longer than this, it will be
+                truncated. If the prompt is shorter, it will be padded to this length.
+
+        Examples:
+
+        Returns:
+            [`~HeliosPipelineOutput`] or `tuple`:
+                If `return_dict` is `True`, [`HeliosPipelineOutput`] is returned, otherwise a `tuple` is returned where
+                the first element is a list with the generated images and the second element is a list of `bool`s
+                indicating whether the corresponding generated image contains "not-safe-for-work" (nsfw) content.
+        """
+
+        if image is not None and video is not None:
+            raise ValueError("image and video cannot be provided simultaneously")
+
+        if use_kv_cache:
+            self.transformer.enable_kv_cache()
+
+        if use_interpolate_prompt:
+            assert num_videos_per_prompt == 1, f"num_videos_per_prompt must be 1, got {num_videos_per_prompt}"
+            assert isinstance(prompt, list), "prompt must be a list"
+            assert len(prompt) == len(interpolate_time_list), (
+                f"Length mismatch: {len(prompt)} vs {len(interpolate_time_list)}"
+            )
+            assert min(interpolate_time_list) > interpolation_steps, (
+                f"Minimum value {min(interpolate_time_list)} must be greater than {interpolation_steps}"
+            )
+            interpolate_interval_idx = None
+            interpolate_embeds = None
+            interpolate_cumulative_list = list(accumulate(interpolate_time_list))
+
+        anti_drifting_helper = None
+        if use_adaptive_anti_drifting:
+            anti_drifting_helper = AdaptiveAntiDrifting(
+                rho_mu=anti_drift_rho_mu,
+                rho_sigma=anti_drift_rho_sigma,
+                delta_mu=anti_drift_delta_mu,
+                delta_sigma=anti_drift_delta_sigma,
+                device=self._execution_device,
+                dtype=torch.float32,
+            )
+
+        history_sizes = sorted(history_sizes, reverse=True)  # From big to small
+
+        latents_mean = (
+            torch.tensor(self.vae.config.latents_mean)
+            .view(1, self.vae.config.z_dim, 1, 1, 1)
+            .to(self.vae.device, self.vae.dtype)
+        )
+        latents_std = 1.0 / torch.tensor(self.vae.config.latents_std).view(1, self.vae.config.z_dim, 1, 1, 1).to(
+            self.vae.device, self.vae.dtype
+        )
+
+        if isinstance(callback_on_step_end, (PipelineCallback, MultiPipelineCallbacks)):
+            callback_on_step_end_tensor_inputs = callback_on_step_end.tensor_inputs
+
+        # 1. Check inputs. Raise error if not correct
+        self.check_inputs(
+            prompt,
+            negative_prompt,
+            height,
+            width,
+            prompt_embeds,
+            negative_prompt_embeds,
+            callback_on_step_end_tensor_inputs,
+        )
+
+        num_frames = max(num_frames, 1)
+
+        self._guidance_scale = guidance_scale
+        self._attention_kwargs = attention_kwargs
+        self._current_timestep = None
+        self._interrupt = False
+
+        device = self._execution_device
+
+        # 2. Define call parameters
+        if use_interpolate_prompt or (prompt is not None and isinstance(prompt, str)):
+            batch_size = 1
+        elif prompt is not None and isinstance(prompt, list):
+            batch_size = len(prompt)
+        else:
+            batch_size = prompt_embeds.shape[0]
+
+        # 3. Encode input prompt
+        all_prompt_embeds, prompt_attention_mask, negative_prompt_embeds, negative_prompt_attention_mask = (
+            self.encode_prompt(
+                prompt=prompt,
+                negative_prompt=negative_prompt,
+                do_classifier_free_guidance=self.do_classifier_free_guidance,
+                num_videos_per_prompt=num_videos_per_prompt,
+                prompt_embeds=prompt_embeds,
+                negative_prompt_embeds=negative_prompt_embeds,
+                max_sequence_length=max_sequence_length,
+                device=device,
+            )
+        )
+
+        transformer_dtype = self.transformer.dtype
+        all_prompt_embeds = all_prompt_embeds.to(transformer_dtype)
+        if negative_prompt_embeds is not None:
+            if use_interpolate_prompt:
+                negative_prompt_embeds = negative_prompt_embeds[0].unsqueeze(0)
+            negative_prompt_embeds = negative_prompt_embeds.to(transformer_dtype)
+
+        # 4. Prepare image
+        if image is not None:
+            image = self.video_processor.preprocess(image, height=height, width=width)
+            image_latents, fake_image_latents = self.prepare_image_latents(
+                image,
+                latents_mean=latents_mean,
+                latents_std=latents_std,
+                dtype=torch.float32,
+                device=device,
+                generator=generator,
+                latents=image_latents,
+                fake_latents=fake_image_latents,
+            )
+
+        if image_latents is not None and add_noise_to_image_latents:
+            image_noise_sigma = (
+                torch.rand(1, device=device, generator=generator) * (image_noise_sigma_max - image_noise_sigma_min)
+                + image_noise_sigma_min
+            )
+            image_latents = (
+                image_noise_sigma * randn_tensor(image_latents.shape, generator=generator, device=device)
+                + (1 - image_noise_sigma) * image_latents
+            )
+            fake_image_noise_sigma = (
+                torch.rand(1, device=device, generator=generator) * (video_noise_sigma_max - video_noise_sigma_min)
+                + video_noise_sigma_min
+            )
+            fake_image_latents = (
+                fake_image_noise_sigma * randn_tensor(fake_image_latents.shape, generator=generator, device=device)
+                + (1 - fake_image_noise_sigma) * fake_image_latents
+            )
+
+        if video is not None:
+            video = self.video_processor.preprocess_video(video, height=height, width=width)
+            image_latents, video_latents = self.prepare_video_latents(
+                video,
+                latents_mean=latents_mean,
+                latents_std=latents_std,
+                latent_window_size=latent_window_size,
+                dtype=torch.float32,
+                device=device,
+                generator=generator,
+                latents=video_latents,
+            )
+
+        if video_latents is not None and add_noise_to_video_latents:
+            image_noise_sigma = (
+                torch.rand(1, device=device, generator=generator) * (image_noise_sigma_max - image_noise_sigma_min)
+                + image_noise_sigma_min
+            )
+            image_latents = (
+                image_noise_sigma * randn_tensor(image_latents.shape, generator=generator, device=device)
+                + (1 - image_noise_sigma) * image_latents
+            )
+
+            noisy_latents_chunks = []
+            num_latent_chunks = video_latents.shape[2] // latent_window_size
+            for i in range(num_latent_chunks):
+                chunk_start = i * latent_window_size
+                chunk_end = chunk_start + latent_window_size
+                latent_chunk = video_latents[:, :, chunk_start:chunk_end, :, :]
+
+                chunk_frames = latent_chunk.shape[2]
+                frame_sigmas = (
+                    torch.rand(chunk_frames, device=device, generator=generator)
+                    * (video_noise_sigma_max - video_noise_sigma_min)
+                    + video_noise_sigma_min
+                )
+                frame_sigmas = frame_sigmas.view(1, 1, chunk_frames, 1, 1)
+
+                noisy_chunk = (
+                    frame_sigmas * randn_tensor(latent_chunk.shape, generator=generator, device=device)
+                    + (1 - frame_sigmas) * latent_chunk
+                )
+                noisy_latents_chunks.append(noisy_chunk)
+            video_latents = torch.cat(noisy_latents_chunks, dim=2)
+
+        # 5. Prepare latent variables
+        num_channels_latents = self.transformer.config.in_channels
+        window_num_frames = (latent_window_size - 1) * self.vae_scale_factor_temporal + 1
+        num_latent_sections = max(1, (num_frames + window_num_frames - 1) // window_num_frames)
+        total_generated_latent_frames = 0
+
+        if not is_keep_x0:
+            history_sizes[-1] = history_sizes[-1] + 1
+        history_latents = torch.zeros(
+            batch_size,
+            num_channels_latents,
+            sum(history_sizes),
+            height // self.vae_scale_factor_spatial,
+            width // self.vae_scale_factor_spatial,
+            device=device,
+            dtype=torch.float32,
+        )
+        if fake_image_latents is not None:
+            history_latents = torch.cat([history_latents, fake_image_latents], dim=2)
+            total_generated_latent_frames += 1
+        if video_latents is not None:
+            history_frames = history_latents.shape[2]
+            video_frames = video_latents.shape[2]
+            if video_frames < history_frames:
+                keep_frames = history_frames - video_frames
+                history_latents = torch.cat([history_latents[:, :, :keep_frames, :, :], video_latents], dim=2)
+            else:
+                history_latents = video_latents
+            total_generated_latent_frames += video_latents.shape[2]
+
+        # 6. Denoising loop
+        all_sections_ode = []
+        for k in range(num_latent_sections):
+            if use_interpolate_prompt:
+                assert num_latent_sections >= max(interpolate_cumulative_list)
+
+                current_interval_idx = 0
+                for idx, cumulative_val in enumerate(interpolate_cumulative_list):
+                    if k < cumulative_val:
+                        current_interval_idx = idx
+                        break
+
+                if current_interval_idx == 0:
+                    prompt_embeds = all_prompt_embeds[0].unsqueeze(0)
+                else:
+                    interval_start = interpolate_cumulative_list[current_interval_idx - 1]
+                    position_in_interval = k - interval_start
+
+                    if position_in_interval < interpolation_steps:
+                        if interpolate_embeds is None or interpolate_interval_idx != current_interval_idx:
+                            interpolate_embeds = self.interpolate_prompt_embeds(
+                                prompt_embeds_1=all_prompt_embeds[current_interval_idx - 1].unsqueeze(0),
+                                prompt_embeds_2=all_prompt_embeds[current_interval_idx].unsqueeze(0),
+                                interpolation_steps=interpolation_steps,
+                            )
+                            interpolate_interval_idx = current_interval_idx
+
+                        prompt_embeds = interpolate_embeds[position_in_interval]
+                    else:
+                        prompt_embeds = all_prompt_embeds[current_interval_idx].unsqueeze(0)
+            else:
+                prompt_embeds = all_prompt_embeds
+
+            is_first_section = k == 0
+            is_second_section = k == 1
+            if is_keep_x0:
+                if is_first_section:
+                    history_sizes_first_section = [1] + history_sizes.copy()
+                    history_latents_first_section = torch.zeros(
+                        batch_size,
+                        num_channels_latents,
+                        sum(history_sizes_first_section),
+                        height // self.vae_scale_factor_spatial,
+                        width // self.vae_scale_factor_spatial,
+                        device=device,
+                        dtype=torch.float32,
+                    )
+                    if fake_image_latents is not None:
+                        history_latents_first_section = torch.cat(
+                            [history_latents_first_section, fake_image_latents], dim=2
+                        )
+                    if video_latents is not None:
+                        history_frames = history_latents_first_section.shape[2]
+                        video_frames = video_latents.shape[2]
+                        if video_frames < history_frames:
+                            keep_frames = history_frames - video_frames
+                            history_latents_first_section = torch.cat(
+                                [history_latents_first_section[:, :, :keep_frames, :, :], video_latents], dim=2
+                            )
+                        else:
+                            history_latents_first_section = video_latents
+
+                    indices = torch.arange(0, sum([1, *history_sizes, latent_window_size]))
+                    (
+                        indices_prefix,
+                        indices_latents_history_long,
+                        indices_latents_history_mid,
+                        indices_latents_history_1x,
+                        indices_hidden_states,
+                    ) = indices.split([1, *history_sizes, latent_window_size], dim=0)
+                    indices_latents_history_short = torch.cat([indices_prefix, indices_latents_history_1x], dim=0)
+
+                    latents_prefix, latents_history_long, latents_history_mid, latents_history_1x = (
+                        history_latents_first_section[:, :, -sum(history_sizes_first_section) :].split(
+                            history_sizes_first_section, dim=2
+                        )
+                    )
+                    if image_latents is not None:
+                        latents_prefix = image_latents
+                    latents_history_short = torch.cat([latents_prefix, latents_history_1x], dim=2)
+                else:
+                    indices = torch.arange(0, sum([1, *history_sizes, latent_window_size]))
+                    (
+                        indices_prefix,
+                        indices_latents_history_long,
+                        indices_latents_history_mid,
+                        indices_latents_history_1x,
+                        indices_hidden_states,
+                    ) = indices.split([1, *history_sizes, latent_window_size], dim=0)
+                    indices_latents_history_short = torch.cat([indices_prefix, indices_latents_history_1x], dim=0)
+
+                    latents_prefix = image_latents
+                    latents_history_long, latents_history_mid, latents_history_1x = history_latents[
+                        :, :, -sum(history_sizes) :
+                    ].split(history_sizes, dim=2)
+                    latents_history_short = torch.cat([latents_prefix, latents_history_1x], dim=2)
+            else:
+                indices = torch.arange(0, sum([*history_sizes, latent_window_size]))
+                (
+                    indices_latents_history_long,
+                    indices_latents_history_mid,
+                    indices_latents_history_short,
+                    indices_hidden_states,
+                ) = indices.split([*history_sizes, latent_window_size], dim=0)
+                latents_history_long, latents_history_mid, latents_history_short = history_latents[
+                    :, :, -sum(history_sizes) :
+                ].split(history_sizes, dim=2)
+
+            latents = self.prepare_latents(
+                batch_size,
+                num_channels_latents,
+                height,
+                width,
+                window_num_frames,
+                dtype=torch.float32,
+                device=device,
+                generator=generator,
+                latents=None,
+            )
+
+            if not is_enable_stage2:
+                self.scheduler.set_timesteps(num_inference_steps, device=device)
+
+                if use_dynamic_shifting:
+                    sigmas = torch.linspace(
+                        0.999, 0.0, steps=num_inference_steps + 1, dtype=torch.float32, device=device
+                    )[:-1]
+                    sigmas = apply_schedule_shift(
+                        sigmas=sigmas,
+                        noise=latents,
+                        base_seq_len=self.scheduler.config.get("base_image_seq_len", 256),
+                        max_seq_len=self.scheduler.config.get("max_image_seq_len", 4096),
+                        base_shift=self.scheduler.config.get("base_shift", 0.5),
+                        max_shift=self.scheduler.config.get("max_shift", 1.15),
+                        time_shift_type=time_shift_type,
+                    )
+                    timesteps = sigmas * 1000.0  # rescale to [0, 1000.0)
+                    timesteps = timesteps.to(device)
+                    sigmas = torch.cat([sigmas, torch.zeros(1, device=sigmas.device)])
+                    self.scheduler.timesteps = timesteps
+                    self.scheduler.sigmas = sigmas
+
+                timesteps = self.scheduler.timesteps
+
+                dmd_sigmas = None
+                dmd_timesteps = None
+                if use_dmd:
+                    dmd_sigmas = self.scheduler.sigmas.to(self.transformer.device)
+                    dmd_timesteps = self.scheduler.timesteps.to(self.transformer.device)
+
+                self._num_timesteps = len(timesteps)
+            else:
+                num_inference_steps = sum(stage2_num_inference_steps_list)
+
+            with self.progress_bar(total=num_inference_steps) as progress_bar:
+                if is_enable_stage2:
+                    latents, ode_stages_tensor = self.stage2_sample(
+                        is_first_section=is_first_section,
+                        latents=latents,
+                        stage2_num_stages=stage2_num_stages,
+                        stage2_num_inference_steps_list=stage2_num_inference_steps_list,
+                        prompt_embeds=prompt_embeds,
+                        negative_prompt_embeds=negative_prompt_embeds,
+                        guidance_scale=guidance_scale,
+                        indices_hidden_states=indices_hidden_states,
+                        indices_latents_history_short=indices_latents_history_short,
+                        indices_latents_history_mid=indices_latents_history_mid,
+                        indices_latents_history_long=indices_latents_history_long,
+                        latents_history_short=latents_history_short,
+                        latents_history_mid=latents_history_mid,
+                        latents_history_long=latents_history_long,
+                        attention_kwargs=attention_kwargs,
+                        device=device,
+                        transformer_dtype=transformer_dtype,
+                        scheduler_type=scheduler_type,
+                        use_dynamic_shifting=use_dynamic_shifting,
+                        time_shift_type=time_shift_type,
+                        generator=generator,
+                        # ------------ CFG Zero ------------
+                        use_cfg_zero_star=use_cfg_zero_star,
+                        use_zero_init=use_zero_init,
+                        zero_steps=zero_steps,
+                        # -------------- DMD --------------
+                        use_dmd=use_dmd,
+                        # ------------ Callback ------------
+                        callback_on_step_end=callback_on_step_end,
+                        callback_on_step_end_tensor_inputs=callback_on_step_end_tensor_inputs,
+                        progress_bar=progress_bar,
+                    )
+
+                    all_sections_ode.append(ode_stages_tensor)
+                else:
+                    latents = self.stage1_sample(
+                        latents=latents,
+                        prompt_embeds=prompt_embeds,
+                        negative_prompt_embeds=negative_prompt_embeds,
+                        timesteps=timesteps,
+                        guidance_scale=guidance_scale,
+                        indices_hidden_states=indices_hidden_states,
+                        indices_latents_history_short=indices_latents_history_short,
+                        indices_latents_history_mid=indices_latents_history_mid,
+                        indices_latents_history_long=indices_latents_history_long,
+                        latents_history_short=latents_history_short,
+                        latents_history_mid=latents_history_mid,
+                        latents_history_long=latents_history_long,
+                        attention_kwargs=attention_kwargs,
+                        device=device,
+                        transformer_dtype=transformer_dtype,
+                        generator=generator,
+                        # ------------ CFG Zero ------------
+                        use_cfg_zero_star=use_cfg_zero_star,
+                        use_zero_init=use_zero_init,
+                        zero_steps=zero_steps,
+                        # -------------- DMD --------------
+                        use_dmd=use_dmd,
+                        dmd_sigmas=dmd_sigmas,
+                        dmd_timesteps=dmd_timesteps,
+                        # ------------ Callback ------------
+                        callback_on_step_end=callback_on_step_end,
+                        callback_on_step_end_tensor_inputs=callback_on_step_end_tensor_inputs,
+                        progress_bar=progress_bar,
+                    )
+
+                if use_kv_cache:
+                    self.transformer.clear_kv_cache()
+
+                if use_adaptive_anti_drifting:
+                    current_mean, current_var = anti_drifting_helper.compute_latent_statistics(latents)
+                    anti_drifting_helper.update_global_statistics(current_mean, current_var)
+                    has_drift = anti_drifting_helper.detect_drift(current_mean, current_var)
+
+                    if has_drift and k < num_latent_sections - 1:
+                        print(
+                            f"Drift detected at chunk {k + 1}/{num_latent_sections}. Applying Frame-Aware Corruption."
+                        )
+                        latents = anti_drifting_helper.apply_frame_aware_corruption(
+                            latents,
+                            corruption_strength=anti_drift_corruption_strength,
+                            generator=generator,
+                        )
+
+                if is_keep_x0 and (
+                    (is_first_section and image_latents is None) or (is_skip_first_section and is_second_section)
+                ):
+                    image_latents = latents[:, :, 0:1, :, :]
+
+                total_generated_latent_frames += latents.shape[2]
+                history_latents = torch.cat([history_latents, latents], dim=2)
+
+        return all_sections_ode

Helios/_DEV/helios/pipelines/pipeline_output.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+from typing import Any
+
+import torch
+
+from diffusers.utils import BaseOutput
+
+
+@dataclass
+class HeliosPipelineOutput(BaseOutput):
+    r"""
+    Output class for Helios pipelines.
+
+    Args:
+        frames (`torch.Tensor`, `np.ndarray`, or List[List[PIL.Image.Image]]):
+            List of video outputs - It can be a nested list of length `batch_size,` with each sub-list containing
+            denoised PIL image sequences of length `num_frames.` It can also be a NumPy array or Torch tensor of shape
+            `(batch_size, num_frames, channels, height, width)`.
+    """
+
+    frames: torch.Tensor
+    relative_l1: list[dict[str, Any]] | None = None

Helios/_DEV/helios/scheduler/scheduling_helios.py

@@ -0,0 +1,1056 @@
+import math
+from dataclasses import dataclass
+from typing import List, Optional, Tuple, Union
+
+import numpy as np
+import torch
+
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.schedulers.scheduling_utils import SchedulerMixin
+from diffusers.utils import BaseOutput, deprecate
+
+
+@dataclass
+class HeliosSchedulerOutput(BaseOutput):
+    """
+    Output class for the scheduler's `step` function output.
+
+    Args:
+        prev_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images):
+            Computed sample `(x_{t-1})` of previous timestep. `prev_sample` should be used as next model input in the
+            denoising loop.
+    """
+
+    prev_sample: torch.FloatTensor
+    model_outputs: torch.FloatTensor
+    last_sample: torch.FloatTensor
+    this_order: int
+
+
+class HeliosScheduler(SchedulerMixin, ConfigMixin):
+    """
+    Euler scheduler.
+
+    This model inherits from [`SchedulerMixin`] and [`ConfigMixin`]. Check the superclass documentation for the generic
+    methods the library implements for all schedulers such as loading and saving.
+
+    Args:
+        num_train_timesteps (`int`, defaults to 1000):
+            The number of diffusion steps to train the model.
+        timestep_spacing (`str`, defaults to `"linspace"`):
+            The way the timesteps should be scaled. Refer to Table 2 of the [Common Diffusion Noise Schedules and
+            Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) for more information.
+        shift (`float`, defaults to 1.0):
+            The shift value for the timestep schedule.
+    """
+
+    _compatibles = []
+    order = 1
+
+    @register_to_config
+    def __init__(
+        self,
+        num_train_timesteps: int = 1000,
+        shift: float = 1.0,  # Following Stable diffusion 3,
+        stages: int = 3,
+        stage_range: List = [0, 1 / 3, 2 / 3, 1],
+        gamma: float = 1 / 3,
+        # For UniPC
+        thresholding: bool = False,
+        prediction_type: str = "flow_prediction",
+        solver_order: int = 2,
+        predict_x0: bool = True,
+        solver_type: str = "bh2",
+        lower_order_final: bool = True,
+        disable_corrector: List[int] = [],
+        solver_p: SchedulerMixin = None,
+        use_flow_sigmas: bool = True,
+        version: str = "v1",
+    ):
+        self.version = version
+        self.timestep_ratios = {}  # The timestep ratio for each stage
+        self.timesteps_per_stage = {}  # The detailed timesteps per stage (fix max and min per stage)
+        self.sigmas_per_stage = {}  # always uniform [1000, 0]
+        self.start_sigmas = {}  # for start point / upsample renoise
+        self.end_sigmas = {}  # for end point
+        self.ori_start_sigmas = {}
+
+        # self.init_sigmas()
+        self.init_sigmas_for_each_stage()
+        self.sigma_min = self.sigmas[-1].item()
+        self.sigma_max = self.sigmas[0].item()
+        self.gamma = gamma
+
+        if solver_type not in ["bh1", "bh2"]:
+            if solver_type in ["midpoint", "heun", "logrho"]:
+                self.register_to_config(solver_type="bh2")
+            else:
+                raise NotImplementedError(f"{solver_type} is not implemented for {self.__class__}")
+
+        self.predict_x0 = predict_x0
+        self.model_outputs = [None] * solver_order
+        self.timestep_list = [None] * solver_order
+        self.lower_order_nums = 0
+        self.disable_corrector = disable_corrector
+        self.solver_p = solver_p
+        self.last_sample = None
+        self._step_index = None
+        self._begin_index = None
+
+    def init_sigmas(self):
+        """
+        initialize the global timesteps and sigmas
+        """
+        num_train_timesteps = self.config.num_train_timesteps
+        shift = self.config.shift
+
+        alphas = np.linspace(1, 1 / num_train_timesteps, num_train_timesteps + 1)
+        sigmas = 1.0 - alphas
+        sigmas = np.flip(shift * sigmas / (1 + (shift - 1) * sigmas))[:-1].copy()
+        sigmas = torch.from_numpy(sigmas)
+        timesteps = (sigmas * num_train_timesteps).clone()
+
+        self._step_index = None
+        self._begin_index = None
+        self.timesteps = timesteps
+        self.sigmas = sigmas.to("cpu")  # to avoid too much CPU/GPU communication
+
+    def init_sigmas_for_each_stage(self):
+        """
+        Init the timesteps for each stage
+        """
+        self.init_sigmas()
+
+        stage_distance = []
+        stages = self.config.stages
+        training_steps = self.config.num_train_timesteps
+        stage_range = self.config.stage_range
+
+        # Init the start and end point of each stage
+        for i_s in range(stages):
+            # To decide the start and ends point
+            start_indice = int(stage_range[i_s] * training_steps)
+            start_indice = max(start_indice, 0)
+            end_indice = int(stage_range[i_s + 1] * training_steps)
+            end_indice = min(end_indice, training_steps)
+            start_sigma = self.sigmas[start_indice].item()
+            end_sigma = self.sigmas[end_indice].item() if end_indice < training_steps else 0.0
+            self.ori_start_sigmas[i_s] = start_sigma
+
+            if i_s != 0:
+                ori_sigma = 1 - start_sigma
+                gamma = self.config.gamma
+                corrected_sigma = (1 / (math.sqrt(1 + (1 / gamma)) * (1 - ori_sigma) + ori_sigma)) * ori_sigma
+                # corrected_sigma = 1 / (2 - ori_sigma) * ori_sigma
+                start_sigma = 1 - corrected_sigma
+
+            stage_distance.append(start_sigma - end_sigma)
+            self.start_sigmas[i_s] = start_sigma
+            self.end_sigmas[i_s] = end_sigma
+
+            if self.version == "v2":
+                new_start_indice = (
+                    len(self.sigmas) - torch.searchsorted(self.sigmas.flip(0), start_sigma, right=True)
+                ).item()
+                self.sigmas_per_stage[i_s] = self.sigmas[new_start_indice:end_indice]
+                self.timesteps_per_stage[i_s] = self.timesteps[new_start_indice:end_indice]
+
+        if self.version == "v2":
+            return
+
+        # Determine the ratio of each stage according to flow length
+        tot_distance = sum(stage_distance)
+        for i_s in range(stages):
+            if i_s == 0:
+                start_ratio = 0.0
+            else:
+                start_ratio = sum(stage_distance[:i_s]) / tot_distance
+            if i_s == stages - 1:
+                end_ratio = 0.9999999999999999
+            else:
+                end_ratio = sum(stage_distance[: i_s + 1]) / tot_distance
+
+            self.timestep_ratios[i_s] = (start_ratio, end_ratio)
+
+        # Determine the timesteps and sigmas for each stage
+        for i_s in range(stages):
+            timestep_ratio = self.timestep_ratios[i_s]
+            # timestep_max = self.timesteps[int(timestep_ratio[0] * training_steps)]
+            timestep_max = min(self.timesteps[int(timestep_ratio[0] * training_steps)], 999)
+            timestep_min = self.timesteps[min(int(timestep_ratio[1] * training_steps), training_steps - 1)]
+            timesteps = np.linspace(timestep_max, timestep_min, training_steps + 1)
+            self.timesteps_per_stage[i_s] = (
+                timesteps[:-1] if isinstance(timesteps, torch.Tensor) else torch.from_numpy(timesteps[:-1])
+            )
+            stage_sigmas = np.linspace(0.999, 0, training_steps + 1)
+            self.sigmas_per_stage[i_s] = torch.from_numpy(stage_sigmas[:-1])
+
+    @property
+    def step_index(self):
+        """
+        The index counter for current timestep. It will increase 1 after each scheduler step.
+        """
+        return self._step_index
+
+    @property
+    def begin_index(self):
+        """
+        The index for the first timestep. It should be set from pipeline with `set_begin_index` method.
+        """
+        return self._begin_index
+
+    # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.set_begin_index
+    def set_begin_index(self, begin_index: int = 0):
+        """
+        Sets the begin index for the scheduler. This function should be run from pipeline before the inference.
+
+        Args:
+            begin_index (`int`):
+                The begin index for the scheduler.
+        """
+        self._begin_index = begin_index
+
+    def _sigma_to_t(self, sigma):
+        return sigma * self.config.num_train_timesteps
+
+    def set_timesteps(
+        self,
+        num_inference_steps: int,
+        stage_index: int,
+        device: Union[str, torch.device] = None,
+    ):
+        """
+        Setting the timesteps and sigmas for each stage
+        """
+        self.num_inference_steps = num_inference_steps
+        self.init_sigmas()
+
+        if self.version == "v1":
+            stage_timesteps = self.timesteps_per_stage[stage_index]
+            timestep_max = stage_timesteps[0].item()
+            timestep_min = stage_timesteps[-1].item()
+
+            timesteps = np.linspace(
+                timestep_max,
+                timestep_min,
+                num_inference_steps,
+            )
+            self.timesteps = torch.from_numpy(timesteps).to(device=device)
+
+            stage_sigmas = self.sigmas_per_stage[stage_index]
+            sigma_max = stage_sigmas[0].item()
+            sigma_min = stage_sigmas[-1].item()
+
+            ratios = np.linspace(sigma_max, sigma_min, num_inference_steps)
+            sigmas = torch.from_numpy(ratios).to(device=device)
+            self.sigmas = torch.cat([sigmas, torch.zeros(1, device=sigmas.device)])
+        else:
+            total_steps = len(self.timesteps_per_stage[stage_index])
+            indices = np.linspace(0, total_steps - 1, num_inference_steps, dtype=int)
+
+            self.timesteps = self.timesteps_per_stage[stage_index][indices].to(device=device)
+
+            if stage_index == (self.config.stages - 1):
+                sigmas = self.sigmas_per_stage[stage_index][indices].to(device=device)
+                self.sigmas = torch.cat([sigmas, torch.zeros(1, device=sigmas.device)])
+            else:
+                sigmas = self.sigmas_per_stage[stage_index][indices].to(device=device)
+                self.sigmas = torch.cat(
+                    [sigmas, torch.tensor([self.ori_start_sigmas[stage_index + 1]], device=sigmas.device)]
+                )
+
+        self._step_index = None
+        self.reset_scheduler_history()
+
+    def index_for_timestep(self, timestep, schedule_timesteps=None):
+        if schedule_timesteps is None:
+            schedule_timesteps = self.timesteps
+
+        indices = (schedule_timesteps == timestep).nonzero()
+
+        # The sigma index that is taken for the **very** first `step`
+        # is always the second index (or the last index if there is only 1)
+        # This way we can ensure we don't accidentally skip a sigma in
+        # case we start in the middle of the denoising schedule (e.g. for image-to-image)
+        pos = 1 if len(indices) > 1 else 0
+
+        return indices[pos].item()
+
+    def _init_step_index(self, timestep):
+        if self.begin_index is None:
+            if isinstance(timestep, torch.Tensor):
+                timestep = timestep.to(self.timesteps.device)
+            self._step_index = self.index_for_timestep(timestep)
+        else:
+            self._step_index = self._begin_index
+
+    def step(
+        self,
+        model_output: torch.FloatTensor,
+        timestep: Union[float, torch.FloatTensor] = None,
+        sample: torch.FloatTensor = None,
+        generator: Optional[torch.Generator] = None,
+        sigma: Optional[torch.FloatTensor] = None,
+        sigma_next: Optional[torch.FloatTensor] = None,
+        return_dict: bool = True,
+    ) -> Union[HeliosSchedulerOutput, Tuple]:
+        """
+        Predict the sample from the previous timestep by reversing the SDE. This function propagates the diffusion
+        process from the learned model outputs (most often the predicted noise).
+
+        Args:
+            model_output (`torch.FloatTensor`):
+                The direct output from learned diffusion model.
+            timestep (`float`):
+                The current discrete timestep in the diffusion chain.
+            sample (`torch.FloatTensor`):
+                A current instance of a sample created by the diffusion process.
+            generator (`torch.Generator`, *optional*):
+                A random number generator.
+            return_dict (`bool`):
+                Whether or not to return a [`~schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput`] or
+                tuple.
+
+        Returns:
+            [`~schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput`] or `tuple`:
+                If return_dict is `True`, [`~schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput`] is
+                returned, otherwise a tuple is returned where the first element is the sample tensor.
+        """
+
+        assert (sigma is None) == (sigma_next is None), "sigma and sigma_next must both be None or both be not None"
+
+        if sigma is None and sigma_next is None:
+            if (
+                isinstance(timestep, int)
+                or isinstance(timestep, torch.IntTensor)
+                or isinstance(timestep, torch.LongTensor)
+            ):
+                raise ValueError(
+                    (
+                        "Passing integer indices (e.g. from `enumerate(timesteps)`) as timesteps to"
+                        " `EulerDiscreteScheduler.step()` is not supported. Make sure to pass"
+                        " one of the `scheduler.timesteps` as a timestep."
+                    ),
+                )
+
+        if self.step_index is None:
+            self._step_index = 0
+
+        # Upcast to avoid precision issues when computing prev_sample
+        sample = sample.to(torch.float32)
+
+        if sigma is None and sigma_next is None:
+            sigma = self.sigmas[self.step_index]
+            sigma_next = self.sigmas[self.step_index + 1]
+
+        prev_sample = sample + (sigma_next - sigma) * model_output
+
+        # Cast sample back to model compatible dtype
+        prev_sample = prev_sample.to(model_output.dtype)
+
+        # upon completion increase step index by one
+        self._step_index += 1
+
+        if not return_dict:
+            return (prev_sample,)
+
+        return HeliosSchedulerOutput(prev_sample=prev_sample)
+
+    # ---------------------------------- UniPC ----------------------------------
+    # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler._sigma_to_alpha_sigma_t
+    def _sigma_to_alpha_sigma_t(self, sigma):
+        if self.config.use_flow_sigmas:
+            alpha_t = 1 - sigma
+            sigma_t = torch.clamp(sigma, min=1e-8)
+        else:
+            alpha_t = 1 / ((sigma**2 + 1) ** 0.5)
+            sigma_t = sigma * alpha_t
+
+        return alpha_t, sigma_t
+
+    def convert_model_output(
+        self,
+        model_output: torch.Tensor,
+        *args,
+        sample: torch.Tensor = None,
+        sigma: torch.Tensor = None,
+        **kwargs,
+    ) -> torch.Tensor:
+        r"""
+        Convert the model output to the corresponding type the UniPC algorithm needs.
+
+        Args:
+            model_output (`torch.Tensor`):
+                The direct output from the learned diffusion model.
+            timestep (`int`):
+                The current discrete timestep in the diffusion chain.
+            sample (`torch.Tensor`):
+                A current instance of a sample created by the diffusion process.
+
+        Returns:
+            `torch.Tensor`:
+                The converted model output.
+        """
+        timestep = args[0] if len(args) > 0 else kwargs.pop("timestep", None)
+        if sample is None:
+            if len(args) > 1:
+                sample = args[1]
+            else:
+                raise ValueError("missing `sample` as a required keyword argument")
+        if timestep is not None:
+            deprecate(
+                "timesteps",
+                "1.0.0",
+                "Passing `timesteps` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
+            )
+
+        flag = False
+        if sigma is None:
+            flag = True
+            sigma = self.sigmas[self.step_index]
+        alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma)
+
+        if self.predict_x0:
+            if self.config.prediction_type == "epsilon":
+                x0_pred = (sample - sigma_t * model_output) / alpha_t
+            elif self.config.prediction_type == "sample":
+                x0_pred = model_output
+            elif self.config.prediction_type == "v_prediction":
+                x0_pred = alpha_t * sample - sigma_t * model_output
+            elif self.config.prediction_type == "flow_prediction":
+                if flag:
+                    sigma_t = self.sigmas[self.step_index]
+                else:
+                    sigma_t = sigma
+                x0_pred = sample - sigma_t * model_output
+            else:
+                raise ValueError(
+                    f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, "
+                    "`v_prediction`, or `flow_prediction` for the UniPCMultistepScheduler."
+                )
+
+            if self.config.thresholding:
+                x0_pred = self._threshold_sample(x0_pred)
+
+            return x0_pred
+        else:
+            if self.config.prediction_type == "epsilon":
+                return model_output
+            elif self.config.prediction_type == "sample":
+                epsilon = (sample - alpha_t * model_output) / sigma_t
+                return epsilon
+            elif self.config.prediction_type == "v_prediction":
+                epsilon = alpha_t * model_output + sigma_t * sample
+                return epsilon
+            else:
+                raise ValueError(
+                    f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, or"
+                    " `v_prediction` for the UniPCMultistepScheduler."
+                )
+
+    def multistep_uni_p_bh_update(
+        self,
+        model_output: torch.Tensor,
+        *args,
+        sample: torch.Tensor = None,
+        order: int = None,
+        sigma: torch.Tensor = None,
+        sigma_next: torch.Tensor = None,
+        **kwargs,
+    ) -> torch.Tensor:
+        """
+        One step for the UniP (B(h) version). Alternatively, `self.solver_p` is used if is specified.
+
+        Args:
+            model_output (`torch.Tensor`):
+                The direct output from the learned diffusion model at the current timestep.
+            prev_timestep (`int`):
+                The previous discrete timestep in the diffusion chain.
+            sample (`torch.Tensor`):
+                A current instance of a sample created by the diffusion process.
+            order (`int`):
+                The order of UniP at this timestep (corresponds to the *p* in UniPC-p).
+
+        Returns:
+            `torch.Tensor`:
+                The sample tensor at the previous timestep.
+        """
+        prev_timestep = args[0] if len(args) > 0 else kwargs.pop("prev_timestep", None)
+        if sample is None:
+            if len(args) > 1:
+                sample = args[1]
+            else:
+                raise ValueError("missing `sample` as a required keyword argument")
+        if order is None:
+            if len(args) > 2:
+                order = args[2]
+            else:
+                raise ValueError("missing `order` as a required keyword argument")
+        if prev_timestep is not None:
+            deprecate(
+                "prev_timestep",
+                "1.0.0",
+                "Passing `prev_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
+            )
+        model_output_list = self.model_outputs
+
+        s0 = self.timestep_list[-1]
+        m0 = model_output_list[-1]
+        x = sample
+
+        if self.solver_p:
+            x_t = self.solver_p.step(model_output, s0, x).prev_sample
+            return x_t
+
+        if sigma_next is None and sigma is None:
+            sigma_t, sigma_s0 = self.sigmas[self.step_index + 1], self.sigmas[self.step_index]
+        else:
+            sigma_t, sigma_s0 = sigma_next, sigma
+        alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma_t)
+        alpha_s0, sigma_s0 = self._sigma_to_alpha_sigma_t(sigma_s0)
+
+        lambda_t = torch.log(alpha_t) - torch.log(sigma_t)
+        lambda_s0 = torch.log(alpha_s0) - torch.log(sigma_s0)
+
+        h = lambda_t - lambda_s0
+        device = sample.device
+
+        rks = []
+        D1s = []
+        for i in range(1, order):
+            si = self.step_index - i
+            mi = model_output_list[-(i + 1)]
+            alpha_si, sigma_si = self._sigma_to_alpha_sigma_t(self.sigmas[si])
+            lambda_si = torch.log(alpha_si) - torch.log(sigma_si)
+            rk = (lambda_si - lambda_s0) / h
+            rks.append(rk)
+            D1s.append((mi - m0) / rk)
+
+        rks.append(1.0)
+        rks = torch.tensor(rks, device=device)
+
+        R = []
+        b = []
+
+        hh = -h if self.predict_x0 else h
+        h_phi_1 = torch.expm1(hh)  # h\phi_1(h) = e^h - 1
+        h_phi_k = h_phi_1 / hh - 1
+
+        factorial_i = 1
+
+        if self.config.solver_type == "bh1":
+            B_h = hh
+        elif self.config.solver_type == "bh2":
+            B_h = torch.expm1(hh)
+        else:
+            raise NotImplementedError()
+
+        for i in range(1, order + 1):
+            R.append(torch.pow(rks, i - 1))
+            b.append(h_phi_k * factorial_i / B_h)
+            factorial_i *= i + 1
+            h_phi_k = h_phi_k / hh - 1 / factorial_i
+
+        R = torch.stack(R)
+        b = torch.tensor(b, device=device)
+
+        if len(D1s) > 0:
+            D1s = torch.stack(D1s, dim=1)  # (B, K)
+            # for order 2, we use a simplified version
+            if order == 2:
+                rhos_p = torch.tensor([0.5], dtype=x.dtype, device=device)
+            else:
+                rhos_p = torch.linalg.solve(R[:-1, :-1], b[:-1]).to(device).to(x.dtype)
+        else:
+            D1s = None
+
+        if self.predict_x0:
+            x_t_ = sigma_t / sigma_s0 * x - alpha_t * h_phi_1 * m0
+            if D1s is not None:
+                pred_res = torch.einsum("k,bkc...->bc...", rhos_p, D1s)
+            else:
+                pred_res = 0
+            x_t = x_t_ - alpha_t * B_h * pred_res
+        else:
+            x_t_ = alpha_t / alpha_s0 * x - sigma_t * h_phi_1 * m0
+            if D1s is not None:
+                pred_res = torch.einsum("k,bkc...->bc...", rhos_p, D1s)
+            else:
+                pred_res = 0
+            x_t = x_t_ - sigma_t * B_h * pred_res
+
+        x_t = x_t.to(x.dtype)
+        return x_t
+
+    def multistep_uni_c_bh_update(
+        self,
+        this_model_output: torch.Tensor,
+        *args,
+        last_sample: torch.Tensor = None,
+        this_sample: torch.Tensor = None,
+        order: int = None,
+        sigma_before: torch.Tensor = None,
+        sigma: torch.Tensor = None,
+        **kwargs,
+    ) -> torch.Tensor:
+        """
+        One step for the UniC (B(h) version).
+
+        Args:
+            this_model_output (`torch.Tensor`):
+                The model outputs at `x_t`.
+            this_timestep (`int`):
+                The current timestep `t`.
+            last_sample (`torch.Tensor`):
+                The generated sample before the last predictor `x_{t-1}`.
+            this_sample (`torch.Tensor`):
+                The generated sample after the last predictor `x_{t}`.
+            order (`int`):
+                The `p` of UniC-p at this step. The effective order of accuracy should be `order + 1`.
+
+        Returns:
+            `torch.Tensor`:
+                The corrected sample tensor at the current timestep.
+        """
+        this_timestep = args[0] if len(args) > 0 else kwargs.pop("this_timestep", None)
+        if last_sample is None:
+            if len(args) > 1:
+                last_sample = args[1]
+            else:
+                raise ValueError("missing `last_sample` as a required keyword argument")
+        if this_sample is None:
+            if len(args) > 2:
+                this_sample = args[2]
+            else:
+                raise ValueError("missing `this_sample` as a required keyword argument")
+        if order is None:
+            if len(args) > 3:
+                order = args[3]
+            else:
+                raise ValueError("missing `order` as a required keyword argument")
+        if this_timestep is not None:
+            deprecate(
+                "this_timestep",
+                "1.0.0",
+                "Passing `this_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
+            )
+
+        model_output_list = self.model_outputs
+
+        m0 = model_output_list[-1]
+        x = last_sample
+        x_t = this_sample
+        model_t = this_model_output
+
+        if sigma_before is None and sigma is None:
+            sigma_t, sigma_s0 = self.sigmas[self.step_index], self.sigmas[self.step_index - 1]
+        else:
+            sigma_t, sigma_s0 = sigma, sigma_before
+        alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma_t)
+        alpha_s0, sigma_s0 = self._sigma_to_alpha_sigma_t(sigma_s0)
+
+        lambda_t = torch.log(alpha_t) - torch.log(sigma_t)
+        lambda_s0 = torch.log(alpha_s0) - torch.log(sigma_s0)
+
+        h = lambda_t - lambda_s0
+        device = this_sample.device
+
+        rks = []
+        D1s = []
+        for i in range(1, order):
+            si = self.step_index - (i + 1)
+            mi = model_output_list[-(i + 1)]
+            alpha_si, sigma_si = self._sigma_to_alpha_sigma_t(self.sigmas[si])
+            lambda_si = torch.log(alpha_si) - torch.log(sigma_si)
+            rk = (lambda_si - lambda_s0) / h
+            rks.append(rk)
+            D1s.append((mi - m0) / rk)
+
+        rks.append(1.0)
+        rks = torch.tensor(rks, device=device)
+
+        R = []
+        b = []
+
+        hh = -h if self.predict_x0 else h
+        h_phi_1 = torch.expm1(hh)  # h\phi_1(h) = e^h - 1
+        h_phi_k = h_phi_1 / hh - 1
+
+        factorial_i = 1
+
+        if self.config.solver_type == "bh1":
+            B_h = hh
+        elif self.config.solver_type == "bh2":
+            B_h = torch.expm1(hh)
+        else:
+            raise NotImplementedError()
+
+        for i in range(1, order + 1):
+            R.append(torch.pow(rks, i - 1))
+            b.append(h_phi_k * factorial_i / B_h)
+            factorial_i *= i + 1
+            h_phi_k = h_phi_k / hh - 1 / factorial_i
+
+        R = torch.stack(R)
+        b = torch.tensor(b, device=device)
+
+        if len(D1s) > 0:
+            D1s = torch.stack(D1s, dim=1)
+        else:
+            D1s = None
+
+        # for order 1, we use a simplified version
+        if order == 1:
+            rhos_c = torch.tensor([0.5], dtype=x.dtype, device=device)
+        else:
+            rhos_c = torch.linalg.solve(R, b).to(device).to(x.dtype)
+
+        if self.predict_x0:
+            x_t_ = sigma_t / sigma_s0 * x - alpha_t * h_phi_1 * m0
+            if D1s is not None:
+                corr_res = torch.einsum("k,bkc...->bc...", rhos_c[:-1], D1s)
+            else:
+                corr_res = 0
+            D1_t = model_t - m0
+            x_t = x_t_ - alpha_t * B_h * (corr_res + rhos_c[-1] * D1_t)
+        else:
+            x_t_ = alpha_t / alpha_s0 * x - sigma_t * h_phi_1 * m0
+            if D1s is not None:
+                corr_res = torch.einsum("k,bkc...->bc...", rhos_c[:-1], D1s)
+            else:
+                corr_res = 0
+            D1_t = model_t - m0
+            x_t = x_t_ - sigma_t * B_h * (corr_res + rhos_c[-1] * D1_t)
+        x_t = x_t.to(x.dtype)
+        return x_t
+
+    def step_unipc(
+        self,
+        model_output: torch.Tensor,
+        timestep: Union[int, torch.Tensor] = None,
+        sample: torch.Tensor = None,
+        return_dict: bool = True,
+        model_outputs: list = None,
+        timestep_list: list = None,
+        sigma_before: torch.Tensor = None,
+        sigma: torch.Tensor = None,
+        sigma_next: torch.Tensor = None,
+        cus_step_index: int = None,
+        cus_lower_order_num: int = None,
+        cus_this_order: int = None,
+        cus_last_sample: torch.Tensor = None,
+    ) -> Union[HeliosSchedulerOutput, Tuple]:
+        """
+        Predict the sample from the previous timestep by reversing the SDE. This function propagates the sample with
+        the multistep UniPC.
+
+        Args:
+            model_output (`torch.Tensor`):
+                The direct output from learned diffusion model.
+            timestep (`int`):
+                The current discrete timestep in the diffusion chain.
+            sample (`torch.Tensor`):
+                A current instance of a sample created by the diffusion process.
+            return_dict (`bool`):
+                Whether or not to return a [`~schedulers.scheduling_utils.SchedulerOutput`] or `tuple`.
+
+        Returns:
+            [`~schedulers.scheduling_utils.SchedulerOutput`] or `tuple`:
+                If return_dict is `True`, [`~schedulers.scheduling_utils.SchedulerOutput`] is returned, otherwise a
+                tuple is returned where the first element is the sample tensor.
+
+        """
+        # don't change
+        # print(len(self.model_outputs), len(self.timestep_list), self.disable_corrector, self.solver_p, self._begin_index)
+
+        if self.num_inference_steps is None:
+            raise ValueError(
+                "Number of inference steps is 'None', you need to run 'set_timesteps' after creating the scheduler"
+            )
+
+        if cus_step_index is None:
+            if self.step_index is None:
+                self._step_index = 0
+        else:
+            self._step_index = cus_step_index
+
+        if cus_lower_order_num is not None:
+            self.lower_order_nums = cus_lower_order_num
+
+        if cus_this_order is not None:
+            self.this_order = cus_this_order
+
+        if cus_last_sample is not None:
+            self.last_sample = cus_last_sample
+
+        use_corrector = (
+            self.step_index > 0 and self.step_index - 1 not in self.disable_corrector and self.last_sample is not None
+        )
+
+        # Convert model output using the proper conversion method
+        model_output_convert = self.convert_model_output(model_output, sample=sample, sigma=sigma)
+
+        if model_outputs is not None and timestep_list is not None:
+            self.model_outputs = model_outputs[:-1]
+            self.timestep_list = timestep_list[:-1]
+
+        # print("1", self.step_index, self.timestep_list)
+
+        if use_corrector:
+            sample = self.multistep_uni_c_bh_update(
+                this_model_output=model_output_convert,
+                last_sample=self.last_sample,
+                this_sample=sample,
+                order=self.this_order,
+                sigma_before=sigma_before,
+                sigma=sigma,
+            )
+
+        if model_outputs is not None and timestep_list is not None:
+            model_outputs[-1] = model_output_convert
+            self.model_outputs = model_outputs[1:]
+            self.timestep_list = timestep_list[1:]
+        else:
+            for i in range(self.config.solver_order - 1):
+                self.model_outputs[i] = self.model_outputs[i + 1]
+                self.timestep_list[i] = self.timestep_list[i + 1]
+            self.model_outputs[-1] = model_output_convert
+            self.timestep_list[-1] = timestep
+
+        if self.config.lower_order_final:
+            this_order = min(self.config.solver_order, len(self.timesteps) - self.step_index)
+        else:
+            this_order = self.config.solver_order
+        self.this_order = min(this_order, self.lower_order_nums + 1)  # warmup for multistep
+        assert self.this_order > 0
+
+        # change
+        # print("2", self.step_index, self.timestep_list, self.lower_order_nums, self.this_order, "\n")
+        # print(self._step_index, self.lower_order_nums, use_corrector, self.this_order, self.lower_order_nums)
+        # 0 1 False 1 1
+        # 1 2  True 2 2
+        # 2 2  True 2 2
+        # 3 2  True 2 2
+        # 4 2  True 2 2
+        # 5 2  True 2 2
+        # 6 2  True 2 2
+        # 7 2  True 2 2
+        # 8 2  True 2 2
+        # 9 2  True 1 2
+
+        self.last_sample = sample
+        prev_sample = self.multistep_uni_p_bh_update(
+            model_output=model_output,  # pass the original non-converted model output, in case solver-p is used
+            sample=sample,
+            order=self.this_order,
+            sigma=sigma,
+            sigma_next=sigma_next,
+        )
+
+        if cus_lower_order_num is None:
+            if self.lower_order_nums < self.config.solver_order:
+                self.lower_order_nums += 1
+
+        # upon completion increase step index by one
+        if cus_step_index is None:
+            self._step_index += 1
+
+        if not return_dict:
+            return (prev_sample, model_outputs, self.last_sample, self.this_order)
+
+        return HeliosSchedulerOutput(
+            prev_sample=prev_sample,
+            model_outputs=model_outputs,
+            last_sample=self.last_sample,
+            this_order=self.this_order,
+        )
+
+    def reset_scheduler_history(self):
+        self.model_outputs = [None] * self.config.solver_order
+        self.timestep_list = [None] * self.config.solver_order
+        self.lower_order_nums = 0
+        self.disable_corrector = self.config.disable_corrector
+        self.solver_p = self.config.solver_p
+        self.last_sample = None
+        self._step_index = None
+        self._begin_index = None
+
+    def __len__(self):
+        return self.config.num_train_timesteps
+
+
+if __name__ == "__main__":
+    device = "cuda"
+
+    # ---------------------- For dynamic shifting ----------------------
+    from examples.scheduling_unipc_multistep_latest import UniPCMultistepScheduler
+
+    scheduler_official = UniPCMultistepScheduler.from_pretrained("BestWishYsh/Helios-Base", subfolder="scheduler")
+    scheduler_official.set_timesteps(num_inference_steps=50)
+    scheduler_official.timesteps
+    scheduler_official.sigmas
+
+    # # Official
+    # from scheduling_flow_match_euler_discrete_official import FlowMatchEulerDiscreteScheduler
+    # scheduler_official = FlowMatchEulerDiscreteScheduler(num_train_timesteps=1000, shift=3.0)
+    # scheduler_official.set_timesteps(num_inference_steps=50, sigmas=None)
+    # scheduler_official.timesteps
+    # scheduler_official.sigmas
+
+    # import sys
+    # sys.path.append("../../")
+    # from helios.utils.utils_helios_base import apply_schedule_shift
+
+    # sigmas = apply_schedule_shift(scheduler_official.sigmas, torch.ones([2, 16, 21, 48, 80]), mu=3)
+    # timesteps = sigmas[:-1] * 1000.0
+
+    # import copy
+    # from diffusers.training_utils import compute_density_for_timestep_sampling
+
+    # def get_sigmas(timesteps, n_dim=4, device="cpu", dtype=torch.float32):
+    #     sigmas = noise_scheduler_copy.sigmas.to(device=device, dtype=dtype)
+    #     schedule_timesteps = noise_scheduler_copy.timesteps.to(device)
+    #     timesteps = timesteps.to(device)
+    #     step_indices = [(schedule_timesteps == t).nonzero().item() for t in timesteps]
+    #     sigma = sigmas[step_indices].flatten()
+    #     while len(sigma.shape) < n_dim:
+    #         sigma = sigma.unsqueeze(-1)
+    #     return sigma
+
+    # noise_scheduler_copy = copy.deepcopy(scheduler_official)
+
+    # # Sample noise that we'll add to the latents
+    # model_input = torch.ones([2, 16, 9, 88, 68])
+    # noise = torch.randn_like(model_input)
+    # bsz = model_input.shape[0]
+
+    # # Sample a random timestep for each image
+    # # for weighting schemes where we sample timesteps non-uniformly
+    # u = compute_density_for_timestep_sampling(
+    #     weighting_scheme="logit_normal", batch_size=bsz, logit_mean=0.0, logit_std=1.0, mode_scale=1.29
+    # )
+    # indices = (u * noise_scheduler_copy.config.num_train_timesteps).long()
+    # timesteps = noise_scheduler_copy.timesteps[indices].to(device=model_input.device)
+
+    # # Add noise according to flow matching.
+    # # zt = (1 - texp) * x + texp * z1
+    # sigmas = get_sigmas(timesteps, n_dim=model_input.ndim, dtype=model_input.dtype)
+
+    # import sys
+    # sys.path.append("../../")
+    # from helios.utils.utils_helios_base import apply_schedule_shift
+
+    # sigmas = apply_schedule_shift(sigmas, noise)  # torch.Size([2, 1, 1, 1, 1])
+    # timesteps = sigmas * 1000.0  # rescale to [0, 1000.0)
+    # while timesteps.ndim > 1:
+    #     timesteps = timesteps.squeeze(-1)
+    # ---------------------- For dynamic shifting ----------------------
+
+    # ---------------------- For timestep shifting ----------------------
+    stages = 3
+    timestep_shift = 1.0
+    stage_range = [0, 1 / 3, 2 / 3, 1]
+    scheduler_gamma = 1 / 3
+    version = "v1"
+    scheduler = HeliosScheduler(
+        shift=timestep_shift, stages=stages, stage_range=stage_range, gamma=scheduler_gamma, version=version
+    )
+    print(
+        f"The start sigmas and end sigmas of each stage is Start: {scheduler.start_sigmas}, End: {scheduler.end_sigmas}, Ori_start: {scheduler.ori_start_sigmas}"
+    )
+
+    i_s = 1
+    stage2_num_inference_steps_list = [3, 3, 3]
+    scheduler.set_timesteps(stage2_num_inference_steps_list[i_s], i_s)
+    scheduler.timesteps.to(dtype=torch.float32)
+    scheduler.sigmas.to(dtype=torch.float32)
+
+    # stages = 2
+    # timestep_shift = 3.0
+    # stage_range = [0, 1 / 2, 1]
+    # scheduler_gamma = 1 / 3
+    # version = "v2"
+    # scheduler = HeliosScheduler(
+    #     shift=timestep_shift, stages=stages, stage_range=stage_range, gamma=scheduler_gamma, version=version
+    # )
+    # print(
+    #     f"The start sigmas and end sigmas of each stage is Start: {scheduler.start_sigmas}, End: {scheduler.end_sigmas}, Ori_start: {scheduler.ori_start_sigmas}"
+    # )
+
+    # i_s = 1
+    # stage2_num_inference_steps_list = [10, 10]
+    # scheduler.set_timesteps(stage2_num_inference_steps_list[i_s], i_s)
+    # scheduler.timesteps.to(dtype=torch.float32)
+    # scheduler.sigmas.to(dtype=torch.float32)
+
+    # scheduler.timesteps_per_stage[0]
+    # scheduler.sigmas_per_stage[0]
+    # shift1: (999, 743.5120) -> (743.2563, 385.9723) -> (385.6146, 1.3846)
+    # shift3: (999, 957.3958) -> (957.3542, 828.9170) -> (828.7885, 3.8198)
+
+    # timesteps_1 = np.linspace(1, 1000 - 1, 1000, dtype=np.float32)[::-1].copy()
+    # timesteps_1 = torch.from_numpy(timesteps_1).to(dtype=torch.float32)
+    # sigmas_1 = timesteps_1 / 1000
+    # sigmas_1 = apply_schedule_shift(sigmas_1, torch.ones([2, 16, 21, 48, 80]), mu=3)
+    # timesteps_2 = sigmas_1 * 1000
+
+    # import pdb;pdb.set_trace()
+    # temp_sigmas = apply_schedule_shift(scheduler.timesteps / 1000, torch.ones([2, 16, 21, 48, 80]), mu=3)
+    # temp_timesteps = temp_sigmas * 1000
+    # while temp_timesteps.ndim > 1:
+    #     temp_timesteps = temp_timesteps.squeeze(-1)
+    # temp_timesteps = temp_timesteps[:-1]
+
+    # # very important here!
+    # timesteps = temp_timesteps
+    # # self.scheduler.sigmas = temp_sigmas
+    # scheduler.timesteps = temp_timesteps
+
+    # ---------------------- For timestep shifting ----------------------
+
+    # ---------------------- For dynamic shifting ----------------------
+
+    # ---------------------- For per step sigmas & timesteps ----------------------
+    # scheduler = HeliosScheduler(shift=3.0, stages=stages, stage_range=stage_range, gamma=scheduler_gamma)
+    # stage2_num_inference_steps_list = [10, 10, 10]
+    # i_s = 0
+    # scheduler.set_timesteps(stage2_num_inference_steps_list[i_s], i_s)
+    # scheduler.timesteps_per_stage[0]
+    # scheduler.sigmas_per_stage[0]
+    # scheduler.timesteps
+    # scheduler.sigmas
+    # ---------------------- For per step sigmas & timesteps ----------------------
+
+    # ---------------------- For Custom step ----------------------
+    # timesteps = scheduler.timesteps
+    # noise_pred = torch.randn([2, 16, 10, 48, 80], device=device)
+    # latents = torch.randn([2, 16, 10, 48, 80], device=device)
+    # for i, t in enumerate(timesteps):
+    #     print(i, t)
+    #     # latents = scheduler.step(noise_pred, t, latents, return_dict=False)[0]
+    #     latents = scheduler.step_custom_unipc(noise_pred, t, latents, return_dict=False)[0]
+
+    # def upsample_tensor(tensor, scale_factor=2):
+    #     return torch.nn.functional.interpolate(
+    #         tensor, scale_factor=scale_factor, mode="trilinear", align_corners=False
+    #     )
+
+    # stage2_num_inference_steps_list = [10, 10, 10]
+    # noise_pred = torch.randn([2, 16, 10, 12, 20], device=device)
+    # latents = torch.randn([2, 16, 10, 12, 20], device=device)
+    # for stage, num_steps in enumerate(stage2_num_inference_steps_list):
+    #     print(f"stage: {stage}, num_steps: {num_steps}")
+    #     if stage > 0:
+    #         latents = upsample_tensor(latents, scale_factor=2)
+    #         noise_pred = upsample_tensor(noise_pred, scale_factor=2)
+
+    #     scheduler.set_timesteps(num_steps, stage)
+    #     timesteps = scheduler.timesteps
+
+    #     print(f"Timesteps for stage {stage + 1}: {timesteps}")
+
+    #     for i, t in enumerate(timesteps):
+    #         # print(i, t, latents.shape)
+    #         # latents = scheduler.step(noise_pred, t, latents, return_dict=False)[0]
+    #         latents = scheduler.step_unipc(noise_pred, t, latents, return_dict=False)[0]
+    # ---------------------- For Custom step ----------------------

Helios/_DEV/helios/utils/create_ema_zero3.py

@@ -0,0 +1,401 @@
+import copy
+import json
+import math
+import os
+from typing import Any, Dict, Iterable, Optional, Union
+
+from huggingface_hub import save_torch_state_dict
+
+from diffusers.utils import (
+    deprecate,
+    is_torchvision_available,
+    is_transformers_available,
+)
+
+
+if is_transformers_available():
+    pass
+
+if is_torchvision_available():
+    pass
+
+import deepspeed
+import torch
+from deepspeed.runtime.zero.partition_parameters import ZeroParamStatus
+
+
+def _z3_params_to_fetch(param_list):
+    return [p for p in param_list if hasattr(p, "ds_id") and p.ds_status == ZeroParamStatus.NOT_AVAILABLE]
+
+
+# Adapted from diffusers-style ema https://github.com/huggingface/diffusers/blob/main/src/diffusers/training_utils.py#L263
+class EMAModel_Zero3:
+    """
+    Exponential Moving Average of models weights
+    """
+
+    def __init__(
+        self,
+        model: torch.nn.Module,
+        decay: float = 0.9999,
+        min_decay: float = 0.0,
+        update_after_step: int = 0,
+        use_ema_warmup: bool = False,
+        inv_gamma: Union[float, int] = 1.0,
+        power: Union[float, int] = 2 / 3,
+        model_cls: Optional[Any] = None,
+        model_config: Dict[str, Any] = None,
+        weight_file_prefix: Optional[str] = "",
+        **kwargs,
+    ):
+        """
+        Args:
+            parameters (Iterable[torch.nn.Parameter]): The parameters to track.
+            decay (float): The decay factor for the exponential moving average.
+            min_decay (float): The minimum decay factor for the exponential moving average.
+            update_after_step (int): The number of steps to wait before starting to update the EMA weights.
+            use_ema_warmup (bool): Whether to use EMA warmup.
+            inv_gamma (float):
+                Inverse multiplicative factor of EMA warmup. Default: 1. Only used if `use_ema_warmup` is True.
+            power (float): Exponential factor of EMA warmup. Default: 2/3. Only used if `use_ema_warmup` is True.
+            device (Optional[Union[str, torch.device]]): The device to store the EMA weights on. If None, the EMA
+                        weights will be stored on CPU.
+
+        @crowsonkb's notes on EMA Warmup:
+            If gamma=1 and power=1, implements a simple average. gamma=1, power=2/3 are good values for models you plan
+            to train for a million or more steps (reaches decay factor 0.999 at 31.6K steps, 0.9999 at 1M steps),
+            gamma=1, power=3/4 for models you plan to train for less (reaches decay factor 0.999 at 10K steps, 0.9999
+            at 215.4k steps).
+        """
+
+        self.model = model
+
+        if kwargs.get("max_value", None) is not None:
+            deprecation_message = "The `max_value` argument is deprecated. Please use `decay` instead."
+            deprecate("max_value", "1.0.0", deprecation_message, standard_warn=False)
+            decay = kwargs["max_value"]
+
+        if kwargs.get("min_value", None) is not None:
+            deprecation_message = "The `min_value` argument is deprecated. Please use `min_decay` instead."
+            deprecate("min_value", "1.0.0", deprecation_message, standard_warn=False)
+            min_decay = kwargs["min_value"]
+
+        if kwargs.get("device", None) is not None:
+            deprecation_message = "The `device` argument is deprecated. Please use `to` instead."
+            deprecate("device", "1.0.0", deprecation_message, standard_warn=False)
+            self.to(device=kwargs["device"])
+
+        self.temp_stored_params = None
+
+        self.decay = decay
+        self.min_decay = min_decay
+        self.update_after_step = update_after_step
+        self.use_ema_warmup = use_ema_warmup
+        self.inv_gamma = inv_gamma
+        self.power = power
+        self.optimization_step = 0
+        self.cur_decay_value = None  # set in `step()`
+
+        self.model_cls = model_cls
+        self.model_config = model_config
+
+        self.weight_file_prefix = weight_file_prefix
+
+    @classmethod
+    def extract_ema_kwargs(cls, kwargs):
+        """
+        Extracts the EMA kwargs from the kwargs of a class method.
+        """
+        ema_kwargs = {}
+        for key in [
+            "decay",
+            "min_decay",
+            "optimization_step",
+            "update_after_step",
+            "use_ema_warmup",
+            "inv_gamma",
+            "power",
+        ]:
+            if kwargs.get(key, None) is not None:
+                ema_kwargs[key] = kwargs.pop(key)
+        return ema_kwargs
+
+    @classmethod
+    def from_pretrained(cls, path, model_cls) -> "EMAModel_Zero3":
+        config = model_cls.load_config(path)
+        ema_kwargs = cls.extract_ema_kwargs(config)
+        model = model_cls.from_pretrained(path)
+
+        ema_model = cls(model, model_cls=model_cls, model_config=config)
+
+        ema_model.load_state_dict(ema_kwargs)
+        return ema_model
+
+    def save_pretrained(self, path):
+        if self.model_cls is None:
+            raise ValueError("`save_pretrained` can only be used if `model_cls` was defined at __init__.")
+
+        if self.model_config is None:
+            raise ValueError("`save_pretrained` can only be used if `model_config` was defined at __init__.")
+
+        rank = int(os.getenv("RANK", "0"))
+        state_dict = self.state_dict()
+        state_dict.pop("model")
+
+        model_to_save = self.model.module if hasattr(self.model, "module") else self.model
+        model_state_dict = {}
+        for k, v in model_to_save.named_parameters():
+            # only gather z3 params
+            params_to_fetch = _z3_params_to_fetch([v])
+            with deepspeed.zero.GatheredParameters(params_to_fetch, enabled=len(params_to_fetch) > 0):
+                vv = v.data.cpu()
+                if rank == 0:
+                    model_state_dict[k] = vv
+
+        if rank == 0:
+            os.makedirs(path, exist_ok=True)
+            print(f"state_dict, {state_dict.keys()}")
+            import time
+
+            t_start = time.perf_counter()
+            print(f"[{t_start:.4f}] 开始 save_pretrained")
+
+            print(type(self.model_config), self.model_config)
+            for k, v in state_dict.items():
+                if isinstance(self.model_config, dict):
+                    self.model.config[k] = v
+                else:
+                    setattr(self.model_config, k, v)
+            t1 = time.perf_counter()
+            print(f"[{t1:.4f}] after setattr config (耗时 {t1 - t_start:.4f} 秒)")
+
+            if hasattr(self.model_config, "save_pretrained"):
+                self.model_config.save_pretrained(path)
+            else:
+                with open(os.path.join(path, "config.json"), "w") as f:
+                    json.dump(self.model_config, f, indent=2)
+            if hasattr(self.model, "generation_config"):
+                print(type(self.model.generation_config), self.model.generation_config)
+                self.model.generation_config.save_pretrained(path)
+                # with open(os.path.join(path, "generation_config.json"), "w") as f:
+                #     json.dump(self.model.generation_config, f, indent=2)
+            t2 = time.perf_counter()
+            print(f"[{t2:.4f}] self.model.save_config(path) (耗时 {t2 - t1:.4f} 秒)")
+
+            if self.weight_file_prefix != "":
+                self._save_pretrained_with_prefix(model_state_dict, path, self.weight_file_prefix)
+            else:
+                torch.save(model_state_dict, os.path.join(path, "pytorch_model.bin"))
+            t3 = time.perf_counter()
+            print(f"[{t3:.4f}] after save_pretrained (耗时 {t3 - t2:.4f} 秒)")
+
+            print(f"[{t3:.4f}] 总耗时 {t3 - t_start:.4f} 秒")
+        return model_state_dict
+
+    def _save_pretrained_with_prefix(self, state_dict, save_dir, weight_file_prefix):
+        suffix = "{suffix}"
+        pattern = f"{weight_file_prefix}{suffix}.safetensors"
+        save_torch_state_dict(
+            state_dict=state_dict,
+            save_directory=save_dir,
+            filename_pattern=pattern,
+            max_shard_size="5GB",
+            safe_serialization=True,
+        )
+
+    def get_decay(self, optimization_step: int) -> float:
+        """
+        Compute the decay factor for the exponential moving average.
+        """
+        step = max(0, optimization_step - self.update_after_step - 1)
+
+        if step <= 0:
+            return 0.0
+
+        if self.use_ema_warmup:
+            cur_decay_value = 1 - (1 + step / self.inv_gamma) ** -self.power
+        else:
+            cur_decay_value = (1 + step) / (10 + step)
+
+        cur_decay_value = min(cur_decay_value, self.decay)
+        # make sure decay is not smaller than min_decay
+        cur_decay_value = max(cur_decay_value, self.min_decay)
+        return cur_decay_value
+
+    @torch.no_grad()
+    def step(self, parameters: Iterable[torch.nn.Parameter]):
+        if isinstance(parameters, torch.nn.Module):
+            deprecation_message = (
+                "Passing a `torch.nn.Module` to `ExponentialMovingAverage.step` is deprecated. "
+                "Please pass the parameters of the module instead."
+            )
+            deprecate(
+                "passing a `torch.nn.Module` to `ExponentialMovingAverage.step`",
+                "1.0.0",
+                deprecation_message,
+                standard_warn=False,
+            )
+            parameters = parameters.parameters()
+
+        parameters = list(parameters)
+
+        self.optimization_step += 1
+
+        # Compute the decay factor for the exponential moving average.
+        decay = self.get_decay(self.optimization_step)
+        self.cur_decay_value = decay
+        one_minus_decay = 1 - decay
+        # print(f'one_minus_decay {one_minus_decay}')
+        # https://github.com/microsoft/DeepSpeed/blob/master/deepspeed/runtime/zero/partition_parameters.py#L1543
+        for s_param, param in zip(self.model.parameters(), parameters):
+            s_tensor, tensor = None, None
+            if hasattr(s_param, "ds_tensor"):  # EMA ZeRO-3
+                # print('EMA ZeRO-3')
+                s_tensor = s_param.ds_tensor
+                if hasattr(param, "ds_tensor"):  # DiT ZeRO-3
+                    tensor = param.ds_tensor
+                else:  # DiT ZeRO-2
+                    rank, world_size = int(os.getenv("RANK")), int(os.getenv("WORLD_SIZE"))
+                    partition_size = math.ceil(param.numel() / world_size)
+                    start = partition_size * rank
+                    end = start + partition_size
+
+                    one_dim_param = param.data.contiguous().view(-1)
+                    if start < param.numel() and end <= param.numel():
+                        tensor = one_dim_param.narrow(0, start, partition_size)
+                    elif start < param.numel():
+                        # raise ValueError(f'start {start}, end {end}, param.numel() {param.numel()}, partition_size {partition_size}')
+                        elems_to_copy = param.numel() - start
+                        s_tensor = s_param.ds_tensor.narrow(0, 0, elems_to_copy)
+                        tensor = one_dim_param.narrow(0, start, elems_to_copy)
+                    else:
+                        # raise ValueError(f'start {start}, end {end}, param.numel() {param.numel()}, partition_size {partition_size}')
+                        continue
+            else:  # DiT/EMA ZeRO-2
+                s_tensor = s_param.data
+                tensor = param.data
+
+            assert s_tensor.shape == tensor.shape, (
+                f"mismatch shape, s_tensor: {s_tensor.shape}, tensor: {tensor.shape}"
+            )
+
+            if param.requires_grad:
+                s_tensor.sub_(one_minus_decay * (s_tensor - tensor.to(s_tensor.dtype)))
+            else:
+                s_tensor.copy_(tensor)
+
+    def copy_to(self, parameters: Iterable[torch.nn.Parameter]) -> None:
+        """
+        Copy current averaged parameters into given collection of parameters.
+
+        Args:
+            parameters: Iterable of `torch.nn.Parameter`; the parameters to be
+                updated with the stored moving averages. If `None`, the parameters with which this
+                `ExponentialMovingAverage` was initialized will be used.
+        """
+        parameters = list(parameters)
+        for s_param, param in zip(self.model.parameters(), parameters):
+            param.data.copy_(s_param.to(param.device).data)
+
+    def to(self, device=None, dtype=None) -> None:
+        r"""Move internal buffers of the ExponentialMovingAverage to `device`.
+
+        Args:
+            device: like `device` argument to `torch.Tensor.to`
+        """
+        # .to() on the tensors handles None correctly
+        self.model = self.model.to(device=device, dtype=dtype)
+
+    def state_dict(self) -> dict:
+        r"""
+        Returns the state of the ExponentialMovingAverage as a dict. This method is used by accelerate during
+        checkpointing to save the ema state dict.
+        """
+        # Following PyTorch conventions, references to tensors are returned:
+        # "returns a reference to the state and not its copy!" -
+        # https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict
+        return {
+            "decay": self.decay,
+            "min_decay": self.min_decay,
+            "optimization_step": self.optimization_step,
+            "update_after_step": self.update_after_step,
+            "use_ema_warmup": self.use_ema_warmup,
+            "inv_gamma": self.inv_gamma,
+            "power": self.power,
+            "weight_file_prefix": self.weight_file_prefix,
+            "model": self.model.state_dict(),
+        }
+
+    def store(self, parameters: Iterable[torch.nn.Parameter]) -> None:
+        r"""
+        Args:
+        Save the current parameters for restoring later.
+            parameters: Iterable of `torch.nn.Parameter`; the parameters to be
+                temporarily stored.
+        """
+        self.temp_stored_params = [param.detach().cpu().clone() for param in parameters]
+
+    def restore(self, parameters: Iterable[torch.nn.Parameter]) -> None:
+        r"""
+        Args:
+        Restore the parameters stored with the `store` method. Useful to validate the model with EMA parameters without:
+        affecting the original optimization process. Store the parameters before the `copy_to()` method. After
+        validation (or model saving), use this to restore the former parameters.
+            parameters: Iterable of `torch.nn.Parameter`; the parameters to be
+                updated with the stored parameters. If `None`, the parameters with which this
+                `ExponentialMovingAverage` was initialized will be used.
+        """
+        if self.temp_stored_params is None:
+            raise RuntimeError("This ExponentialMovingAverage has no `store()`ed weights to `restore()`")
+        for c_param, param in zip(self.temp_stored_params, parameters):
+            param.data.copy_(c_param.data)
+
+        # Better memory-wise.
+        self.temp_stored_params = None
+
+    def load_state_dict(self, state_dict: dict) -> None:
+        r"""
+        Args:
+        Loads the ExponentialMovingAverage state. This method is used by accelerate during checkpointing to save the
+        ema state dict.
+            state_dict (dict): EMA state. Should be an object returned
+                from a call to :meth:`state_dict`.
+        """
+        # deepcopy, to be consistent with module API
+        state_dict = copy.deepcopy(state_dict)
+
+        self.decay = state_dict.get("decay", self.decay)
+        if self.decay < 0.0 or self.decay > 1.0:
+            raise ValueError("Decay must be between 0 and 1")
+
+        self.min_decay = state_dict.get("min_decay", self.min_decay)
+        if not isinstance(self.min_decay, float):
+            raise ValueError("Invalid min_decay")
+
+        self.optimization_step = state_dict.get("optimization_step", self.optimization_step)
+        if not isinstance(self.optimization_step, int):
+            raise ValueError("Invalid optimization_step")
+
+        self.update_after_step = state_dict.get("update_after_step", self.update_after_step)
+        if not isinstance(self.update_after_step, int):
+            raise ValueError("Invalid update_after_step")
+
+        self.use_ema_warmup = state_dict.get("use_ema_warmup", self.use_ema_warmup)
+        if not isinstance(self.use_ema_warmup, bool):
+            raise ValueError("Invalid use_ema_warmup")
+
+        self.inv_gamma = state_dict.get("inv_gamma", self.inv_gamma)
+        if not isinstance(self.inv_gamma, (float, int)):
+            raise ValueError("Invalid inv_gamma")
+
+        self.power = state_dict.get("power", self.power)
+        if not isinstance(self.power, (float, int)):
+            raise ValueError("Invalid power")
+
+        self.weight_file_prefix = state_dict.get("weight_file_prefix", self.weight_file_prefix)
+        if not isinstance(self.weight_file_prefix, (str)):
+            raise ValueError("Invalid weight_file_prefix")
+
+        model_state_dict = state_dict.get("model", None)
+        if model_state_dict is not None:
+            self.model.load_state_dict(model_state_dict)

Helios/_DEV/helios/utils/create_ema_zero3_lora.py

@@ -0,0 +1,336 @@
+import copy
+import json
+import os
+import time
+
+import deepspeed
+import torch
+from peft import LoraConfig, set_peft_model_state_dict
+from peft.utils import get_peft_model_state_dict
+
+from diffusers.training_utils import _collate_lora_metadata, free_memory
+from diffusers.utils import convert_unet_state_dict_to_peft
+
+from ..pipelines.pipeline_helios import HeliosPipeline
+from ..utils.create_ema_zero3 import EMAModel_Zero3, _z3_params_to_fetch
+from ..utils.utils_base import NORM_LAYER_PREFIXES, load_extra_components, save_extra_components
+
+
+GB = 1024 * 1024 * 1024
+
+
+# Adapted from diffusers-style ema https://github.com/huggingface/diffusers/blob/main/src/diffusers/training_utils.py#L263
+class EMAModel_Zero3_LoRA(EMAModel_Zero3):
+    """
+    Exponential Moving Average of models weights
+    """
+
+    def __init__(
+        self,
+        *args,
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+
+    @classmethod
+    def from_pretrained(
+        cls, args, path, model_cls, lora_config, transformer_additional_kwargs={}
+    ) -> "EMAModel_Zero3_LoRA":
+        model = model_cls.from_pretrained(
+            args.model_config.transformer_model_name_or_path,
+            subfolder=args.model_config.subfolder or "transformer",
+            transformer_additional_kwargs=transformer_additional_kwargs,
+        )
+        model.add_adapter(lora_config)
+
+        # ------------- load lora -------------
+        lora_state_dict = HeliosPipeline.lora_state_dict(path)
+        model_state_dict = {
+            f"{k.replace('transformer.', '')}": v for k, v in lora_state_dict.items() if k.startswith("transformer.")
+        }
+        model_state_dict = convert_unet_state_dict_to_peft(model_state_dict)
+        incompatible_keys = set_peft_model_state_dict(model, model_state_dict, adapter_name="default")
+        if incompatible_keys is not None:
+            # check only for unexpected keys
+            unexpected_keys = getattr(incompatible_keys, "unexpected_keys", None)
+            if unexpected_keys:
+                accelerator.print(
+                    f"Loading adapter weights from state_dict led to unexpected keys not found in the model: "
+                    f" {unexpected_keys}. "
+                )
+
+        if args.model_config.train_norm_layers:
+            model_norm_state_dict = {
+                k: v
+                for k, v in lora_state_dict.items()
+                if k.startswith("transformer.") and any(norm_k in k for norm_k in NORM_LAYER_PREFIXES)
+            }
+            model._transformer_norm_layers = HeliosPipeline._load_norm_into_transformer(
+                model_norm_state_dict,
+                transformer=model,
+                discard_original_layers=False,
+            )
+        # ------------- load lora -------------
+
+        # ------------- load extra components -------------
+        load_extra_components(args, model, os.path.join(path, "transformer_partial.pth"))
+        # ------------- load extra components -------------
+
+        ema_model = cls(model, model_cls=model_cls, model_config=model.config)
+
+        with open(os.path.join(path, "ema_kwargs.json"), "r") as f:
+            ema_kwargs = json.load(f)
+        ema_model.load_state_dict(ema_kwargs)
+
+        return ema_model
+
+    def save_pretrained(
+        self, args, path, pretrained_name_or_path, lora_config, transformer_additional_kwargs={}, transformer_cpu=None
+    ):
+        if self.model_cls is None:
+            raise ValueError("`save_pretrained` can only be used if `model_cls` was defined at __init__.")
+
+        if self.model_config is None:
+            raise ValueError("`save_pretrained` can only be used if `model_config` was defined at __init__.")
+
+        rank = int(os.getenv("RANK", "0"))
+
+        model_to_save = self.model.module if hasattr(self.model, "module") else self.model
+        model_state_dict = {}
+        for k, v in model_to_save.named_parameters():
+            # only gather z3 params
+            params_to_fetch = _z3_params_to_fetch([v])
+            with deepspeed.zero.GatheredParameters(params_to_fetch, enabled=len(params_to_fetch) > 0):
+                if rank == 0:
+                    model_state_dict[k] = v.data.cpu().clone()
+
+        if rank == 0:
+            state_dict = self.state_dict()
+            state_dict.pop("model")
+
+            os.makedirs(path, exist_ok=True)
+            print(f"state_dict, {state_dict.keys()}")
+            t_start = time.perf_counter()
+            print(f"[{t_start:.4f}] self.model_cls.from_pretrained")
+
+            print("self.model_cls", self.model_cls)
+            if transformer_cpu is None:
+                model = self.model_cls.from_pretrained(
+                    pretrained_name_or_path,
+                    subfolder=args.model_config.subfolder or "transformer",
+                    transformer_additional_kwargs=transformer_additional_kwargs,
+                )
+                model.add_adapter(lora_config)
+            else:
+                model = transformer_cpu
+            t1 = time.perf_counter()
+            print(f"[{t1:.4f}] after self.model_cls.from_pretrained (耗时 {t1 - t_start:.4f} 秒)")
+
+            miss, unexp = model.load_state_dict(model_state_dict, strict=False)
+            assert len(unexp) == 0, f"miss: {miss}; unexp: {unexp}"
+
+            # ------------- only save lora -------------
+            config_dict = model.config if hasattr(model, "config") else self.model_config
+            with open(os.path.join(path, "config.json"), "w") as f:
+                json.dump(config_dict, f, indent=2)
+
+            modules_to_save = {}
+            transformer_lora_layers_to_save = get_peft_model_state_dict(model)
+            if args.model_config.train_norm_layers:
+                transformer_norm_layers_to_save = {
+                    f"transformer.{name}": param
+                    for name, param in model.named_parameters()
+                    if any(k in name for k in NORM_LAYER_PREFIXES)
+                }
+                transformer_lora_layers_to_save = {
+                    **transformer_lora_layers_to_save,
+                    **transformer_norm_layers_to_save,
+                }
+            modules_to_save["transformer"] = model
+            HeliosPipeline.save_lora_weights(
+                path,
+                transformer_lora_layers=transformer_lora_layers_to_save,
+                **_collate_lora_metadata(modules_to_save),
+            )
+            # ------------- only save lora -------------
+
+            # ------------- only save extra components -------------
+            save_extra_components(args, model_state_dict=model_state_dict, output_dir=path)
+            # ------------- only save extra components -------------
+
+            t2 = time.perf_counter()
+            print(f"[{t2:.4f}] after save_pretrained (耗时 {t2 - t1:.4f} 秒)")
+
+            print(f"[{t2:.4f}] 总耗时 {t2 - t_start:.4f} 秒")
+
+            with open(os.path.join(path, "ema_kwargs.json"), "w") as f:
+                json.dump(state_dict, f, indent=2)
+
+        model = None
+        transformer_cpu = None
+        params_to_fetch = None
+        state_dict = None
+        model_state_dict = None
+        transformer_lora_layers_to_save = None
+        transformer_norm_layers_to_save = None
+        modules_to_save = None
+        del model
+        del transformer_cpu
+        del params_to_fetch
+        del state_dict
+        del model_state_dict
+        del transformer_lora_layers_to_save
+        del transformer_norm_layers_to_save
+        del modules_to_save
+        free_memory()
+
+        print(f"rank {rank} done saved ema!")
+
+
+def gather_zero3ema(accelerator, ema_model):
+    model_to_save = ema_model.model.module if hasattr(ema_model.model, "module") else ema_model.model
+    model_state_dict = {}
+    for k, v in model_to_save.named_parameters():
+        # only gather z3 params
+        params_to_fetch = _z3_params_to_fetch([v])
+        with deepspeed.zero.GatheredParameters(params_to_fetch, enabled=len(params_to_fetch) > 0):
+            # if accelerator.process_index == 0:
+            model_state_dict[k] = v.data.cpu().clone()
+    return model_state_dict
+
+
+def create_ema_model(
+    accelerator,
+    args,
+    transformer,
+    resume_checkpoint_path,
+    model_cls,
+    model_config,
+    ds_config=None,
+    lora_config=None,
+    update_after_step=0,
+    transformer_additional_kwargs={},
+):
+    ds_config["train_micro_batch_size_per_gpu"] = args.training_config.train_batch_size
+    ds_config["fp16"]["enabled"] = False
+    ds_config["bf16"]["enabled"] = False
+    ds_config["gradient_accumulation_steps"] = args.training_config.gradient_accumulation_steps
+    ds_config["train_batch_size"] = (
+        args.training_config.train_batch_size
+        * args.training_config.gradient_accumulation_steps
+        * accelerator.num_processes
+    )
+    accelerator.print(f"EMA deepspeed config {ds_config}")
+
+    if resume_checkpoint_path:
+        ema_model = EMAModel_Zero3_LoRA.from_pretrained(
+            args=args,
+            path=resume_checkpoint_path,
+            model_cls=model_cls,
+            lora_config=lora_config,
+            transformer_additional_kwargs=transformer_additional_kwargs,
+        )
+        accelerator.print(f"Successully resume EMAModel_Zero3 from {resume_checkpoint_path}")
+    else:
+        ema_model = EMAModel_Zero3_LoRA(
+            copy.deepcopy(transformer),
+            decay=args.training_config.ema_decay,
+            model_cls=model_cls,
+            model_config=model_config,
+            update_after_step=update_after_step,
+        )
+        accelerator.print(f"EMAModel_Zero3 finish, memory_allocated: {torch.cuda.memory_allocated() / GB:.2f} GB")
+        accelerator.print("Successully deepcopy EMAModel_Zero3 from model")
+    ema_model.model, _, _, _ = deepspeed.initialize(
+        model=ema_model.model, config_params=ds_config, distributed_port=args.training_config.ema_zero3_port
+    )
+    return ema_model
+
+
+def create_ema_final(
+    accelerator,
+    args,
+    transformer_cpu,
+    model_cls,
+    ds_config,
+    transformer_lora_config,
+    update_after_step=0,
+    resume_checkpoint_path=None,
+    transformer_additional_kwargs=None,
+):
+    ema_transformer = create_ema_model(
+        accelerator,
+        args=args,
+        transformer=transformer_cpu,
+        resume_checkpoint_path=resume_checkpoint_path,
+        model_cls=model_cls,
+        model_config=transformer_cpu.config,
+        ds_config=ds_config,
+        lora_config=transformer_lora_config,
+        update_after_step=update_after_step,
+        transformer_additional_kwargs=transformer_additional_kwargs,
+    )
+    free_memory()
+    return ema_transformer
+
+
+if __name__ == "__main__":
+    import json
+    import sys
+    from argparse import Namespace
+
+    import deepspeed
+    from accelerate import Accelerator
+
+    sys.path.append("../../")
+    from helios.modules.transformer_helios import HeliosTransformer3DModel
+
+    args = Namespace()
+    args.data_config = Namespace()
+    args.training_config = Namespace()
+    args.model_config = Namespace()
+    args.training_config.train_batch_size = 1
+    args.training_config.gradient_accumulation_steps = 1
+    args.training_config.ema_decay = 0.999
+    args.training_config.ema_zero3_port = 10543
+    args.model_config.train_norm_layers = False
+    args.model_config.transformer_model_name_or_path = "Wan-AI/Wan2.1-T2V-1.3B-Diffusers"
+    args.training_config.ema_deepspeed_config_file = "../../scripts/accelerate_configs/zero3.json"
+    resume_checkpoint_path = None
+
+    output_dir = "temp"
+    accelerator = Accelerator()
+
+    model_cls = HeliosTransformer3DModel
+    transformer = model_cls.from_pretrained(
+        args.model_config.transformer_model_name_or_path, subfolder="transformer", torch_dtype=torch.bfloat16
+    )
+    target_modules = set()
+    for name, module in transformer.named_modules():
+        if isinstance(module, torch.nn.Linear):
+            target_modules.add(name)
+    target_modules = list(target_modules)
+    lora_config = LoraConfig(
+        r=256,
+        lora_alpha=256,
+        # target_modules=["to_k", "to_v", "to_q", "to_out.0"],
+        target_modules=target_modules,
+        lora_dropout=0.0,
+    )
+    transformer.add_adapter(lora_config)
+
+    transformer_cpu = copy.deepcopy(transformer)
+    transformer.to(device=accelerator.device, dtype=torch.bfloat16)
+    accelerator.print(f"Load model finish, memory_allocated: {torch.cuda.memory_allocated() / GB:.2f} GB")
+
+    with open(args.training_config.ema_deepspeed_config_file, "r") as f:
+        ds_config = json.load(f)
+
+    ema_transformer = create_ema_final(
+        accelerator=accelerator,
+        args=args,
+        transformer_cpu=transformer_cpu,
+        model_cls=model_cls,
+        ds_config=ds_config,
+        transformer_lora_config=lora_config,
+    )

Helios/_DEV/tools/merge_lora_for_helios.py

@@ -0,0 +1,55 @@
+import sys
+from argparse import Namespace
+
+
+sys.path.append("../")
+from helios.modules.transformer_helios import HeliosTransformer3DModel
+from helios.pipelines.pipeline_helios import HeliosPipeline
+from helios.utils.utils_base import load_extra_components
+
+
+transformer_additional_kwargs = {
+    "has_multi_term_memory_patch": True,
+    "zero_history_timestep": True,
+    "guidance_cross_attn": True,
+    "restrict_self_attn": False,
+    "is_train_restrict_lora": False,
+    "restrict_lora": False,
+    "restrict_lora_rank": 128,
+}
+
+transformer = HeliosTransformer3DModel.from_pretrained(
+    "1_formal_ckpts/ablation_stage3_2_mid-train_v4_e2500-ema",
+    subfolder="transformer",
+    transformer_additional_kwargs=transformer_additional_kwargs,
+)
+pipe = HeliosPipeline.from_pretrained(
+    "Wan-AI/Wan2.1-T2V-14B-Diffusers",
+    transformer=transformer,
+)
+
+pipe.load_lora_weights(
+    "ablation_stage3_3_post-train-emergency_only-gan/checkpoint-2000/model_ema/pytorch_lora_weights.safetensors",
+    adapter_name="default",
+)
+pipe.set_adapters(["default"], adapter_weights=[1.0])
+
+
+args = Namespace()
+if not hasattr(args, "training_config"):
+    args.training_config = Namespace()
+args.training_config.is_enable_stage1 = True
+args.training_config.restrict_self_attn = True
+args.training_config.is_amplify_history = True
+args.training_config.is_use_gan = True
+load_extra_components(
+    args,
+    transformer,
+    "ablation_stage3_3_post-train-emergency_only-gan/checkpoint-2000/model_ema/transformer_partial.pth",
+)
+
+pipe.fuse_lora()
+pipe.unload_lora_weights()
+pipe.transformer.save_pretrained(
+    "1_formal_ckpts/ablation_stage3_3_post-train-emergency_only-gan_e2000-ema/transformer"
+)

Helios/_DEV/tools/merge_lora_for_wan.py

@@ -0,0 +1,55 @@
+import sys
+from argparse import Namespace
+
+
+sys.path.append("../")
+from helios.modules.transformer_helios import HeliosTransformer3DModel
+from helios.pipelines.pipeline_helios import HeliosPipeline
+from helios.utils.utils_base import load_extra_components
+
+
+transformer_additional_kwargs = {
+    "has_multi_term_memory_patch": False,
+    "zero_history_timestep": False,
+    "guidance_cross_attn": False,
+    "restrict_self_attn": False,
+    "is_train_restrict_lora": False,
+    "restrict_lora": False,
+    "restrict_lora_rank": 128,
+}
+
+transformer = HeliosTransformer3DModel.from_pretrained(
+    "Wan-AI/Wan2.1-T2V-14B-Diffusers",
+    subfolder="transformer",
+    transformer_additional_kwargs=transformer_additional_kwargs,
+)
+pipe = HeliosPipeline.from_pretrained(
+    "Wan-AI/Wan2.1-T2V-14B-Diffusers",
+    transformer=transformer,
+)
+
+pipe.load_lora_weights(
+    "ablation_14B_single-res_length-21_t2v_rank128_bs128_new/checkpoint-1000/pytorch_lora_weights.safetensors",
+    adapter_name="default",
+)
+pipe.set_adapters(["default"], adapter_weights=[1.0])
+
+
+args = Namespace()
+if not hasattr(args, "training_config"):
+    args.training_config = Namespace()
+args.training_config.is_enable_stage1 = True
+args.training_config.restrict_self_attn = True
+args.training_config.is_amplify_history = True
+args.training_config.is_use_gan = True
+load_extra_components(
+    args,
+    transformer,
+    "ablation_14B_single-res_length-21_t2v_rank128_bs128_new/checkpoint-1000/transformer_partial.pth",
+)
+
+pipe.fuse_lora()
+pipe.unload_lora_weights()
+pipe.transformer.save_pretrained(
+    "1_formal_ckpts/ablation_14B_single-res_length-21_t2v_rank128_bs128_new_e1000/transformer"
+)

Helios/_DEV/tools/remove_ckpt.sh

@@ -0,0 +1,5 @@
+DIR="./"
+find "$DIR" -type d -name "pytorch_model" -exec rm -rf {} +
+find "$DIR" -type d -name "distributed_checkpoint" -exec rm -rf {} +
+find "$DIR" -type f -name "random_states_*" -exec rm -f {} +
+find "$DIR" -type f -name "scheduler.bin*" -exec rm -f {} +

Helios/_DEV/tools/requirements_old.txt

@@ -0,0 +1,42 @@
+torch==2.7.1
+torchvision==0.22.1
+torchaudio==2.7.1
+triton==3.3.1
+# diffusers==0.36.0
+# transformers==4.57.6
+# sentence-transformers==5.2.3
+# git+https://github.com/SHYuanBest/diffusers.git@test
+# git+https://github.com/huggingface/transformers.git
+# git+https://github.com/huggingface/sentence-transformers.git
+transformers==4.57.6
+tokenizers==0.22.0
+sentence-transformers==2.2.2
+accelerate==1.12.0
+deepspeed==0.18.4
+peft==0.17.1
+hf-xet==1.1.5
+huggingface-hub==0.36.0
+zstandard==0.25.0
+wandb==0.23.0
+video-reader-rs==0.4.1
+gradio==5.44.1
+gradio_client==1.12.1
+numpy<2.0.0
+opencv-python
+gradio
+spaces
+moviepy
+imageio-ffmpeg
+ftfy
+Jinja2
+einops
+nvitop
+packaging
+ninja
+omegaconf
+mpi4py
+hf-doc-builder
+torchdata
+kernels
+loguru
+tf_keras

Helios/_DEV/tools/requirements_raw.txt

@@ -0,0 +1,539 @@
+absl-py==2.4.0
+accelerate==1.12.0
+addict==2.4.0
+aiofiles==22.1.0
+aiohttp==3.8.4
+aiosignal==1.3.1
+aiosqlite==0.22.1
+altair==5.5.0
+annotated-doc==0.0.4
+annotated-types==0.7.0
+antlr4-python3-runtime==4.9.3
+anyio==4.9.0
+apex @ file:///apex
+argon2-cffi==25.1.0
+argon2-cffi-bindings==25.1.0
+arrow==1.4.0
+asn1crypto==1.5.1
+asr-eval-tool @ file:///tmp/py_pkg.asr_eval_tool/dist/asr_eval_tool-1.0.0.125-py3-none-any.whl#sha256=505809aedcce9d18d6d69fe9b4590e3e8b1064bf0f13effcd58ce761a1e9128e
+asttokens==3.0.0
+astunparse==1.6.3
+async-timeout==4.0.2
+attrs==23.1.0
+audioread==3.0.1
+auraloss==0.4.0
+azure-core==1.35.0
+azure-identity==1.23.0
+azure-storage-blob==12.25.1
+azure-storage-file-datalake==12.20.0
+babel==2.18.0
+bcrypt==4.3.0
+beautifulsoup4==4.13.4
+bidict==0.23.1
+bigvgan==2.4.1
+bitsandbytes==0.47.0
+black==26.1.0
+bleach==6.3.0
+blessed==1.21.0
+blinker==1.9.0
+blis==0.7.11
+boto3==1.39.4
+botocore==1.39.4
+braceexpand==0.1.7
+Brotli==1.1.0
+bs4==0.0.1
+bson==0.5.10
+byted-bumi @ http://luban-source.byted.org/repository/scm/seed.speech.bumi_2.3.0.40.tar.gz#sha256=88970040e733c1f0fa408537939b6335bc556d85cecd755bd1ab7f7b80939f16
+byted-dataloader==0.5.5
+byted-encrypted-hdfs==0.5.5
+byted-hdfs-io==0.3.16
+byted-iceberg==0.2.257
+byted-jarvis==1.0.27
+byted-kms-encryption==0.0.6
+byted-kmsv2inner==0.1.20
+byted-lafka-internal==1.4.16rc1
+byted-OmniDispatcher==1.0.0.37
+byted-omnistore==1.0.1
+byted-seed-models==1.1.3
+byted-streaming==1.1.206
+byted-unified-io==0.0.20
+byted-wandb==0.13.93
+byted_huggingface_hub==0.130.5
+byted_remote_ikernel==0.4.8
+bytedance-context==0.7.1
+bytedance-metrics==0.5.2
+bytedance.ckpt_io_metrics==0.0.27
+bytedance.easycycle==1.1.37
+bytedance.hdfs-stdenv==0.0.40
+bytedance.modelhub==0.0.103
+bytedance.ndtimeline==2.3.1
+bytedance.servicediscovery==0.1.2
+bytedbackgrounds==0.0.6
+byteddatabus==1.0.6
+byteddps==0.1.2
+bytedenv==0.6.2
+bytedeuler==0.42.1
+bytedfeather==0.3.5
+bytedidgenerator==1.0.5
+bytedkafka==0.2.9
+bytedkms==3.2.9
+bytedkmsv2==0.10.59
+bytedlogger==0.15.1
+bytedlogid==0.2.1
+bytedmemfd==0.2
+bytedmetrics==0.9.0
+bytedmoxing @ https://luban-source.byted.org/repository/scm/search.nlp.moxing_py_1.0.0.21.tar.gz#sha256=10a8d5ad88b1f12dcecd3350d1a7f414f6af966734a7b155c389baf5d5c1872b
+bytedpymongo==2.0.5
+bytedrh2==1.18.11
+bytedservicediscovery==0.18.0
+bytedsinfmetacenter==1.4.3
+bytedtcc==1.4.4
+bytedtitan @ http://luban-source.byted.org/repository/scm/data.aml.titan_1.0.0.151.tar.gz
+bytedtos==1.1.16
+bytedtrace==0.3.0
+bytedzti==1.0.15
+bytedztijwthelper==0.0.22
+bytedztispiffe==0.0.16
+cachetools==5.5.2
+catalogue==2.0.10
+certifi==2022.9.24
+cffi==1.17.1
+chardet==5.1.0
+charset-normalizer==3.0.1
+circuitbreaker==2.1.3
+click==8.2.1
+colorama==0.4.6
+comm==0.2.3
+confection==0.1.5
+contourpy==1.0.7
+cramjam==2.10.0
+crcmod==1.7
+cryptography==39.0.2
+cxxfilt==0.3.0
+cycler==0.11.0
+cymem==2.0.11
+Cython==3.1.2
+dataclasses-json==0.6.7
+datasets==4.0.0
+dbus-python==1.3.2
+debugpy==1.8.14
+decorator==5.2.1
+decord==0.6.0
+deepspeed==0.18.4
+defusedxml==0.7.1
+Deprecated==1.2.18
+-e git+https://github.com/huggingface/diffusers-new-model-addition-helios.git@50b565af2edd0574aa6678aec2d61268dd85b4a2#egg=diffusers
+dill==0.3.8
+distlib==0.3.9
+distro==1.8.0
+distro-info==1.5+deb12u1
+dnspython==2.7.0
+docker-pycreds==0.4.0
+docstring_parser==0.16
+ecdsa==0.19.1
+editdistance==0.8.1
+einops==0.6.0
+emoji==2.14.0
+entrypoints==0.4
+et_xmlfile==2.0.0
+executing==2.2.0
+fairscale==0.4.13
+fastapi==0.116.1
+fastavro==1.11.1
+fastjsonschema==2.21.2
+ffmpy==0.6.0
+filelock==3.18.0
+flash-attn==2.5.8
+flash-attn-3==3.0.0b1
+Flask==2.3.3
+flatbuffers==25.2.10
+fonttools==4.38.0
+fqdn==1.5.1
+frozenlist==1.3.3
+fsspec==2023.6.0
+ftfy==6.1.1
+func-timeout==4.3.5
+fvcore==0.1.5.post20221221
+gast==0.6.0
+gensim==4.3.2
+gevent==22.10.2
+gitdb==4.0.12
+GitPython==3.1.44
+google-api-core==2.25.1
+google-auth==2.40.3
+google-auth-oauthlib==0.4.6
+google-cloud-core==2.4.3
+google-cloud-storage==2.10.0
+google-crc32c==1.7.1
+google-pasta==0.2.0
+google-resumable-media==2.7.2
+googleapis-common-protos==1.70.0
+gpustat==1.1.1
+GPUtil==1.4.0
+gradio==6.8.0
+gradio_client==2.2.0
+greenlet==3.2.3
+groovy==0.1.2
+grpcio==1.73.1
+gunicorn==20.1.0
+h11==0.16.0
+h5py==3.14.0
+hf-doc-builder==0.5.0
+hf-xet==1.3.2
+hjson==3.1.0
+httpcore==1.0.9
+httplib2==0.20.4
+httpx==0.28.1
+huggingface_hub==1.4.1
+idna==3.3
+ImageIO==2.37.2
+imageio-ffmpeg==0.6.0
+imagesize==1.4.1
+importlib-metadata==6.7.0
+importlib-resources==5.12.0
+iniconfig==2.1.0
+iopath==0.1.10
+iotop==0.6
+ipaddress==1.0.23
+ipdb==0.13.13
+ipykernel==6.29.5
+ipython==9.10.0
+ipython-genutils==0.2.0
+ipython_pygments_lexers==1.1.1
+ipywidgets==8.1.8
+isodate==0.7.2
+isoduration==20.11.0
+itsdangerous==2.2.0
+jedi==0.19.2
+Jinja2==3.1.3
+jiter==0.10.0
+jmespath==1.0.1
+joblib==1.5.1
+json5==0.13.0
+jsonargparse==4.14.0
+jsonpatch==1.33
+jsonpath-ng==1.5.3
+jsonpickle==3.0.4
+jsonpointer==3.0.0
+jsonschema==4.24.0
+jsonschema-specifications==2025.4.1
+jupyter==1.1.1
+jupyter-client==7.0.0
+jupyter-console==6.6.3
+jupyter-events==0.12.0
+jupyter-ydoc==0.2.5
+jupyter_core==5.9.1
+jupyter_server==2.17.0
+jupyter_server_fileid==0.9.3
+jupyter_server_terminals==0.5.4
+jupyter_server_ydoc==0.8.0
+jupyterlab==3.6.4
+jupyterlab_pygments==0.3.0
+jupyterlab_server==2.28.0
+jupyterlab_widgets==3.0.16
+keras==3.10.0
+kernels==0.12.1
+kiwisolver==1.4.4
+langchain==0.1.19
+langchain-community==0.0.38
+langchain-core==0.1.53
+langchain-text-splitters==0.0.2
+langcodes==3.5.0
+langsmith==0.1.147
+language_data==1.3.0
+lazr.restfulclient==0.14.5
+lazr.uri==1.0.6
+lazy_loader==0.4
+libclang==18.1.1
+librosa==0.11.0
+liger_kernel==0.6.2
+linkify-it-py==2.0.3
+llvmlite==0.44.0
+loguru==0.7.3
+lpips==0.1.4
+lxml==6.0.0
+magi-attention @ file:///MagiAttention
+marisa-trie==1.2.1
+Markdown==3.8.2
+markdown-it-py==2.2.0
+MarkupSafe==2.1.5
+marshmallow==3.26.1
+matplotlib==3.7.0
+matplotlib-inline==0.1.7
+mdit-py-plugins==0.3.3
+mdurl==0.1.2
+miscreant==0.3.0
+mistune==3.2.0
+ml_dtypes==0.5.4
+mmcv==2.0.0
+mmengine==0.10.7
+mmh3==4.1.0
+mmhash3==3.0.1
+mock==5.2.0
+modelscope==1.34.0
+moviepy==2.2.1
+mpi4py==4.1.1
+mpmath==1.3.0
+msal==1.32.3
+msal-extensions==1.3.1
+msgpack==1.0.8
+multidict==6.0.4
+multiprocess==0.70.16
+murmurhash==1.0.13
+mypy_extensions==1.1.0
+namex==0.1.0
+narwhals==1.46.0
+nbclassic==1.3.3
+nbclient==0.10.4
+nbconvert==7.17.0
+nbformat==5.10.4
+nest-asyncio==1.6.0
+networkx==3.3
+ninja==1.11.1.1
+nlg-eval @ git+https://github.com/Maluuba/nlg-eval.git@2ab4528fad5548315cf61e40c2249fec8c8ad233
+nltk==3.8.1
+nnAudio==0.3.3
+notebook==6.5.7
+notebook_shim==0.2.4
+numba==0.61.2
+numpy==1.26.4
+nvidia-cublas-cu12==12.8.3.14
+nvidia-cuda-cupti-cu12==12.8.57
+nvidia-cuda-nvrtc-cu12==12.8.61
+nvidia-cuda-runtime-cu12==12.8.57
+nvidia-cudnn-cu12==9.7.1.26
+nvidia-cufft-cu12==11.3.3.41
+nvidia-cufile-cu12==1.13.0.11
+nvidia-curand-cu12==10.3.9.55
+nvidia-cusolver-cu12==11.7.2.55
+nvidia-cusparse-cu12==12.5.7.53
+nvidia-cusparselt-cu12==0.6.3
+nvidia-ml-py==13.580.65
+nvidia-nccl-cu12==2.26.2
+nvidia-nvjitlink-cu12==12.8.61
+nvidia-nvtx-cu12==12.8.55
+nvitop==1.6.2
+oauthlib==3.2.2
+oci==2.155.1
+omegaconf==2.3.0
+onnx==1.16.1
+openai==1.105.0
+opencv-python==4.7.0.72
+openpyxl==3.1.2
+opt_einsum==3.4.0
+optree==0.16.0
+orjson==3.10.18
+overrides==7.7.0
+packaging==24.2
+pandas==2.3.1
+pandocfilters==1.5.1
+panther-gpu @ file:///torch/panther_gpu-1.7.14-cp311-cp311-linux_x86_64.whl#sha256=e00952ea8d43da2cfca9ed9c15d084d302d3fac4c2d5e2f9565c8d9b2ff9881f
+paramiko==3.5.1
+parso==0.8.4
+pathlib2==2.3.7.post1
+pathlib_abc==0.1.1
+pathspec==1.0.4
+pathtools==0.1.2
+pathy==0.11.0
+pdfminer.six==20231228
+pdfplumber==0.11.4
+peft==0.18.1
+pesq==0.0.4
+pexpect==4.8.0
+pillow==11.3.0
+pillow_heif==1.1.0
+platformdirs==4.3.8
+pluggy==1.6.0
+ply==3.11
+pooch==1.8.2
+portalocker==3.2.0
+preshed==3.0.10
+prettytable==3.10.0
+proglog==0.1.12
+prometheus_client==0.24.1
+promise==2.3
+prompt_toolkit==3.0.51
+propcache==0.3.2
+proto-plus==1.26.1
+protobuf==6.33.5
+psutil==5.9.4
+ptflops==0.7.4
+ptyprocess==0.7.0
+pure_eval==0.2.3
+py==1.11.0
+py-cpuinfo==9.0.0
+py-spy==0.3.14
+pyahocorasick==2.1.0
+pyarrow==21.0.0
+pyasn1==0.6.1
+pyasn1_modules==0.4.2
+pybind11==2.12.0
+pycocoevalcap==1.2
+pycocotools==2.0.6
+pycparser==2.22
+pycryptodomex==3.23.0
+pydantic==2.11.7
+pydantic_core==2.33.2
+pydub==0.25.1
+Pygments==2.19.2
+PyGObject==3.42.2
+PyJWT==2.10.1
+PyNaCl==1.5.0
+pynndescent==0.5.13
+pyope==0.2.2
+pyOpenSSL==23.2.0
+pyparsing==3.0.9
+pypdfium2==4.30.1
+pyPEG2==2.15.2
+pypinyin==0.48.0
+pytest==6.2.5
+python-apt==2.6.0
+python-consul==1.1.0
+python-dateutil==2.8.2
+python-dotenv==1.2.1
+python-engineio==4.12.2
+python-etcd==0.4.5
+python-jose==3.5.0
+python-json-logger==4.0.0
+python-multipart==0.0.20
+python-snappy==0.7.3
+python-socketio==5.13.0
+pytokens==0.4.1
+pytz==2025.2
+pywsd==1.2.5
+PyYAML==6.0
+pyzmq==27.1.0
+rapidfuzz==3.7.0
+redis==4.5.5
+referencing==0.36.2
+regex==2022.10.31
+requests==2.32.5
+requests-oauthlib==2.0.0
+requests-toolbelt==1.0.0
+rfc3339-validator==0.1.4
+rfc3986-validator==0.1.1
+rich==13.9.4
+rpds-py==0.26.0
+rsa==4.9.1
+ruff==0.12.11
+s3transfer==0.13.0
+sacrebleu==2.4.3
+safehttpx==0.1.7
+safetensors==0.5.3
+schedule==1.2.2
+scikit-learn==1.2.2
+scipy==1.10.1
+semantic-version==2.10.0
+Send2Trash==2.1.0
+sentence-transformers @ git+https://github.com/huggingface/sentence-transformers.git@58900864d51cde2f918885587709b2466938422c
+sentencepiece==0.2.1
+sentry-sdk==2.32.0
+setproctitle==1.3.6
+shapely==2.0.2
+shellingham==1.5.4
+shortuuid==1.0.13
+shyaml==0.6.2
+simple-websocket==1.1.0
+six==1.16.0
+smart-open==6.4.0
+smmap==5.0.2
+sniffio==1.3.1
+sortedcontainers==2.4.0
+soundfile==0.13.1
+soupsieve==2.7
+sox==1.5.0
+soxbindings==1.2.3
+soxr==0.5.0.post1
+spaces==0.47.0
+spacy==3.5.1
+spacy-legacy==3.0.12
+spacy-loggers==1.0.5
+speech-evals @ file:///tmp/py_pkg.speech_evals/dist/speech_evals-1.0.0.34-py3-none-any.whl#sha256=521a1325b4d42fe67396f7d34b8daba0df225ba568a1cf35d517cd12d012f351
+SQLAlchemy==2.0.41
+srsly==2.5.1
+stack-data==0.6.3
+starlette==0.47.1
+subword-nmt==0.3.8
+sympy==1.13.3
+tabulate==0.9.0
+tbb==2022.2.0
+tcmlib==1.4.0
+tenacity==8.2.2
+tensorboard==2.20.0
+tensorboard-data-server==0.7.2
+tensorboard-plugin-wit==1.8.1
+tensorboardX==2.6.2.2
+tensorflow==2.20.0
+tensorflow-cpu==2.16.1
+tensorflow-io==0.30.0
+tensorflow-io-gcs-filesystem==0.30.0
+termcolor==3.1.0
+terminado==0.18.1
+terminaltables==3.1.10
+text-cutter @ https://luban-source.byted.org/repository/scm/search.nlp.libcut_py_2.3.0.52.tar.gz#sha256=c3689e2d0fa0323ef72a79eeb2adea7f3991513b87f6fa9ef0f8a66155737ce9
+tf_keras==2.20.1
+thinc==8.1.12
+threadpoolctl==3.6.0
+thrift2pyi==1.0.3
+thriftpy2==0.5.2
+timm==1.0.11
+tinycss2==1.4.0
+tokenizers==0.22.2
+toml==0.10.2
+tomlkit==0.13.3
+torch==2.7.1+cu128
+torchaudio==2.7.1+cu128
+torchcodec==0.5
+torchdata==0.11.0
+torchlibrosa==0.1.0
+torchvision==0.22.1+cu128
+tornado==6.5.1
+tox==3.28.0
+tqdm==4.67.1
+traitlets==5.14.3
+transformers @ git+https://github.com/huggingface/transformers.git@11b1906d5c0dae39c13270e47cc02c4cde70e548
+triton==3.3.1
+typer==0.24.1
+typer-slim==0.24.0
+typing-inspect==0.9.0
+typing-inspection==0.4.1
+typing_extensions==4.12.2
+tzdata==2025.2
+uc-micro-py==1.0.3
+umap-learn==0.5.4
+unattended-upgrades==0.1
+universal_pathlib==0.2.6
+uri-template==1.3.0
+urllib3==1.26.12
+uvicorn==0.35.0
+video_reader-rs==0.4.1
+virtualenv==20.31.2
+visdom==0.2.4
+wadllib==1.3.6
+wandb==0.23.0
+wasabi==1.1.3
+watchdog==6.0.0
+wcwidth==0.2.13
+webcolors==25.10.0
+webdataset==0.2.48
+webencodings==0.5.1
+websocket-client==1.8.0
+websockets==15.0.1
+Werkzeug==3.1.3
+widgetsnbextension==4.0.15
+wn==0.0.23
+word2number==1.1
+wrapt==1.17.2
+wsproto==1.2.0
+xxhash==3.5.0
+y-py==0.6.2
+yacs==0.1.8
+yapf==0.43.0
+yarl==1.8.2
+ypy-websocket==0.8.4
+zhon==1.1.5
+zipp==3.14.0
+zope.event==5.1
+zope.interface==7.2
+zstandard==0.25.0
+zstd==1.5.7.2

Helios/eval/0_get_aesthetic.py

@@ -0,0 +1,203 @@
+import argparse
+import glob
+import json
+import os
+import re
+
+import clip
+import pandas as pd
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from tqdm import tqdm
+
+from utils.utils import clip_transform, load_video
+
+
+BATCH_SIZE = 32
+
+
+def get_aesthetic_model(path_to_model):
+    """Load the aesthetic predictor model"""
+    m = nn.Linear(768, 1)
+    s = torch.load(path_to_model, map_location="cpu", weights_only=False)
+    m.load_state_dict(s)
+    m.eval()
+    return m
+
+
+def evaluate_aesthetic(aesthetic_model, clip_model, video_path, height=384, width=640, device="cuda"):
+    """Evaluate aesthetic quality for a single video"""
+    aesthetic_model.eval()
+    clip_model.eval()
+
+    # Load video frames
+    images = load_video(video_path, height=height, width=width)
+    image_transform = clip_transform(224)
+    aesthetic_scores_list = []
+
+    # Process in batches
+    for i in range(0, len(images), BATCH_SIZE):
+        image_batch = images[i : i + BATCH_SIZE]
+        image_batch = image_transform(image_batch)
+        image_batch = image_batch.to(device)
+
+        with torch.no_grad():
+            image_feats = clip_model.encode_image(image_batch).to(torch.float32)
+            image_feats = F.normalize(image_feats, dim=-1, p=2)
+            aesthetic_scores = aesthetic_model(image_feats).squeeze(dim=-1)
+
+        aesthetic_scores_list.append(aesthetic_scores)
+
+    # Combine all scores
+    aesthetic_scores = torch.cat(aesthetic_scores_list, dim=0)
+    normalized_aesthetic_scores = aesthetic_scores / 10.0
+    avg_score = torch.mean(normalized_aesthetic_scores, dim=0, keepdim=True)
+
+    return avg_score.item()
+
+
+def main(args):
+    baseline_name = os.path.basename(args.video_dir)
+    output_path = os.path.join(args.output_path, baseline_name)
+    output_json_path = os.path.join(output_path, "aesthetic_results.json")
+
+    # Set device
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Using device: {device}")
+
+    # Load CSV file
+    if not os.path.exists(args.input_csv):
+        raise FileNotFoundError(f"CSV file not found: {args.input_csv}")
+
+    df = pd.read_csv(args.input_csv)
+    df_dict = df.set_index("id").to_dict("index")
+
+    # Validate CSV columns
+    required_columns = ["id", "duration"]
+    for col in required_columns:
+        if col not in df.columns:
+            raise ValueError(f"CSV must contain '{col}' column. Found columns: {df.columns.tolist()}")
+
+    # Load existing results if available
+    existing_results = {}
+    if os.path.exists(output_json_path):
+        print(f"Found existing results at {output_json_path}, loading...")
+        with open(output_json_path, "r") as f:
+            existing_data = json.load(f)
+            for item in existing_data.get("per_video_results", []):
+                existing_results[item["id"]] = item
+        print(f"Loaded {len(existing_results)} existing results")
+
+    # Get all videos to process
+    video_files = glob.glob(os.path.join(args.video_dir, "*_*_ori*.mp4"))
+    video_files.sort(key=lambda x: int(re.search(r"(\d+)_", os.path.basename(x)).group(1)))
+    print(f"\nFound {len(video_files)} videos in directory")
+
+    # Check which videos need processing
+    results = []
+    scores = []
+    videos_to_process = []
+
+    for video_path in video_files:
+        video_name = os.path.basename(video_path)
+        parts = video_name.replace(".mp4", "").split("_")
+        video_id = int(parts[0])
+
+        if video_id not in df_dict:
+            print(f"Warning: Video {video_name} (id={video_id}) not found in CSV, skipping")
+            continue
+
+        # Check if already processed
+        if video_id in existing_results:
+            # Use existing result
+            results.append(existing_results[video_id])
+            scores.append(existing_results[video_id]["aesthetic_score"])
+        else:
+            # Need to process
+            videos_to_process.append((video_path, video_id, video_name))
+
+    print(f"Already processed: {len(existing_results)} videos")
+    print(f"Need to process: {len(videos_to_process)} videos")
+
+    # Process remaining videos
+    if videos_to_process:
+        # Load models
+        print("Loading CLIP model...")
+        clip_model, preprocess = clip.load(args.clip_model_path, device=device)
+
+        print("Loading aesthetic predictor model...")
+        aesthetic_model = get_aesthetic_model(args.aesthetic_model_path).to(device)
+
+        print("\nEvaluating remaining videos...")
+        for video_path, video_id, video_name in tqdm(videos_to_process):
+            try:
+                score = evaluate_aesthetic(
+                    aesthetic_model,
+                    clip_model,
+                    video_path,
+                    height=args.height,
+                    width=args.width,
+                    device=device,
+                )
+
+                result_item = {"id": video_id, "video_name": video_name, "aesthetic_score": score}
+                results.append(result_item)
+                scores.append(score)
+
+            except Exception as e:
+                print(f"Error processing {video_name}: {str(e)}")
+                continue
+    else:
+        print("No videos to process. Skipping evaluation.")
+        return
+
+    # Calculate overall metrics
+    if scores:
+        avg_score = sum(scores) / len(scores)
+
+        # Sort results by video_id
+        results_sorted = sorted(results, key=lambda x: x["id"])
+
+        output = {
+            "metric": "aesthetic",
+            "average_score": avg_score,
+            "num_videos": len(scores),
+            "per_video_results": results_sorted,
+        }
+
+        # Save results
+        os.makedirs(output_path, exist_ok=True)
+        with open(output_json_path, "w") as f:
+            json.dump(output, f, indent=2)
+
+        print(f"\n{'=' * 60}")
+        print("Results Summary:")
+        print(f"{'=' * 60}")
+        print(f"Average Aesthetic Score: {avg_score:.4f}")
+        print(f"Number of videos evaluated: {len(scores)}")
+        print(f"Results saved to: {output_json_path}")
+        print(f"{'=' * 60}\n")
+    else:
+        print("No videos were successfully evaluated!")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Evaluate video aesthetic using CLIP + LAION aesthetic predictor")
+
+    # Input/Output arguments
+    parser.add_argument("--height", type=str, default=384)
+    parser.add_argument("--width", type=str, default=640)
+    parser.add_argument("--input_csv", type=str, default="playground/helios_t2v_prompts.csv")
+    parser.add_argument("--video_dir", type=str, default="playground/toy-video")
+    parser.add_argument("--output_path", type=str, default="playground/results")
+
+    # Model arguments
+    parser.add_argument("--clip_model_path", type=str, default="checkpoints/aesthetic_model/ViT-L-14.pt")
+    parser.add_argument(
+        "--aesthetic_model_path", type=str, default="checkpoints/aesthetic_model/sa_0_4_vit_l_14_linear.pth"
+    )
+
+    args = parser.parse_args()
+
+    main(args)

Helios/eval/10_merge_all_results.py

@@ -0,0 +1,152 @@
+import argparse
+import json
+import os
+from pathlib import Path
+
+
+def collect_all_model_results(input_dir, score_type="normalized"):
+    model_results = {}
+    base_path = Path(input_dir)
+
+    for model_dir in base_path.iterdir():
+        if not model_dir.is_dir():
+            continue
+
+        merged_file = model_dir / "merged_results.json"
+        if not merged_file.exists():
+            print(f"⚠ Skipping {model_dir.name}: merged_results.json not found")
+            continue
+
+        try:
+            with open(merged_file, "r") as f:
+                data = json.load(f)
+
+            model_name = model_dir.name
+            scores = {}
+
+            if score_type == "raw":
+                score_field = "raw_score"
+            elif score_type == "normalized":
+                score_field = "normalized_score"
+            elif score_type == "rating":
+                score_field = "rating"
+            else:
+                score_field = "normalized_score"
+
+            summary = data.get("summary", {})
+
+            for metric_key, metric_info in summary.get("non_drifting", {}).items():
+                scores[metric_key] = metric_info.get(score_field)
+
+            for metric_key, metric_info in summary.get("drifting", {}).items():
+                scores[metric_key] = metric_info.get(score_field)
+
+            if "total_weighted_rating" in summary:
+                scores["total_weighted_rating"] = summary["total_weighted_rating"]
+
+            model_results[model_name] = scores
+            print(f"✓ Loaded results for: {model_name}")
+
+        except Exception as e:
+            print(f"✗ Error loading {model_dir.name}/merged_results.json: {e}")
+
+    return model_results
+
+
+def create_final_merged_json(model_results, output_path, score_type="normalized", rating_scale=None):
+    all_metrics = set()
+    for scores in model_results.values():
+        all_metrics.update(scores.keys())
+
+    sorted_metrics = sorted([m for m in all_metrics if m != "total_weighted_rating"])
+    if "total_weighted_rating" in all_metrics:
+        sorted_metrics.append("total_weighted_rating")
+
+    final_data = {
+        "num_models": len(model_results),
+        "score_type": score_type,
+        "metrics": sorted_metrics,
+        "models": model_results,
+    }
+
+    if score_type == "rating" and rating_scale is not None:
+        final_data["rating_scale"] = rating_scale
+
+    with open(output_path, "w") as f:
+        json.dump(final_data, f, indent=2)
+
+    return final_data
+
+
+def get_rating_scale_from_results(input_dir):
+    base_path = Path(input_dir)
+
+    for model_dir in base_path.iterdir():
+        if not model_dir.is_dir():
+            continue
+
+        merged_file = model_dir / "merged_results.json"
+        if merged_file.exists():
+            try:
+                with open(merged_file, "r") as f:
+                    data = json.load(f)
+                    rating_scale = data.get("rating_scale")
+                    if rating_scale:
+                        return rating_scale
+            except Exception:
+                continue
+
+    return None
+
+
+def main(args):
+    input_dir = Path(args.input_dir)
+
+    if not input_dir.exists():
+        print(f"Error: Directory not found: {input_dir}")
+        return
+
+    score_type = args.score_type
+
+    rating_scale = None
+    if score_type == "rating":
+        rating_scale = get_rating_scale_from_results(input_dir)
+        if rating_scale:
+            score_type_str = f"RATING (1-{rating_scale})"
+        else:
+            score_type_str = "RATING"
+    elif score_type == "normalized":
+        score_type_str = "NORMALIZED"
+    elif score_type == "raw":
+        score_type_str = "RAW"
+    else:
+        score_type_str = score_type.upper()
+
+    print(f"\n{'=' * 100}")
+    print(f"ALL MODELS RESULTS MERGER (Using {score_type_str} Scores)")
+    print(f"{'=' * 100}")
+    print(f"Base Directory: {input_dir}\n")
+
+    model_results = collect_all_model_results(input_dir, score_type)
+
+    if not model_results:
+        print("\n✗ No model results found!")
+        return
+
+    print(f"\n✓ Successfully loaded {len(model_results)} models\n")
+
+    output_path = args.output_path or os.path.join(input_dir, "all_models_merged.json")
+    create_final_merged_json(model_results, output_path, score_type, rating_scale)
+
+    print(f"✓ All models merged results saved to: {output_path}\n")
+
+    return True
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Merge all models' merged_results.json into a single comparison file")
+    parser.add_argument("--input_dir", type=str, default="playground/results", help="Base directory")
+    parser.add_argument("--output_path", type=str, default=None)
+    parser.add_argument("--score_type", type=str, choices=["raw", "normalized", "rating"], default="rating")
+    args = parser.parse_args()
+    main(args)

Helios/eval/1_get_motion_amplitude.py

@@ -0,0 +1,194 @@
+import argparse
+import glob
+import json
+import os
+import re
+from concurrent.futures import ProcessPoolExecutor, as_completed
+
+import cv2
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+
+from utils.utils import load_video
+
+
+def _downscale_maps(flow_maps, downscale_size=16):
+    """Resize flow maps for score calculation"""
+    downscaled = []
+    for flow in flow_maps:
+        h, w = flow.shape[:2]
+        new_h = int(h * (downscale_size / w))
+        downscaled.append(cv2.resize(flow, (downscale_size, new_h), interpolation=cv2.INTER_AREA))
+    return downscaled
+
+
+def _motion_score(maps_or_masks):
+    """Calculate mean score from maps or masks"""
+    if len(maps_or_masks) == 0:
+        return 0.0
+    average_map = np.mean(np.array(maps_or_masks), axis=0)
+    return float(np.mean(average_map))
+
+
+def compute_farneback_optical_flow(frames):
+    """Compute dense optical flow using Farneback algorithm"""
+    if len(frames) < 2:
+        return []
+
+    prev_gray = cv2.cvtColor(frames[0], cv2.COLOR_RGB2GRAY)
+    flow_maps = []
+
+    for frame in frames[1:]:
+        gray = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
+        flow_map = cv2.calcOpticalFlowFarneback(
+            prev_gray,
+            gray,
+            flow=None,
+            pyr_scale=0.5,
+            levels=3,
+            winsize=15,
+            iterations=3,
+            poly_n=5,
+            poly_sigma=1.2,
+            flags=0,
+        )
+        flow_maps.append(flow_map)
+        prev_gray = gray
+
+    return flow_maps
+
+
+def evaluate_motion(video_info, height=384, width=640):
+    video_path, video_id, video_name = video_info
+    try:
+        images = load_video(video_path, height=height, width=width, return_tensor=False)
+        farneback_maps = compute_farneback_optical_flow(images)
+        score = _motion_score(_downscale_maps(farneback_maps))
+
+        return {"id": video_id, "video_name": video_name, "motion_fb": abs(score), "success": True}
+    except Exception as e:
+        return {"id": video_id, "video_name": video_name, "error": str(e), "success": False}
+
+
+def main(args):
+    baseline_name = os.path.basename(args.video_dir)
+    output_path = os.path.join(args.output_path, baseline_name)
+    output_json_path = os.path.join(output_path, "motion_amplitude_results.json")
+
+    # Load CSV file
+    if not os.path.exists(args.input_csv):
+        raise FileNotFoundError(f"CSV file not found: {args.input_csv}")
+
+    df = pd.read_csv(args.input_csv)
+    df_dict = df.set_index("id").to_dict("index")
+
+    # Validate CSV columns
+    required_columns = ["id", "duration"]
+    for col in required_columns:
+        if col not in df.columns:
+            raise ValueError(f"CSV must contain '{col}' column. Found columns: {df.columns.tolist()}")
+
+    # Load existing results if available
+    existing_results = {}
+    if os.path.exists(output_json_path):
+        print(f"Found existing results at {output_json_path}, loading...")
+        with open(output_json_path, "r") as f:
+            existing_data = json.load(f)
+            for item in existing_data.get("per_video_results", []):
+                existing_results[item["id"]] = item
+        print(f"Loaded {len(existing_results)} existing results")
+
+    # Get all videos to process
+    video_files = glob.glob(os.path.join(args.video_dir, "*_*_ori*.mp4"))
+    video_files.sort(key=lambda x: int(re.search(r"(\d+)_", os.path.basename(x)).group(1)))
+    print(f"\nFound {len(video_files)} videos in directory")
+
+    # Check which videos need processing
+    results = []
+    scores = []
+    videos_to_process = []
+
+    for video_path in video_files:
+        video_name = os.path.basename(video_path)
+        parts = video_name.replace(".mp4", "").split("_")
+        video_id = int(parts[0])
+
+        if video_id not in df_dict:
+            print(f"Warning: Video {video_name} (id={video_id}) not found in CSV, skipping")
+            continue
+
+        # Check if already processed
+        if video_id in existing_results:
+            # Use existing result
+            results.append(existing_results[video_id])
+            scores.append(existing_results[video_id]["motion_fb"])
+        else:
+            # Need to process
+            videos_to_process.append((video_path, video_id, video_name))
+
+    print(f"Already processed: {len(existing_results)} videos")
+    print(f"Need to process: {len(videos_to_process)} videos")
+
+    # Process remaining videos
+    if videos_to_process:
+        with ProcessPoolExecutor(max_workers=args.num_workers) as executor:
+            futures = [executor.submit(evaluate_motion, v, args.height, args.width) for v in videos_to_process]
+
+            for future in tqdm(as_completed(futures), total=len(futures), desc="Processing"):
+                res = future.result()
+                if res["success"]:
+                    results.append({"id": res["id"], "video_name": res["video_name"], "motion_fb": res["motion_fb"]})
+                    scores.append(res["motion_fb"])
+                else:
+                    print(f"Error processing {res['video_name']}: {res.get('error')}")
+    else:
+        print("No videos to process. Skipping evaluation.")
+        return
+
+    # Calculate overall metrics
+    if scores:
+        avg_score = sum(scores) / len(scores)
+
+        # Sort results by video_id
+        results_sorted = sorted(results, key=lambda x: x["id"])
+
+        output = {
+            "metric": "motion_fb",
+            "average_score": avg_score,
+            "num_videos": len(scores),
+            "per_video_results": results_sorted,
+        }
+
+        # Save results
+        os.makedirs(output_path, exist_ok=True)
+        with open(output_json_path, "w") as f:
+            json.dump(output, f, indent=2)
+
+        print(f"\n{'=' * 60}")
+        print("Results Summary:")
+        print(f"{'=' * 60}")
+        print(f"Average Motion Farneback Score:   {avg_score:.4f}")
+        print(f"Number of videos evaluated: {len(scores)}")
+        print(f"Results saved to: {output_json_path}")
+        print(f"{'=' * 60}\n")
+    else:
+        print("No videos were successfully evaluated!")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Evaluate video motion farneback")
+
+    # Input/Output arguments
+    parser.add_argument("--height", type=int, default=384)
+    parser.add_argument("--width", type=int, default=640)
+    parser.add_argument("--input_csv", type=str, default="playground/helios_t2v_prompts.csv")
+    parser.add_argument("--video_dir", type=str, default="playground/toy-video")
+    parser.add_argument("--output_path", type=str, default="playground/results")
+
+    # Evaluation arguments
+    parser.add_argument("--num_workers", type=int, default=32)
+
+    args = parser.parse_args()
+
+    main(args)

Helios/eval/2_get_motion_smoothness.py

@@ -0,0 +1,301 @@
+import argparse
+import glob
+import json
+import os
+import re
+
+import cv2
+import numpy as np
+import pandas as pd
+import torch
+from omegaconf import OmegaConf
+from tqdm import tqdm
+
+from utils.third_party.amt.utils.build_utils import build_from_cfg
+from utils.third_party.amt.utils.utils import InputPadder, check_dim_and_resize, img2tensor, tensor2img
+from utils.utils import align_dimension
+
+
+class FrameProcess:
+    def __init__(self, height=384, width=640):
+        self.height = height
+        self.width = width
+
+    def get_frames(self, video_path):
+        """Extract frames from MP4 video"""
+        frame_list = []
+        video = cv2.VideoCapture(video_path)
+
+        original_width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH))
+        original_height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        original_aspect_ratio = original_width / original_height
+
+        if self.width > self.height:
+            target_width = self.width
+            target_height = int(self.width / original_aspect_ratio)
+        else:
+            target_height = self.height
+            target_width = int(self.height * original_aspect_ratio)
+
+        target_height = align_dimension(target_height, 2)
+        target_width = align_dimension(target_width, 2)
+
+        while video.isOpened():
+            success, frame = video.read()
+            if success:
+                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                frame = cv2.resize(frame, (target_width, target_height))
+                frame_list.append(frame)
+            else:
+                break
+        video.release()
+        assert frame_list != [], "No frames extracted from video"
+        return frame_list
+
+    def extract_frame(self, frame_list, start_from=0):
+        extract = []
+        for i in range(start_from, len(frame_list), 2):
+            extract.append(frame_list[i])
+        return extract
+
+
+class MotionSmoothness:
+    def __init__(self, config, ckpt, height=384, width=640, device="cuda"):
+        self.device = device
+        self.config = config
+        self.ckpt = ckpt
+        self.niters = 1
+        self.height = height
+        self.width = width
+        self.initialization()
+        self.load_model()
+
+    def load_model(self):
+        """Load AMT model"""
+        cfg_path = self.config
+        ckpt_path = self.ckpt
+        network_cfg = OmegaConf.load(cfg_path).network
+        network_name = network_cfg.name
+        print(f"Loading [{network_name}] from [{ckpt_path}]...")
+
+        self.model = build_from_cfg(network_cfg)
+        ckpt = torch.load(ckpt_path, map_location="cpu", weights_only=False)
+        self.model.load_state_dict(ckpt["state_dict"])
+        self.model = self.model.to(self.device)
+        self.model.eval()
+
+    def initialization(self):
+        """Initialize parameters based on device"""
+        if self.device.type == "cuda":
+            self.anchor_resolution = 1024 * 512
+            self.anchor_memory = 1500 * 1024**2
+            self.anchor_memory_bias = 2500 * 1024**2
+            self.vram_avail = torch.cuda.get_device_properties(self.device).total_memory
+        else:
+            self.anchor_resolution = 8192 * 8192
+            self.anchor_memory = 1
+            self.anchor_memory_bias = 0
+            self.vram_avail = 1
+
+        self.embt = torch.tensor(1 / 2).float().view(1, 1, 1, 1).to(self.device)
+        self.fp = FrameProcess(height=self.height, width=self.width)
+
+    def motion_score(self, video_path):
+        """Calculate motion smoothness score for a video"""
+        iters = int(self.niters)
+
+        # Get frames
+        frames = self.fp.get_frames(video_path)
+        frame_list = self.fp.extract_frame(frames, start_from=0)
+
+        # Convert to tensors
+        inputs = [img2tensor(frame).to(self.device) for frame in frame_list]
+        assert len(inputs) > 1, f"Need more than one frame (current {len(inputs)})"
+
+        inputs = check_dim_and_resize(inputs)
+        h, w = inputs[0].shape[-2:]
+        scale = (
+            self.anchor_resolution
+            / (h * w)
+            * np.sqrt((self.vram_avail - self.anchor_memory_bias) / self.anchor_memory)
+        )
+        scale = 1 if scale > 1 else scale
+        scale = 1 / np.floor(1 / np.sqrt(scale) * 16) * 16
+
+        if scale < 1:
+            print(f"Due to limited VRAM, video will be scaled by {scale:.2f}")
+
+        padding = int(16 / scale)
+        padder = InputPadder(inputs[0].shape, padding)
+        inputs = padder.pad(*inputs)
+
+        # Frame interpolation
+        for i in range(iters):
+            outputs = [inputs[0]]
+            for in_0, in_1 in zip(inputs[:-1], inputs[1:]):
+                in_0 = in_0.to(self.device)
+                in_1 = in_1.to(self.device)
+                with torch.no_grad():
+                    imgt_pred = self.model(in_0, in_1, self.embt, scale_factor=scale, eval=True)["imgt_pred"]
+                outputs += [imgt_pred.cpu(), in_1.cpu()]
+            inputs = outputs
+
+        # Calculate VFI score
+        outputs = padder.unpad(*outputs)
+        outputs = [tensor2img(out) for out in outputs]
+        vfi_score = self.vfi_score(frames, outputs)
+        norm = (255.0 - vfi_score) / 255.0
+
+        return norm
+
+    def vfi_score(self, ori_frames, interpolate_frames):
+        """Calculate video frame interpolation quality score"""
+        ori = self.fp.extract_frame(ori_frames, start_from=1)
+        interpolate = self.fp.extract_frame(interpolate_frames, start_from=1)
+
+        scores = []
+        for i in range(len(interpolate)):
+            scores.append(self.get_diff(ori[i], interpolate[i]))
+
+        return np.mean(np.array(scores))
+
+    def get_diff(self, img1, img2):
+        """Calculate absolute difference between two images"""
+        img = cv2.absdiff(img1, img2)
+        return np.mean(img)
+
+
+def main(args):
+    baseline_name = os.path.basename(args.video_dir)
+    output_path = os.path.join(args.output_path, baseline_name)
+    output_json_path = os.path.join(output_path, "motion_smoothness_results.json")
+
+    # Set device
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Using device: {device}")
+
+    # Load CSV file
+    if not os.path.exists(args.input_csv):
+        raise FileNotFoundError(f"CSV file not found: {args.input_csv}")
+
+    df = pd.read_csv(args.input_csv)
+    df_dict = df.set_index("id").to_dict("index")
+
+    # Validate CSV columns
+    required_columns = ["id", "duration"]
+    for col in required_columns:
+        if col not in df.columns:
+            raise ValueError(f"CSV must contain '{col}' column. Found columns: {df.columns.tolist()}")
+
+    # Load existing results if available
+    existing_results = {}
+    if os.path.exists(output_json_path):
+        print(f"Found existing results at {output_json_path}, loading...")
+        with open(output_json_path, "r") as f:
+            existing_data = json.load(f)
+            for item in existing_data.get("per_video_results", []):
+                existing_results[item["id"]] = item
+        print(f"Loaded {len(existing_results)} existing results")
+
+    # Get all videos to process
+    video_files = glob.glob(os.path.join(args.video_dir, "*_*_ori*.mp4"))
+    video_files.sort(key=lambda x: int(re.search(r"(\d+)_", os.path.basename(x)).group(1)))
+    print(f"\nFound {len(video_files)} videos in directory")
+
+    # Check which videos need processing
+    results = []
+    scores = []
+    videos_to_process = []
+
+    for video_path in video_files:
+        video_name = os.path.basename(video_path)
+        parts = video_name.replace(".mp4", "").split("_")
+        video_id = int(parts[0])
+
+        if video_id not in df_dict:
+            print(f"Warning: Video {video_name} (id={video_id}) not found in CSV, skipping")
+            continue
+
+        # Check if already processed
+        if video_id in existing_results:
+            # Use existing result
+            results.append(existing_results[video_id])
+            scores.append(existing_results[video_id]["motion_smoothness_score"])
+        else:
+            # Need to process
+            videos_to_process.append((video_path, video_id, video_name))
+
+    print(f"Already processed: {len(existing_results)} videos")
+    print(f"Need to process: {len(videos_to_process)} videos")
+
+    # Process remaining videos
+    if videos_to_process:
+        # Load model
+        print("Loading AMT model...")
+        motion_evaluator = MotionSmoothness(
+            args.config, args.smoothness_model_path, height=args.height, width=args.width, device=device
+        )
+
+        print("\nEvaluating remaining videos...")
+        for video_path, video_id, video_name in tqdm(videos_to_process):
+            try:
+                score = motion_evaluator.motion_score(video_path)
+
+                result_item = {"id": video_id, "video_name": video_name, "motion_smoothness_score": float(score)}
+                results.append(result_item)
+                scores.append(float(score))
+
+            except Exception as e:
+                print(f"Error processing {video_name}: {str(e)}")
+                continue
+    else:
+        print("No videos to process. Skipping evaluation.")
+        return
+
+    # Calculate overall metrics
+    if scores:
+        avg_score = sum(scores) / len(scores)
+
+        # Sort results by video_id
+        results_sorted = sorted(results, key=lambda x: x["id"])
+
+        output = {
+            "metric": "motion_smoothness",
+            "average_score": avg_score,
+            "num_videos": len(scores),
+            "per_video_results": results_sorted,
+        }
+
+        # Save results
+        os.makedirs(output_path, exist_ok=True)
+        with open(output_json_path, "w") as f:
+            json.dump(output, f, indent=2)
+
+        print(f"\n{'=' * 60}")
+        print("Results Summary:")
+        print(f"{'=' * 60}")
+        print(f"Average Motion Smoothness Score: {avg_score:.4f}")
+        print(f"Number of videos evaluated: {len(scores)}")
+        print(f"Results saved to: {output_json_path}")
+        print(f"{'=' * 60}\n")
+    else:
+        print("No videos were successfully evaluated!")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Evaluate video motion smoothness using AMT model")
+
+    # Input/Output arguments
+    parser.add_argument("--height", type=str, default=384)
+    parser.add_argument("--width", type=str, default=640)
+    parser.add_argument("--input_csv", type=str, default="playground/helios_t2v_prompts.csv")
+    parser.add_argument("--video_dir", type=str, default="playground/toy-video")
+    parser.add_argument("--output_path", type=str, default="playground/results")
+
+    # Model arguments
+    parser.add_argument("--config", type=str, default="checkpoints/AMT-S.yaml")
+    parser.add_argument("--smoothness_model_path", type=str, default="checkpoints/amt_model/amt-s.pth")
+
+    args = parser.parse_args()
+
+    main(args)

Helios/eval/3_get_semantic.py

@@ -0,0 +1,207 @@
+import argparse
+import glob
+import json
+import os
+import re
+
+import pandas as pd
+import torch
+from tqdm import tqdm
+
+from utils.third_party.ViCLIP.simple_tokenizer import SimpleTokenizer
+from utils.third_party.ViCLIP.viclip import ViCLIP
+from utils.utils import clip_transform, read_frames_decord_by_fps
+
+
+def get_text_features(model, input_text, tokenizer, text_feature_dict={}):
+    """Get text features from ViCLIP"""
+    if input_text in text_feature_dict:
+        return text_feature_dict[input_text]
+
+    text_template = f"{input_text}"
+    with torch.no_grad():
+        text_features = model.encode_text(text_template).float()
+        text_features /= text_features.norm(dim=-1, keepdim=True)
+        text_feature_dict[input_text] = text_features
+
+    return text_features
+
+
+def get_vid_features(model, input_frames):
+    """Get video features from ViCLIP"""
+    with torch.no_grad():
+        clip_feat = model.encode_vision(input_frames, test=True).float()
+        clip_feat /= clip_feat.norm(dim=-1, keepdim=True)
+    return clip_feat
+
+
+def evaluate_overall_consistency(
+    viclip_model, tokenizer, video_path, prompt, height=384, width=640, device="cuda", sample_mode="middle"
+):
+    """Evaluate semantic consistency between video and prompt"""
+    image_transform = clip_transform(224)
+
+    with torch.no_grad():
+        # Load video frames
+        images = read_frames_decord_by_fps(video_path, height=height, width=width, num_frames=8, sample=sample_mode)
+        images = image_transform(images)
+        images = images.to(device)
+
+        # Get features
+        clip_feat = get_vid_features(viclip_model, images.unsqueeze(0))
+        text_feat = get_text_features(viclip_model, prompt, tokenizer)
+
+        # Calculate similarity
+        logit_per_text = clip_feat @ text_feat.T
+        score = float(logit_per_text[0][0].cpu())
+
+    return score
+
+
+def main(args):
+    baseline_name = os.path.basename(args.video_dir)
+    output_path = os.path.join(args.output_path, baseline_name)
+    output_json_path = os.path.join(output_path, "semantic_results.json")
+
+    # Set device
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Using device: {device}")
+
+    # Load CSV file
+    if not os.path.exists(args.input_csv):
+        raise FileNotFoundError(f"CSV file not found: {args.input_csv}")
+
+    df = pd.read_csv(args.input_csv)
+    df_dict = df.set_index("id").to_dict("index")
+
+    # Validate CSV columns
+    required_columns = ["id", "duration", "prompt"]
+    for col in required_columns:
+        if col not in df.columns:
+            raise ValueError(f"CSV must contain '{col}' column. Found columns: {df.columns.tolist()}")
+
+    # Load existing results if available
+    existing_results = {}
+    if os.path.exists(output_json_path):
+        print(f"Found existing results at {output_json_path}, loading...")
+        with open(output_json_path, "r") as f:
+            existing_data = json.load(f)
+            for item in existing_data.get("per_video_results", []):
+                existing_results[item["id"]] = item
+        print(f"Loaded {len(existing_results)} existing results")
+
+    # Get video files
+    video_files = glob.glob(os.path.join(args.video_dir, "*_*_ori*.mp4"))
+    video_files.sort(key=lambda x: int(re.search(r"(\d+)_", os.path.basename(x)).group(1)))
+    print(f"\nFound {len(video_files)} videos in directory")
+
+    # Check which videos need processing
+    results = []
+    scores = []
+    videos_to_process = []
+
+    for video_path in video_files:
+        video_name = os.path.basename(video_path)
+        parts = video_name.replace(".mp4", "").split("_")
+        video_id = int(parts[0])
+
+        if video_id not in df_dict:
+            print(f"Warning: Video {video_name} (id={video_id}) not found in CSV, skipping")
+            continue
+
+        # Check if already processed
+        if video_id in existing_results:
+            # Use existing result
+            results.append(existing_results[video_id])
+            scores.append(existing_results[video_id]["semantic_score"])
+        else:
+            # Need to process
+            prompt = df_dict[video_id]["prompt"]
+            videos_to_process.append((video_path, video_id, video_name, prompt))
+
+    print(f"Already processed: {len(existing_results)} videos")
+    print(f"Need to process: {len(videos_to_process)} videos")
+
+    # Process remaining videos
+    if videos_to_process:
+        # Load ViCLIP model
+        print("Loading ViCLIP model...")
+        tokenizer_path = os.path.join(args.semantic_model_path, "bpe_simple_vocab_16e6.txt.gz")
+        semantic_model_path = os.path.join(args.semantic_model_path, "ViClip-InternVid-10M-FLT.pth")
+
+        tokenizer = SimpleTokenizer(tokenizer_path)
+        viclip = ViCLIP(tokenizer=tokenizer, pretrain=semantic_model_path).to(device)
+        viclip.eval()
+
+        print("\nEvaluating remaining videos...")
+        for video_path, video_id, video_name, prompt in tqdm(videos_to_process):
+            try:
+                score = evaluate_overall_consistency(
+                    viclip,
+                    tokenizer,
+                    video_path,
+                    prompt,
+                    height=args.height,
+                    width=args.width,
+                    sample_mode=args.sample_mode,
+                    device=device,
+                )
+
+                result_item = {"id": video_id, "video_name": video_name, "prompt": prompt, "semantic_score": score}
+                results.append(result_item)
+                scores.append(score)
+
+            except Exception as e:
+                print(f"Error processing {video_name}: {str(e)}")
+                continue
+    else:
+        print("No videos to process. Skipping evaluation.")
+        return
+
+    # Sort all results by video_id
+    results_sorted = sorted(results, key=lambda x: x["id"])
+
+    # Calculate overall metrics and save final results
+    if scores:
+        avg_score = sum(scores) / len(scores)
+
+        output = {
+            "metric": "semantic",
+            "average_score": avg_score,
+            "num_videos": len(scores),
+            "per_video_results": results_sorted,
+        }
+
+        # Save results
+        os.makedirs(output_path, exist_ok=True)
+        with open(output_json_path, "w") as f:
+            json.dump(output, f, indent=2)
+
+        print(f"\n{'=' * 60}")
+        print("Results Summary:")
+        print(f"{'=' * 60}")
+        print(f"Average Semantic Score: {avg_score:.4f}")
+        print(f"Number of videos evaluated: {len(scores)}")
+        print(f"Results saved to: {output_json_path}")
+        print(f"{'=' * 60}\n")
+    else:
+        print("No videos were successfully evaluated!")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Evaluate video semantic using ViCLIP model")
+
+    # Input/Output arguments
+    parser.add_argument("--height", type=str, default=384)
+    parser.add_argument("--width", type=str, default=640)
+    parser.add_argument("--input_csv", type=str, default="playground/helios_t2v_prompts.csv")
+    parser.add_argument("--video_dir", type=str, default="playground/toy-video")
+    parser.add_argument("--output_path", type=str, default="playground/results")
+
+    # Model arguments
+    parser.add_argument("--semantic_model_path", type=str, default="checkpoints/ViCLIP")
+    parser.add_argument("--sample_mode", type=str, default="middle", choices=["middle", "rand"])
+
+    args = parser.parse_args()
+
+    main(args)

Helios/eval/4_get_naturalness.py

@@ -0,0 +1,287 @@
+import argparse
+import base64
+import glob
+import json
+import os
+import re
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import cv2
+import pandas as pd
+from openai import OpenAI
+from tqdm import tqdm
+
+
+PROMPT_VIDEO_DETECTION = """
+Your task is to analyze ##NUM_FRAMES## frames sampled across a long video (e.g., ~1500 frames) to determine if it is AI-generated.
+
+### CONTEXT:
+Frames are sampled at wide intervals. Scene changes or camera movements are expected. Focus on individual frame integrity and local physical logic rather than global consistency.
+
+### EVALUATION CRITERIA:
+1. **Single-Frame Technical Flaws**: Look for AI-specific rendering "hallucinations":
+   - **Textures**: "Melting" surfaces, plastic-like skin, or chaotic patterns in complex areas (e.g., water ripples, foliage, fire).
+   - **Edges**: Unnatural blurring or "auras" around moving subjects where they meet the background.
+2. **Local Physical Logic**: Within any given frame or small cluster of frames:
+   - Do shadows and reflections align with the visible light sources?
+   - Are objects interacting naturally with their environment (e.g., feet touching the ground properly, hands grasping objects correctly)?
+3. **Biological Anomalies**: If humans appear, inspect for:
+   - Anatomical errors: Extra fingers, asymmetric eyes, or "fused" teeth.
+   - Unnatural micro-expressions or "dead" eyes lacking specular highlights.
+4. **Transient Artifacts**: Even in sparse samples, look for "ghosting" or objects that seem to be partially transparent or merging with other objects (common in AI diffusion).
+
+### SCORING SCALE:
+- 1 (Definitely AI): Clear anatomical deformities, "melting" textures, or impossible physical interactions.
+- 2 (Likely AI): Presence of "uncanny valley" effects, suspicious texture smoothing, or minor physical illogic.
+- 3 (Uncertain): Ambiguous; could be low-quality real-world footage, heavy motion blur, or high-end AI.
+- 4 (Likely Real): Consistent organic details, natural motion blur, and logical lighting.
+- 5 (Definitely Real): Perfect high-frequency details (pores, fabric, grain), flawless physics, and natural anatomy.
+
+### OUTPUT INSTRUCTION:
+Return ONLY the integer score (1-5). No explanation.
+""".strip()
+
+
+def image_to_base64(image):
+    """Convert image to base64 string"""
+    _, buffer = cv2.imencode(".jpg", image)
+    return base64.b64encode(buffer).decode("utf-8")
+
+
+def resize_long_side(image, target_long=512):
+    """Resize image keeping aspect ratio"""
+    h, w = image.shape[:2]
+    if h >= w:
+        new_h = target_long
+        new_w = int(w * target_long / h)
+    else:
+        new_w = target_long
+        new_h = int(h * target_long / w)
+    return cv2.resize(image, (new_w, new_h), interpolation=cv2.INTER_AREA)
+
+
+def extract_frames(video_path, num_frames=16):
+    """Extract frames from video"""
+    cap = cv2.VideoCapture(video_path)
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    frame_interval = max(total_frames // num_frames, 1)
+    frames = []
+
+    for i in range(num_frames):
+        cap.set(cv2.CAP_PROP_POS_FRAMES, i * frame_interval)
+        ret, frame = cap.read()
+        if ret:
+            resized = resize_long_side(frame, 512)
+            frames.append(resized)
+
+    cap.release()
+    return frames
+
+
+# @retry(wait=wait_exponential(min=2, max=10), stop=stop_after_attempt(5))
+def call_gpt(image_frames_base64, model_name, api_key, base_url, num_frames=16, temperature=0.0):
+    """Call GPT API to evaluate video naturalness"""
+    client = OpenAI(api_key=api_key, base_url=base_url)
+
+    content_list = []
+    for frame in image_frames_base64:
+        content_list.append(
+            {
+                "type": "image_url",
+                "image_url": {"url": f"data:image/jpeg;base64,{frame}"},
+            }
+        )
+    content_list.append({"type": "text", "text": PROMPT_VIDEO_DETECTION.replace("##NUM_FRAMES##", str(num_frames))})
+
+    response = client.chat.completions.create(
+        model=model_name,
+        stream=False,
+        temperature=temperature,
+        messages=[{"role": "user", "content": content_list}],
+    )
+
+    score = response.choices[0].message.content.strip()
+    return score
+
+
+def evaluate_naturalness(video_path, api_key, model_name, base_url, num_frames=16):
+    """Evaluate naturalness for a single video"""
+    try:
+        frames = extract_frames(video_path, num_frames)
+        frames_base64 = [image_to_base64(f) for f in frames]
+        score_str = call_gpt(frames_base64, model_name, api_key, base_url, num_frames)
+
+        # Parse score (try to extract number from response)
+        score = float(score_str)
+        score = max(1.0, min(5.0, score))
+        # Normalize to [0, 1] if score is 1-5
+        score = (score - 1) / 4.0  # Convert 1-5 to 0-1
+
+        return score, score_str
+    except Exception as e:
+        print(f"Error evaluating video: {str(e)}")
+        raise
+
+
+def process_video_worker(args_tuple):
+    """Worker function for parallel processing"""
+    video_path, video_id, video_name, api_key, model_name, base_url, num_frames = args_tuple
+    try:
+        score, raw_score = evaluate_naturalness(video_path, api_key, model_name, base_url, num_frames)
+        return {
+            "id": video_id,
+            "video_name": video_name,
+            "naturalness_score": score,
+            "raw_score": raw_score,
+        }
+    except Exception as e:
+        print(f"Error processing {video_name}: {str(e)}")
+        return None
+
+
+def main(args):
+    baseline_name = os.path.basename(args.video_dir)
+    output_path = os.path.join(args.output_path, baseline_name)
+    output_json_path = os.path.join(output_path, "naturalness_results.json")
+
+    print(f"Using API: {args.base_url}")
+    print(f"Model: {args.model_name}")
+
+    # Load CSV file
+    if not os.path.exists(args.input_csv):
+        raise FileNotFoundError(f"CSV file not found: {args.input_csv}")
+
+    df = pd.read_csv(args.input_csv)
+    df_dict = df.set_index("id").to_dict("index")
+
+    # Validate CSV columns
+    required_columns = ["id", "duration"]
+    for col in required_columns:
+        if col not in df.columns:
+            raise ValueError(f"CSV must contain '{col}' column. Found columns: {df.columns.tolist()}")
+
+    # Load existing results if available
+    existing_results = {}
+    if os.path.exists(output_json_path):
+        print(f"Found existing results at {output_json_path}, loading...")
+        with open(output_json_path, "r") as f:
+            existing_data = json.load(f)
+            for item in existing_data.get("per_video_results", []):
+                existing_results[item["id"]] = item
+        print(f"Loaded {len(existing_results)} existing results")
+
+    # Get video files
+    video_files = glob.glob(os.path.join(args.video_dir, "*_*_ori*.mp4"))
+    video_files.sort(key=lambda x: int(re.search(r"(\d+)_", os.path.basename(x)).group(1)))
+    print(f"\nFound {len(video_files)} videos in directory")
+
+    # Check which videos need processing
+    results = []
+    tasks = []
+
+    for video_path in video_files:
+        video_name = os.path.basename(video_path)
+        parts = video_name.replace(".mp4", "").split("_")
+        video_id = int(parts[0])
+
+        if video_id not in df_dict:
+            print(f"Warning: Video {video_name} (id={video_id}) not found in CSV, skipping")
+            continue
+
+        # Check if already processed
+        if video_id in existing_results:
+            # Use existing result
+            results.append(existing_results[video_id])
+        else:
+            # Need to process
+            tasks.append(
+                (
+                    video_path,
+                    video_id,
+                    video_name,
+                    args.api_key,
+                    args.model_name,
+                    args.base_url,
+                    args.num_frames,
+                )
+            )
+
+    print(f"Already processed: {len(existing_results)} videos")
+    print(f"Need to process: {len(tasks)} videos")
+
+    # Evaluate remaining videos in parallel
+    if tasks:
+        results_dict = {}
+
+        print(f"Evaluating videos with {args.num_workers} workers...")
+
+        with ThreadPoolExecutor(max_workers=args.num_workers) as executor:
+            future_to_idx = {executor.submit(process_video_worker, task): idx for idx, task in enumerate(tasks)}
+
+            for future in tqdm(as_completed(future_to_idx), total=len(tasks), desc="Evaluating"):
+                idx = future_to_idx[future]
+                result = future.result()
+                if result is not None:
+                    results_dict[idx] = result
+
+        # Add new results in order
+        new_results = [results_dict[i] for i in sorted(results_dict.keys())]
+        results.extend(new_results)
+    else:
+        print("No videos to process. Skipping evaluation.")
+        return
+
+    # Sort all results by video_id
+    results_sorted = sorted(results, key=lambda x: x["id"])
+    scores = [r["naturalness_score"] for r in results_sorted]
+
+    # Calculate overall metrics
+    if scores:
+        avg_score = sum(scores) / len(scores)
+
+        output = {
+            "metric": "naturalness",
+            "average_score": avg_score,
+            "num_videos": len(scores),
+            "model_name": args.model_name,
+            "num_frames_per_video": args.num_frames,
+            "per_video_results": results_sorted,
+        }
+
+        # Save results
+        os.makedirs(output_path, exist_ok=True)
+
+        with open(output_json_path, "w") as f:
+            json.dump(output, f, indent=2)
+
+        print(f"\n{'=' * 60}")
+        print("Results Summary:")
+        print(f"{'=' * 60}")
+        print(f"Average Naturalness Score: {avg_score:.4f}")
+        print(f"Number of videos evaluated: {len(scores)}")
+        print(f"Results saved to: {output_json_path}")
+        print(f"{'=' * 60}\n")
+    else:
+        print("No videos were successfully evaluated!")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Evaluate video naturalness using VLM")
+
+    # Input/Output arguments
+    parser.add_argument("--input_csv", type=str, default="playground/helios_t2v_prompts.csv")
+    parser.add_argument("--video_dir", type=str, default="playground/toy-video")
+    parser.add_argument("--output_path", type=str, default="playground/results")
+
+    # API arguments
+    parser.add_argument("--api_key", type=str, required=True)
+    parser.add_argument("--model_name", type=str, default="gpt-5.2-2025-12-11")
+    parser.add_argument("--base_url", type=str, default=None)
+
+    # Evaluation arguments
+    parser.add_argument("--num_frames", type=int, default=16)
+    parser.add_argument("--num_workers", type=int, default=64)
+
+    args = parser.parse_args()
+
+    main(args)

Helios/eval/5_get_drifting_aesthetic.py

@@ -0,0 +1,239 @@
+import argparse
+import glob
+import json
+import os
+import re
+
+import clip
+import pandas as pd
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from tqdm import tqdm
+
+from utils.utils import clip_transform, load_video
+
+
+BATCH_SIZE = 32
+# Percentage of frames to use for start/end portions
+DRIFT_RATIO = 0.15
+
+
+def get_aesthetic_model(path_to_model):
+    """Load the aesthetic predictor model"""
+    m = nn.Linear(768, 1)
+    s = torch.load(path_to_model, map_location="cpu", weights_only=False)
+    m.load_state_dict(s)
+    m.eval()
+    return m
+
+
+def evaluate_aesthetic_on_frames(aesthetic_model, clip_model, frames, device):
+    """Evaluate aesthetic on a set of frames"""
+    if len(frames) == 0:
+        return 0.0
+
+    aesthetic_model.eval()
+    clip_model.eval()
+
+    image_transform = clip_transform(224)
+    aesthetic_scores_list = []
+
+    # Process in batches
+    for i in range(0, len(frames), BATCH_SIZE):
+        frame_batch = frames[i : i + BATCH_SIZE]
+        frame_batch = image_transform(frame_batch)
+        frame_batch = frame_batch.to(device)
+
+        with torch.no_grad():
+            image_feats = clip_model.encode_image(frame_batch).to(torch.float32)
+            image_feats = F.normalize(image_feats, dim=-1, p=2)
+            aesthetic_scores = aesthetic_model(image_feats).squeeze(dim=-1)
+
+        aesthetic_scores_list.append(aesthetic_scores)
+
+    # Combine all scores
+    aesthetic_scores = torch.cat(aesthetic_scores_list, dim=0)
+    normalized_aesthetic_scores = aesthetic_scores / 10.0
+    avg_score = torch.mean(normalized_aesthetic_scores, dim=0, keepdim=True)
+
+    return avg_score.item()
+
+
+def evaluate_drifting_aesthetic(aesthetic_model, clip_model, video_path, height=384, width=640, device="cuda"):
+    """
+    Evaluate drifting aesthetic for a single video.
+    Returns: (drift_score, start_score, end_score)
+    """
+    # Load video frames
+    images = load_video(video_path, height=height, width=width)
+
+    total_frames = len(images)
+    num_drift_frames = max(1, int(total_frames * DRIFT_RATIO))
+
+    # Extract start and end portions
+    start_frames = images[:num_drift_frames]
+    end_frames = images[-num_drift_frames:]
+
+    # Calculate scores for each portion
+    start_score = evaluate_aesthetic_on_frames(aesthetic_model, clip_model, start_frames, device)
+    end_score = evaluate_aesthetic_on_frames(aesthetic_model, clip_model, end_frames, device)
+
+    # Calculate drift as absolute difference
+    drift_score = abs(start_score - end_score)
+
+    return drift_score, start_score, end_score
+
+
+def main(args):
+    baseline_name = os.path.basename(args.video_dir)
+    output_path = os.path.join(args.output_path, baseline_name)
+    output_json_path = os.path.join(output_path, "drifting_aesthetic_results.json")
+
+    # Set device
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Using device: {device}")
+
+    # Load CSV file
+    if not os.path.exists(args.input_csv):
+        raise FileNotFoundError(f"CSV file not found: {args.input_csv}")
+
+    df = pd.read_csv(args.input_csv)
+    df_dict = df.set_index("id").to_dict("index")
+
+    # Validate CSV columns
+    required_columns = ["id", "duration"]
+    for col in required_columns:
+        if col not in df.columns:
+            raise ValueError(f"CSV must contain '{col}' column. Found columns: {df.columns.tolist()}")
+
+    # Load existing results if available
+    existing_results = {}
+    if os.path.exists(output_json_path):
+        print(f"Found existing results at {output_json_path}, loading...")
+        with open(output_json_path, "r") as f:
+            existing_data = json.load(f)
+            for item in existing_data.get("per_video_results", []):
+                existing_results[item["id"]] = item
+        print(f"Loaded {len(existing_results)} existing results")
+
+    # Get video files
+    video_files = glob.glob(os.path.join(args.video_dir, "*_*_ori*.mp4"))
+    video_files.sort(key=lambda x: int(re.search(r"(\d+)_", os.path.basename(x)).group(1)))
+    print(f"\nFound {len(video_files)} videos in directory")
+
+    # Check which videos need processing
+    results = []
+    drift_scores = []
+    videos_to_process = []
+
+    for video_path in video_files:
+        video_name = os.path.basename(video_path)
+        parts = video_name.replace(".mp4", "").split("_")
+        video_id = int(parts[0])
+
+        if video_id not in df_dict:
+            print(f"Warning: Video {video_name} (id={video_id}) not found in CSV, skipping")
+            continue
+
+        # Check if already processed
+        if video_id in existing_results:
+            # Use existing result
+            results.append(existing_results[video_id])
+            drift_scores.append(existing_results[video_id]["drift_aesthetic_score"])
+        else:
+            # Need to process
+            videos_to_process.append((video_path, video_id, video_name))
+
+    print(f"Already processed: {len(existing_results)} videos")
+    print(f"Need to process: {len(videos_to_process)} videos")
+
+    # Process remaining videos
+    if videos_to_process:
+        # Load models
+        print("Loading CLIP model...")
+        clip_model, preprocess = clip.load(args.clip_model_path, device=device)
+
+        print("Loading aesthetic predictor model...")
+        aesthetic_model = get_aesthetic_model(args.aesthetic_model_path).to(device)
+
+        print("\nEvaluating remaining videos...")
+        for video_path, video_id, video_name in tqdm(videos_to_process):
+            try:
+                drift_score, start_score, end_score = evaluate_drifting_aesthetic(
+                    aesthetic_model,
+                    clip_model,
+                    video_path,
+                    height=args.height,
+                    width=args.width,
+                    device=device,
+                )
+
+                result_item = {
+                    "id": video_id,
+                    "video_name": video_name,
+                    "drift_aesthetic_score": drift_score,
+                    "start_aesthetic_score": start_score,
+                    "end_aesthetic_score": end_score,
+                }
+                results.append(result_item)
+                drift_scores.append(drift_score)
+
+            except Exception as e:
+                print(f"Error processing {video_name}: {str(e)}")
+                continue
+    else:
+        print("No videos to process. Skipping evaluation.")
+        return
+
+    # Sort all results by video_id
+    results_sorted = sorted(results, key=lambda x: x["id"])
+
+    # Calculate overall metrics
+    if drift_scores:
+        avg_drift = sum(drift_scores) / len(drift_scores)
+
+        output = {
+            "metric": "drifting_aesthetic",
+            "description": f"Start-end contrast of aesthetic (first/last {DRIFT_RATIO * 100:.0f}% frames)",
+            "average_drift_score": avg_drift,
+            "num_videos": len(drift_scores),
+            "per_video_results": results_sorted,
+        }
+
+        # Save results
+        os.makedirs(output_path, exist_ok=True)
+        with open(output_json_path, "w") as f:
+            json.dump(output, f, indent=2)
+
+        print(f"\n{'=' * 60}")
+        print("Results Summary:")
+        print(f"{'=' * 60}")
+        print(f"Average Drifting Aesthetic Score: {avg_drift:.4f}")
+        print("(Lower is better - indicates less quality drift)")
+        print(f"Number of videos evaluated: {len(drift_scores)}")
+        print(f"Results saved to: {output_json_path}")
+        print(f"{'=' * 60}\n")
+    else:
+        print("No videos were successfully evaluated!")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Evaluate drifting aesthetic using CLIP + LAION aesthetic predictor")
+
+    # Input/Output arguments
+    parser.add_argument("--height", type=str, default=384)
+    parser.add_argument("--width", type=str, default=640)
+    parser.add_argument("--input_csv", type=str, default="playground/helios_t2v_prompts.csv")
+    parser.add_argument("--video_dir", type=str, default="playground/toy-video")
+    parser.add_argument("--output_path", type=str, default="playground/results")
+
+    # Model arguments
+    parser.add_argument("--clip_model_path", type=str, default="checkpoints/aesthetic_model/ViT-L-14.pt")
+    parser.add_argument(
+        "--aesthetic_model_path", type=str, default="checkpoints/aesthetic_model/sa_0_4_vit_l_14_linear.pth"
+    )
+
+    args = parser.parse_args()
+
+    main(args)

Helios/eval/6_get_drifting_motion_smoothness.py

@@ -0,0 +1,336 @@
+import argparse
+import glob
+import json
+import os
+import re
+
+import cv2
+import numpy as np
+import pandas as pd
+import torch
+from omegaconf import OmegaConf
+from tqdm import tqdm
+
+from utils.third_party.amt.utils.build_utils import build_from_cfg
+from utils.third_party.amt.utils.utils import InputPadder, check_dim_and_resize, img2tensor, tensor2img
+from utils.utils import align_dimension
+
+
+# Percentage of frames to use for start/end portions
+DRIFT_RATIO = 0.15
+
+
+class FrameProcess:
+    def __init__(self, height=384, width=640):
+        self.height = height
+        self.width = width
+
+    def get_frames(self, video_path):
+        """Extract frames from MP4 video"""
+        frame_list = []
+        video = cv2.VideoCapture(video_path)
+
+        original_width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH))
+        original_height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        original_aspect_ratio = original_width / original_height
+
+        if self.width > self.height:
+            target_width = self.width
+            target_height = int(self.width / original_aspect_ratio)
+        else:
+            target_height = self.height
+            target_width = int(self.height * original_aspect_ratio)
+
+        target_height = align_dimension(target_height, 2)
+        target_width = align_dimension(target_width, 2)
+
+        while video.isOpened():
+            success, frame = video.read()
+            if success:
+                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                frame = cv2.resize(frame, (target_width, target_height))
+                frame_list.append(frame)
+            else:
+                break
+        video.release()
+        assert frame_list != [], "No frames extracted from video"
+        return frame_list
+
+    def extract_frame(self, frame_list, start_from=0):
+        extract = []
+        for i in range(start_from, len(frame_list), 2):
+            extract.append(frame_list[i])
+        return extract
+
+
+class MotionSmoothnessEvaluator:
+    def __init__(self, config, ckpt, height=384, width=640, device="cuda"):
+        self.device = device
+        self.config = config
+        self.ckpt = ckpt
+        self.niters = 1
+        self.height = height
+        self.width = width
+        self.initialization()
+        self.load_model()
+
+    def load_model(self):
+        """Load AMT model"""
+        cfg_path = self.config
+        ckpt_path = self.ckpt
+        network_cfg = OmegaConf.load(cfg_path).network
+        network_name = network_cfg.name
+        print(f"Loading [{network_name}] from [{ckpt_path}]...")
+
+        self.model = build_from_cfg(network_cfg)
+        ckpt = torch.load(ckpt_path, map_location="cpu", weights_only=False)
+        self.model.load_state_dict(ckpt["state_dict"])
+        self.model = self.model.to(self.device)
+        self.model.eval()
+
+    def initialization(self):
+        """Initialize parameters based on device"""
+        if self.device.type == "cuda":
+            self.anchor_resolution = 1024 * 512
+            self.anchor_memory = 1500 * 1024**2
+            self.anchor_memory_bias = 2500 * 1024**2
+            self.vram_avail = torch.cuda.get_device_properties(self.device).total_memory
+        else:
+            self.anchor_resolution = 8192 * 8192
+            self.anchor_memory = 1
+            self.anchor_memory_bias = 0
+            self.vram_avail = 1
+
+        self.embt = torch.tensor(1 / 2).float().view(1, 1, 1, 1).to(self.device)
+        self.fp = FrameProcess(height=self.height, width=self.width)
+
+    def compute_motion_score_on_frames(self, frames):
+        """Calculate motion smoothness score for a list of frames"""
+        if len(frames) < 4:
+            return 0.0
+
+        frame_list = self.fp.extract_frame(frames, start_from=0)
+        if len(frame_list) < 2:
+            return 0.0
+
+        # Convert to tensors
+        inputs = [img2tensor(frame).to(self.device) for frame in frame_list]
+
+        inputs = check_dim_and_resize(inputs)
+        h, w = inputs[0].shape[-2:]
+        scale = (
+            self.anchor_resolution
+            / (h * w)
+            * np.sqrt((self.vram_avail - self.anchor_memory_bias) / self.anchor_memory)
+        )
+        scale = 1 if scale > 1 else scale
+        scale = 1 / np.floor(1 / np.sqrt(scale) * 16) * 16
+
+        padding = int(16 / scale)
+        padder = InputPadder(inputs[0].shape, padding)
+        inputs = padder.pad(*inputs)
+
+        # Frame interpolation
+        iters = int(self.niters)
+        for i in range(iters):
+            outputs = [inputs[0]]
+            for in_0, in_1 in zip(inputs[:-1], inputs[1:]):
+                in_0 = in_0.to(self.device)
+                in_1 = in_1.to(self.device)
+                with torch.no_grad():
+                    imgt_pred = self.model(in_0, in_1, self.embt, scale_factor=scale, eval=True)["imgt_pred"]
+                outputs += [imgt_pred.cpu(), in_1.cpu()]
+            inputs = outputs
+
+        # Calculate VFI score
+        outputs = padder.unpad(*outputs)
+        outputs = [tensor2img(out) for out in outputs]
+        vfi_score = self.vfi_score(frames, outputs)
+        norm = (255.0 - vfi_score) / 255.0
+
+        return norm
+
+    def vfi_score(self, ori_frames, interpolate_frames):
+        """Calculate video frame interpolation quality score"""
+        ori = self.fp.extract_frame(ori_frames, start_from=1)
+        interpolate = self.fp.extract_frame(interpolate_frames, start_from=1)
+
+        scores = []
+        min_len = min(len(ori), len(interpolate))
+        for i in range(min_len):
+            scores.append(self.get_diff(ori[i], interpolate[i]))
+
+        if len(scores) == 0:
+            return 0.0
+        return np.mean(np.array(scores))
+
+    def get_diff(self, img1, img2):
+        """Calculate absolute difference between two images"""
+        img = cv2.absdiff(img1, img2)
+        return np.mean(img)
+
+    def evaluate_drifting(self, video_path):
+        """
+        Evaluate drifting motion smoothness for a single video.
+        Returns: (drift_score, start_score, end_score)
+        """
+        frames = self.fp.get_frames(video_path)
+        total_frames = len(frames)
+        num_drift_frames = max(4, int(total_frames * DRIFT_RATIO))  # Need at least 4 frames for AMT
+
+        # Extract start and end portions
+        start_frames = frames[:num_drift_frames]
+        end_frames = frames[-num_drift_frames:]
+
+        # Calculate scores for each portion
+        start_score = self.compute_motion_score_on_frames(start_frames)
+        end_score = self.compute_motion_score_on_frames(end_frames)
+
+        # Calculate drift as absolute difference
+        drift_score = abs(start_score - end_score)
+
+        return drift_score, start_score, end_score
+
+
+def main(args):
+    baseline_name = os.path.basename(args.video_dir)
+    output_path = os.path.join(args.output_path, baseline_name)
+    output_json_path = os.path.join(output_path, "drifting_motion_smoothness_results.json")
+
+    # Set device
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Using device: {device}")
+
+    # Load CSV file
+    if not os.path.exists(args.input_csv):
+        raise FileNotFoundError(f"CSV file not found: {args.input_csv}")
+
+    df = pd.read_csv(args.input_csv)
+    df_dict = df.set_index("id").to_dict("index")
+
+    # Validate CSV columns
+    required_columns = ["id", "duration"]
+    for col in required_columns:
+        if col not in df.columns:
+            raise ValueError(f"CSV must contain '{col}' column. Found columns: {df.columns.tolist()}")
+
+    # Load existing results if available
+    existing_results = {}
+    if os.path.exists(output_json_path):
+        print(f"Found existing results at {output_json_path}, loading...")
+        with open(output_json_path, "r") as f:
+            existing_data = json.load(f)
+            for item in existing_data.get("per_video_results", []):
+                existing_results[item["id"]] = item
+        print(f"Loaded {len(existing_results)} existing results")
+
+    # Get video files
+    video_files = glob.glob(os.path.join(args.video_dir, "*_*_ori*.mp4"))
+    video_files.sort(key=lambda x: int(re.search(r"(\d+)_", os.path.basename(x)).group(1)))
+    print(f"\nFound {len(video_files)} videos in directory")
+
+    # Check which videos need processing
+    results = []
+    drift_scores = []
+    videos_to_process = []
+
+    for video_path in video_files:
+        video_name = os.path.basename(video_path)
+        parts = video_name.replace(".mp4", "").split("_")
+        video_id = int(parts[0])
+
+        if video_id not in df_dict:
+            print(f"Warning: Video {video_name} (id={video_id}) not found in CSV, skipping")
+            continue
+
+        # Check if already processed
+        if video_id in existing_results:
+            # Use existing result
+            results.append(existing_results[video_id])
+            drift_scores.append(existing_results[video_id]["drift_motion_smoothness_score"])
+        else:
+            # Need to process
+            videos_to_process.append((video_path, video_id, video_name))
+
+    print(f"Already processed: {len(existing_results)} videos")
+    print(f"Need to process: {len(videos_to_process)} videos")
+
+    # Process remaining videos
+    if videos_to_process:
+        # Load model
+        print("Loading AMT model...")
+        evaluator = MotionSmoothnessEvaluator(
+            args.config, args.smoothness_model_path, height=args.height, width=args.width, device=device
+        )
+
+        print("\nEvaluating remaining videos...")
+        for video_path, video_id, video_name in tqdm(videos_to_process):
+            try:
+                drift_score, start_score, end_score = evaluator.evaluate_drifting(video_path)
+
+                result_item = {
+                    "id": video_id,
+                    "video_name": video_name,
+                    "drift_motion_smoothness_score": float(drift_score),
+                    "start_motion_smoothness_score": float(start_score),
+                    "end_motion_smoothness_score": float(end_score),
+                }
+                results.append(result_item)
+                drift_scores.append(drift_score)
+
+            except Exception as e:
+                print(f"Error processing {video_name}: {str(e)}")
+                continue
+    else:
+        print("No videos to process. Skipping evaluation.")
+        return
+
+    # Sort all results by video_id
+    results_sorted = sorted(results, key=lambda x: x["id"])
+
+    # Calculate overall metrics
+    if drift_scores:
+        avg_drift = sum(drift_scores) / len(drift_scores)
+
+        output = {
+            "metric": "drifting_motion_smoothness",
+            "description": f"Start-end contrast of motion smoothness (first/last {DRIFT_RATIO * 100:.0f}% frames)",
+            "average_drift_score": avg_drift,
+            "num_videos": len(drift_scores),
+            "per_video_results": results_sorted,
+        }
+
+        # Save results
+        os.makedirs(output_path, exist_ok=True)
+        with open(output_json_path, "w") as f:
+            json.dump(output, f, indent=2)
+
+        print(f"\n{'=' * 60}")
+        print("Results Summary:")
+        print(f"{'=' * 60}")
+        print(f"Average Drifting Motion Smoothness Score: {avg_drift:.4f}")
+        print("(Lower is better - indicates less motion quality drift)")
+        print(f"Number of videos evaluated: {len(drift_scores)}")
+        print(f"Results saved to: {output_json_path}")
+        print(f"{'=' * 60}\n")
+    else:
+        print("No videos were successfully evaluated!")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Evaluate drifting motion smoothness using AMT model")
+
+    # Input/Output arguments
+    parser.add_argument("--height", type=str, default=384)
+    parser.add_argument("--width", type=str, default=640)
+    parser.add_argument("--input_csv", type=str, default="playground/helios_t2v_prompts.csv")
+    parser.add_argument("--video_dir", type=str, default="playground/toy-video")
+    parser.add_argument("--output_path", type=str, default="playground/results")
+
+    # Model arguments
+    parser.add_argument("--config", type=str, default="checkpoints/AMT-S.yaml")
+    parser.add_argument("--smoothness_model_path", type=str, default="checkpoints/amt_model/amt-s.pth")
+
+    args = parser.parse_args()
+
+    main(args)

Helios/eval/7_get_drifting_semantic.py

@@ -0,0 +1,268 @@
+import argparse
+import glob
+import json
+import os
+import re
+
+import pandas as pd
+import torch
+from tqdm import tqdm
+
+from utils.third_party.ViCLIP.simple_tokenizer import SimpleTokenizer
+from utils.third_party.ViCLIP.viclip import ViCLIP
+from utils.utils import clip_transform, load_video_frames
+
+
+# Percentage of frames to use for start/end portions
+DRIFT_RATIO = 0.15
+
+
+def get_text_features(model, input_text, tokenizer, text_feature_dict={}):
+    """Get text features from ViCLIP"""
+    if input_text in text_feature_dict:
+        return text_feature_dict[input_text]
+
+    text_template = f"{input_text}"
+    with torch.no_grad():
+        text_features = model.encode_text(text_template).float()
+        text_features /= text_features.norm(dim=-1, keepdim=True)
+        text_feature_dict[input_text] = text_features
+
+    return text_features
+
+
+def get_vid_features(model, input_frames):
+    """Get video features from ViCLIP"""
+    with torch.no_grad():
+        clip_feat = model.encode_vision(input_frames, test=True).float()
+        clip_feat /= clip_feat.norm(dim=-1, keepdim=True)
+    return clip_feat
+
+
+def evaluate_semantic_on_portion(
+    model,
+    tokenizer,
+    video_path,
+    prompt,
+    height=384,
+    width=640,
+    device="cuda",
+    start_ratio=0.0,
+    end_ratio=DRIFT_RATIO,
+    num_frames=8,
+):
+    """Evaluate semantic consistency on a portion of the video"""
+    image_transform = clip_transform(224)
+
+    with torch.no_grad():
+        # Load video frames from the specified portion
+        images = load_video_frames(
+            video_path, start_ratio, end_ratio, num_frames=num_frames, height=height, width=width
+        )
+        images = image_transform(images)
+        images = images.to(device)
+
+        # Get features
+        clip_feat = get_vid_features(model, images.unsqueeze(0))
+        text_feat = get_text_features(model, prompt, tokenizer)
+
+        # Calculate similarity
+        logit_per_text = clip_feat @ text_feat.T
+        score = float(logit_per_text[0][0].cpu())
+
+    return score
+
+
+def evaluate_drifting_semantic(model, tokenizer, video_path, prompt, height=384, width=640, device="cuda"):
+    """
+    Evaluate drifting semantic consistency for a single video.
+    Returns: (drift_score, start_score, end_score)
+    """
+    # Evaluate start portion (first 15%)
+    start_score = evaluate_semantic_on_portion(
+        model,
+        tokenizer,
+        video_path,
+        prompt,
+        height=height,
+        width=width,
+        device=device,
+        start_ratio=0.0,
+        end_ratio=DRIFT_RATIO,
+        num_frames=8,
+    )
+
+    # Evaluate end portion (last 15%)
+    end_score = evaluate_semantic_on_portion(
+        model,
+        tokenizer,
+        video_path,
+        prompt,
+        height=height,
+        width=width,
+        device=device,
+        start_ratio=1.0 - DRIFT_RATIO,
+        end_ratio=1.0,
+        num_frames=8,
+    )
+
+    # Calculate drift as absolute difference
+    drift_score = abs(start_score - end_score)
+
+    return drift_score, start_score, end_score
+
+
+def main(args):
+    baseline_name = os.path.basename(args.video_dir)
+    output_path = os.path.join(args.output_path, baseline_name)
+    output_json_path = os.path.join(output_path, "drifting_semantic_results.json")
+
+    # Set device
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Using device: {device}")
+
+    # Load CSV file
+    if not os.path.exists(args.input_csv):
+        raise FileNotFoundError(f"CSV file not found: {args.input_csv}")
+
+    df = pd.read_csv(args.input_csv)
+    df_dict = df.set_index("id").to_dict("index")
+
+    # Validate CSV columns
+    required_columns = ["id", "duration", "prompt"]
+    for col in required_columns:
+        if col not in df.columns:
+            raise ValueError(f"CSV must contain '{col}' column. Found columns: {df.columns.tolist()}")
+
+    # Load existing results if available
+    existing_results = {}
+    if os.path.exists(output_json_path):
+        print(f"Found existing results at {output_json_path}, loading...")
+        with open(output_json_path, "r") as f:
+            existing_data = json.load(f)
+            for item in existing_data.get("per_video_results", []):
+                existing_results[item["id"]] = item
+        print(f"Loaded {len(existing_results)} existing results")
+
+    # Get video files
+    video_files = glob.glob(os.path.join(args.video_dir, "*_*_ori*.mp4"))
+    video_files.sort(key=lambda x: int(re.search(r"(\d+)_", os.path.basename(x)).group(1)))
+    print(f"\nFound {len(video_files)} videos in directory")
+
+    # Check which videos need processing
+    results = []
+    drift_scores = []
+    videos_to_process = []
+
+    for video_path in video_files:
+        video_name = os.path.basename(video_path)
+        parts = video_name.replace(".mp4", "").split("_")
+        video_id = int(parts[0])
+
+        if video_id not in df_dict:
+            print(f"Warning: Video {video_name} (id={video_id}) not found in CSV, skipping")
+            continue
+
+        # Check if already processed
+        if video_id in existing_results:
+            # Use existing result
+            results.append(existing_results[video_id])
+            drift_scores.append(existing_results[video_id]["drift_semantic_score"])
+        else:
+            # Need to process
+            prompt = df_dict[video_id]["prompt"]
+            videos_to_process.append((video_path, video_id, video_name, prompt))
+
+    print(f"Already processed: {len(existing_results)} videos")
+    print(f"Need to process: {len(videos_to_process)} videos")
+
+    # Process remaining videos
+    if videos_to_process:
+        # Load ViCLIP model
+        print("Loading ViCLIP model...")
+        tokenizer_path = os.path.join(args.semantic_model_path, "bpe_simple_vocab_16e6.txt.gz")
+        semantic_model_path = os.path.join(args.semantic_model_path, "ViClip-InternVid-10M-FLT.pth")
+
+        tokenizer = SimpleTokenizer(tokenizer_path)
+        viclip = ViCLIP(tokenizer=tokenizer, pretrain=semantic_model_path).to(device)
+        viclip.eval()
+
+        print("\nEvaluating remaining videos...")
+        for video_path, video_id, video_name, prompt in tqdm(videos_to_process):
+            try:
+                drift_score, start_score, end_score = evaluate_drifting_semantic(
+                    viclip,
+                    tokenizer,
+                    video_path,
+                    prompt,
+                    height=args.height,
+                    width=args.width,
+                    device=device,
+                )
+
+                result_item = {
+                    "id": video_id,
+                    "video_name": video_name,
+                    "prompt": prompt,
+                    "drift_semantic_score": drift_score,
+                    "start_semantic_score": start_score,
+                    "end_semantic_score": end_score,
+                }
+                results.append(result_item)
+                drift_scores.append(drift_score)
+
+            except Exception as e:
+                print(f"Error processing {video_name}: {str(e)}")
+                continue
+    else:
+        print("No videos to process. Skipping evaluation.")
+        return
+
+    # Sort all results by video_id
+    results_sorted = sorted(results, key=lambda x: x["id"])
+
+    # Calculate overall metrics
+    if drift_scores:
+        avg_drift = sum(drift_scores) / len(drift_scores)
+
+        output = {
+            "metric": "drifting_semantic",
+            "description": f"Start-end contrast of semantic consistency (first/last {DRIFT_RATIO * 100:.0f}% frames)",
+            "average_drift_score": avg_drift,
+            "num_videos": len(drift_scores),
+            "per_video_results": results_sorted,
+        }
+
+        # Save results
+        os.makedirs(output_path, exist_ok=True)
+        with open(output_json_path, "w") as f:
+            json.dump(output, f, indent=2)
+
+        print(f"\n{'=' * 60}")
+        print("Results Summary:")
+        print(f"{'=' * 60}")
+        print(f"Average Drifting Semantic Score: {avg_drift:.4f}")
+        print("(Lower is better - indicates less semantic drift)")
+        print(f"Number of videos evaluated: {len(drift_scores)}")
+        print(f"Results saved to: {output_json_path}")
+        print(f"{'=' * 60}\n")
+    else:
+        print("No videos were successfully evaluated!")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Evaluate drifting semantic consistency using ViCLIP model")
+
+    # Input/Output arguments
+    parser.add_argument("--height", type=str, default=384)
+    parser.add_argument("--width", type=str, default=640)
+    parser.add_argument("--input_csv", type=str, default="playground/helios_t2v_prompts.csv")
+    parser.add_argument("--video_dir", type=str, default="playground/toy-video")
+    parser.add_argument("--output_path", type=str, default="playground/results")
+
+    # Model arguments
+    parser.add_argument("--semantic_model_path", type=str, default="checkpoints/ViCLIP")
+
+    args = parser.parse_args()
+
+    main(args)

Helios/eval/8_get_drifting_naturalness.py

@@ -0,0 +1,339 @@
+import argparse
+import base64
+import glob
+import json
+import os
+import re
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import cv2
+import pandas as pd
+from openai import OpenAI
+from tqdm import tqdm
+
+
+# Percentage of frames to use for start/end portions
+DRIFT_RATIO = 0.15
+
+PROMPT_VIDEO_DETECTION = """
+Your task is to analyze ##NUM_FRAMES## frames sampled across a long video (e.g., ~1500 frames) to determine if it is AI-generated.
+
+### CONTEXT:
+Frames are sampled at wide intervals. Scene changes or camera movements are expected. Focus on individual frame integrity and local physical logic rather than global consistency.
+
+### EVALUATION CRITERIA:
+1. **Single-Frame Technical Flaws**: Look for AI-specific rendering "hallucinations":
+   - **Textures**: "Melting" surfaces, plastic-like skin, or chaotic patterns in complex areas (e.g., water ripples, foliage, fire).
+   - **Edges**: Unnatural blurring or "auras" around moving subjects where they meet the background.
+2. **Local Physical Logic**: Within any given frame or small cluster of frames:
+   - Do shadows and reflections align with the visible light sources?
+   - Are objects interacting naturally with their environment (e.g., feet touching the ground properly, hands grasping objects correctly)?
+3. **Biological Anomalies**: If humans appear, inspect for:
+   - Anatomical errors: Extra fingers, asymmetric eyes, or "fused" teeth.
+   - Unnatural micro-expressions or "dead" eyes lacking specular highlights.
+4. **Transient Artifacts**: Even in sparse samples, look for "ghosting" or objects that seem to be partially transparent or merging with other objects (common in AI diffusion).
+
+### SCORING SCALE:
+- 1 (Definitely AI): Clear anatomical deformities, "melting" textures, or impossible physical interactions.
+- 2 (Likely AI): Presence of "uncanny valley" effects, suspicious texture smoothing, or minor physical illogic.
+- 3 (Uncertain): Ambiguous; could be low-quality real-world footage, heavy motion blur, or high-end AI.
+- 4 (Likely Real): Consistent organic details, natural motion blur, and logical lighting.
+- 5 (Definitely Real): Perfect high-frequency details (pores, fabric, grain), flawless physics, and natural anatomy.
+
+### OUTPUT INSTRUCTION:
+Return ONLY the integer score (1-5). No explanation.
+""".strip()
+
+
+def image_to_base64(image):
+    """Convert image to base64 string"""
+    _, buffer = cv2.imencode(".jpg", image)
+    return base64.b64encode(buffer).decode("utf-8")
+
+
+def resize_long_side(image, target_long=512):
+    """Resize image keeping aspect ratio"""
+    h, w = image.shape[:2]
+    if h >= w:
+        new_h = target_long
+        new_w = int(w * target_long / h)
+    else:
+        new_w = target_long
+        new_h = int(h * target_long / w)
+    return cv2.resize(image, (new_w, new_h), interpolation=cv2.INTER_AREA)
+
+
+def extract_frames_from_portion(video_path, num_frames=8, portion="start"):
+    """
+    Extract frames from start or end portion of video
+    Args:
+        video_path: Path to video file
+        num_frames: Number of frames to extract
+        portion: 'start' or 'end'
+    """
+    cap = cv2.VideoCapture(video_path)
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+    # Calculate portion boundaries
+    num_drift_frames = max(1, int(total_frames * DRIFT_RATIO))
+
+    if portion == "start":
+        start_frame = 0
+        end_frame = num_drift_frames
+    else:  # end
+        start_frame = total_frames - num_drift_frames
+        end_frame = total_frames
+
+    # Extract frames evenly from the portion
+    frame_interval = max((end_frame - start_frame) // num_frames, 1)
+    frames = []
+
+    for i in range(num_frames):
+        frame_idx = start_frame + i * frame_interval
+        if frame_idx >= end_frame:
+            break
+        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
+        ret, frame = cap.read()
+        if ret:
+            resized = resize_long_side(frame, 512)
+            frames.append(resized)
+
+    cap.release()
+    return frames
+
+
+def call_gpt(image_frames_base64, model_name, api_key, base_url, num_frames=8, temperature=0.0):
+    """Call GPT API to evaluate video naturalness"""
+    client = OpenAI(api_key=api_key, base_url=base_url)
+
+    content_list = []
+    for frame in image_frames_base64:
+        content_list.append(
+            {
+                "type": "image_url",
+                "image_url": {"url": f"data:image/jpeg;base64,{frame}"},
+            }
+        )
+    content_list.append({"type": "text", "text": PROMPT_VIDEO_DETECTION.replace("##NUM_FRAMES##", str(num_frames))})
+
+    response = client.chat.completions.create(
+        model=model_name,
+        stream=False,
+        temperature=temperature,
+        messages=[{"role": "user", "content": content_list}],
+    )
+
+    score = response.choices[0].message.content.strip()
+    return score
+
+
+def evaluate_portion_naturalness(video_path, api_key, model_name, base_url, num_frames=8, portion="start"):
+    """Evaluate naturalness for start or end portion of video"""
+    try:
+        frames = extract_frames_from_portion(video_path, num_frames, portion)
+        frames_base64 = [image_to_base64(f) for f in frames]
+        score_str = call_gpt(frames_base64, model_name, api_key, base_url, num_frames)
+
+        # Parse score
+        score = float(score_str)
+        score = max(1.0, min(5.0, score))
+        # Normalize to [0, 1] (1-5 to 0-1)
+        score = (score - 1) / 4.0
+
+        return score, score_str
+    except Exception as e:
+        print(f"Error evaluating video portion {portion}: {str(e)}")
+        raise
+
+
+def evaluate_drifting_naturalness(video_path, api_key, model_name, base_url, num_frames=8):
+    """
+    Evaluate drifting naturalness for a single video
+    Returns: (drift_score, start_score, end_score, start_raw, end_raw)
+    """
+    # Evaluate start portion
+    start_score, start_raw = evaluate_portion_naturalness(
+        video_path, api_key, model_name, base_url, num_frames, portion="start"
+    )
+
+    # Evaluate end portion
+    end_score, end_raw = evaluate_portion_naturalness(
+        video_path, api_key, model_name, base_url, num_frames, portion="end"
+    )
+
+    # Calculate drift as absolute difference
+    drift_score = abs(start_score - end_score)
+
+    return drift_score, start_score, end_score, start_raw, end_raw
+
+
+def process_video_worker(args_tuple):
+    """Worker function for parallel processing"""
+    video_path, video_id, video_name, api_key, model_name, base_url, num_frames = args_tuple
+    try:
+        drift_score, start_score, end_score, start_raw, end_raw = evaluate_drifting_naturalness(
+            video_path, api_key, model_name, base_url, num_frames
+        )
+        return {
+            "id": video_id,
+            "video_name": video_name,
+            "drift_naturalness_score": drift_score,
+            "start_naturalness_score": start_score,
+            "end_naturalness_score": end_score,
+            "start_raw_score": start_raw,
+            "end_raw_score": end_raw,
+        }
+    except Exception as e:
+        print(f"Error processing {video_name}: {str(e)}")
+        return None
+
+
+def main(args):
+    baseline_name = os.path.basename(args.video_dir)
+    output_path = os.path.join(args.output_path, baseline_name)
+    output_json_path = os.path.join(output_path, "drifting_naturalness_results.json")
+
+    print(f"Using API: {args.base_url}")
+    print(f"Model: {args.model_name}")
+
+    # Load CSV file
+    if not os.path.exists(args.input_csv):
+        raise FileNotFoundError(f"CSV file not found: {args.input_csv}")
+
+    df = pd.read_csv(args.input_csv)
+    df_dict = df.set_index("id").to_dict("index")
+
+    # Validate CSV columns
+    required_columns = ["id", "duration"]
+    for col in required_columns:
+        if col not in df.columns:
+            raise ValueError(f"CSV must contain '{col}' column. Found columns: {df.columns.tolist()}")
+
+    # Load existing results if available
+    existing_results = {}
+    if os.path.exists(output_json_path):
+        print(f"Found existing results at {output_json_path}, loading...")
+        with open(output_json_path, "r") as f:
+            existing_data = json.load(f)
+            for item in existing_data.get("per_video_results", []):
+                existing_results[item["id"]] = item
+        print(f"Loaded {len(existing_results)} existing results")
+
+    # Get video files
+    video_files = glob.glob(os.path.join(args.video_dir, "*_*_ori*.mp4"))
+    video_files.sort(key=lambda x: int(re.search(r"(\d+)_", os.path.basename(x)).group(1)))
+    print(f"\nFound {len(video_files)} videos in directory")
+
+    # Check which videos need processing
+    results = []
+    drift_scores = []
+    tasks = []
+
+    for video_path in video_files:
+        video_name = os.path.basename(video_path)
+        parts = video_name.replace(".mp4", "").split("_")
+        video_id = int(parts[0])
+
+        if video_id not in df_dict:
+            print(f"Warning: Video {video_name} (id={video_id}) not found in CSV, skipping")
+            continue
+
+        # Check if already processed
+        if video_id in existing_results:
+            # Use existing result
+            results.append(existing_results[video_id])
+            drift_scores.append(existing_results[video_id]["drift_naturalness_score"])
+        else:
+            # Need to process
+            tasks.append(
+                (
+                    video_path,
+                    video_id,
+                    video_name,
+                    args.api_key,
+                    args.model_name,
+                    args.base_url,
+                    args.num_frames,
+                )
+            )
+
+    print(f"Already processed: {len(existing_results)} videos")
+    print(f"Need to process: {len(tasks)} videos")
+
+    # Evaluate remaining videos in parallel
+    if tasks:
+        results_dict = {}
+
+        print(f"Evaluating videos with {args.num_workers} workers...")
+
+        with ThreadPoolExecutor(max_workers=args.num_workers) as executor:
+            future_to_idx = {executor.submit(process_video_worker, task): idx for idx, task in enumerate(tasks)}
+
+            for future in tqdm(as_completed(future_to_idx), total=len(tasks), desc="Evaluating"):
+                idx = future_to_idx[future]
+                result = future.result()
+                if result is not None:
+                    results_dict[idx] = result
+
+        # Add new results in order
+        new_results = [results_dict[i] for i in sorted(results_dict.keys())]
+        results.extend(new_results)
+        drift_scores.extend([r["drift_naturalness_score"] for r in new_results])
+    else:
+        print("No videos to process. Skipping evaluation.")
+        return
+
+    # Sort all results by video_id
+    results_sorted = sorted(results, key=lambda x: x["id"])
+
+    # Calculate overall metrics and save final results
+    if drift_scores:
+        avg_drift = sum(drift_scores) / len(drift_scores)
+
+        output = {
+            "metric": "drifting_naturalness",
+            "description": f"Start-end contrast of naturalness (first/last {DRIFT_RATIO * 100:.0f}% frames)",
+            "average_drift_score": avg_drift,
+            "num_videos": len(drift_scores),
+            "model_name": args.model_name,
+            "per_video_results": results_sorted,
+        }
+
+        # Save results
+        os.makedirs(output_path, exist_ok=True)
+
+        with open(output_json_path, "w") as f:
+            json.dump(output, f, indent=2)
+
+        print(f"\n{'=' * 60}")
+        print("Results Summary:")
+        print(f"{'=' * 60}")
+        print(f"Average Drifting Naturalness Score: {avg_drift:.4f}")
+        print("(Lower is better - indicates less quality drift)")
+        print(f"Number of videos evaluated: {len(drift_scores)}")
+        print(f"Results saved to: {output_json_path}")
+        print(f"{'=' * 60}\n")
+    else:
+        print("No videos were successfully evaluated!")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Evaluate drifting naturalness using VLM")
+
+    # Input/Output arguments
+    parser.add_argument("--input_csv", type=str, default="playground/helios_t2v_prompts.csv")
+    parser.add_argument("--video_dir", type=str, default="playground/toy-video")
+    parser.add_argument("--output_path", type=str, default="playground/results")
+
+    # API arguments
+    parser.add_argument("--api_key", type=str, required=True)
+    parser.add_argument("--model_name", type=str, default="gpt-5.2-2025-12-11")
+    parser.add_argument("--base_url", type=str, default=None)
+
+    # Evaluation arguments
+    parser.add_argument("--num_frames", type=int, default=16)
+    parser.add_argument("--num_workers", type=int, default=64)
+
+    args = parser.parse_args()
+
+    main(args)

Helios/eval/9_merge_all_scores.py

@@ -0,0 +1,230 @@
+import argparse
+import json
+import os
+
+
+WEIGHTS_SHORT = {
+    "aesthetic": 0.10,
+    "motion_amplitude": 0.10,
+    "motion_smoothness": 0.10,
+    "semantic": 0.35,
+    "naturalness": 0.35,
+}
+
+WEIGHTS_LONG = {
+    "aesthetic": 0.03,
+    "motion_amplitude": 0.03,
+    "motion_smoothness": 0.03,
+    "semantic": 0.255,
+    "naturalness": 0.255,
+    "drifting_aesthetic": 0.099,
+    "drifting_motion_smoothness": 0.099,
+    "drifting_semantic": 0.099,
+    "drifting_naturalness": 0.099,
+}
+
+
+METRIC_RANGES = {
+    "aesthetic": {"min": 0, "max": 1},
+    "motion_amplitude": {"min": 0, "max": 1},
+    "motion_smoothness": {"min": 0, "max": 1},
+    "naturalness": {"min": 0, "max": 1},
+    "semantic": {"min": 0, "max": 1},
+    "drifting_aesthetic": {"min": 0, "max": 1},
+    "drifting_motion_smoothness": {"min": 0, "max": 1},
+    "drifting_naturalness": {"min": 0, "max": 1},
+    "drifting_semantic": {"min": 0, "max": 1},
+}
+
+METRIC_ALIASES = {
+    "aesthetic_score": "aesthetic",
+    "motion_amplitude_score": "motion_amplitude",
+    "motion_smoothness_score": "motion_smoothness",
+    "naturalness_score": "naturalness",
+    "semantic_score": "semantic",
+    "drift_aesthetic_score": "drifting_aesthetic",
+    "drift_motion_smoothness_score": "drifting_motion_smoothness",
+    "drift_naturalness_score": "drifting_naturalness",
+    "drift_semantic_score": "drifting_semantic",
+}
+
+RATING_SCALE = 10
+
+SCORING_RULES_SHORT = {
+    "aesthetic": {
+        "type": "higher_better",
+        "thresholds": [0.70, 0.65, 0.60, 0.55, 0.50, 0.45, 0.40, 0.35, 0.30],
+    },
+    "motion_amplitude": {
+        "type": "higher_better",
+        "thresholds": [0.45, 0.40, 0.35, 0.30, 0.25, 0.20, 0.15, 0.10, 0.05],
+    },
+    "motion_smoothness": {
+        "type": "higher_better",
+        "thresholds": [0.99, 0.98, 0.97, 0.96, 0.95, 0.94, 0.93, 0.92, 0.91],
+    },
+    "semantic": {"type": "higher_better", "thresholds": [0.30, 0.29, 0.28, 0.27, 0.26, 0.25, 0.24, 0.23, 0.22]},
+    "naturalness": {"type": "higher_better", "thresholds": [0.65, 0.60, 0.55, 0.50, 0.45, 0.40, 0.30, 0.25, 0.20]},
+}
+
+SCORING_RULES_LONG = {
+    "aesthetic": {
+        "type": "higher_better",
+        "thresholds": [0.70, 0.65, 0.60, 0.55, 0.50, 0.45, 0.40, 0.45, 0.40],
+    },
+    "motion_amplitude": {
+        "type": "higher_better",
+        "thresholds": [0.45, 0.40, 0.35, 0.30, 0.25, 0.20, 0.15, 0.10, 0.05],
+    },
+    "motion_smoothness": {
+        "type": "higher_better",
+        "thresholds": [0.99, 0.98, 0.97, 0.96, 0.95, 0.94, 0.93, 0.92, 0.91],
+    },
+    "semantic": {"type": "higher_better", "thresholds": [0.30, 0.29, 0.28, 0.27, 0.26, 0.25, 0.24, 0.23, 0.22]},
+    "naturalness": {"type": "higher_better", "thresholds": [0.65, 0.60, 0.55, 0.50, 0.45, 0.40, 0.30, 0.25, 0.20]},
+    "drifting_aesthetic": {
+        "type": "lower_better",
+        "thresholds": [0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09],
+    },
+    "drifting_motion_smoothness": {
+        "type": "lower_better",
+        "thresholds": [0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09],
+    },
+    "drifting_semantic": {
+        "type": "lower_better",
+        "thresholds": [0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09],
+    },
+    "drifting_naturalness": {
+        "type": "lower_better",
+        "thresholds": [0.06, 0.08, 0.10, 0.12, 0.14, 0.16, 0.18, 0.20, 0.22],
+    },
+}
+
+
+def calculate_weighted_rating(summary_data, is_long):
+    weights = WEIGHTS_LONG if is_long else WEIGHTS_SHORT
+    total_rating = 0.0
+
+    all_metrics = {**summary_data.get("non_drifting", {}), **summary_data.get("drifting", {})}
+
+    print(f"\nCalculating Weighted Total Rating ({'Long' if is_long else 'Short'}):")
+    for metric, weight in weights.items():
+        if metric in all_metrics and all_metrics[metric]["rating"] is not None:
+            contribution = all_metrics[metric]["rating"] * weight
+            total_rating += contribution
+            print(f"  - {metric}: {all_metrics[metric]['rating']} * {weight} = {contribution:.4f}")
+        else:
+            print(f"  ⚠ Warning: Metric '{metric}' missing for weighting!")
+
+    return round(total_rating, 4)
+
+
+def convert_to_rating(normalized_score, metric_key, is_long):
+    if normalized_score is None:
+        return None
+    canonical_key = METRIC_ALIASES.get(metric_key, metric_key)
+    rule = SCORING_RULES_LONG[canonical_key] if is_long else SCORING_RULES_SHORT[canonical_key]
+
+    rule_type = rule["type"]
+    thresholds = rule["thresholds"]
+
+    if rule_type == "higher_better":
+        for i, threshold in enumerate(thresholds):
+            if normalized_score >= threshold:
+                return RATING_SCALE - i
+        return 1
+    elif rule_type == "lower_better":
+        for i, threshold in enumerate(thresholds):
+            if normalized_score <= threshold:
+                return RATING_SCALE - i
+        return 1
+    elif rule_type == "target_based":
+        target = rule["target"]
+        distance = abs(normalized_score - target)
+        for i, threshold in enumerate(thresholds):
+            if distance <= threshold:
+                return RATING_SCALE - i
+        return 1
+    return None
+
+
+def normalize_score(score, metric_key):
+    if score is None or not isinstance(score, (int, float)):
+        return None
+    canonical_key = METRIC_ALIASES.get(metric_key, metric_key)
+    if canonical_key not in METRIC_RANGES:
+        return score
+    min_val, max_val = METRIC_RANGES[canonical_key]["min"], METRIC_RANGES[canonical_key]["max"]
+    normalized = (score - min_val) / (max_val - min_val)
+    return max(0.0, min(1.0, normalized))
+
+
+def is_valid_metric(metric_key, is_long):
+    canonical_key = METRIC_ALIASES.get(metric_key, metric_key)
+    rules = SCORING_RULES_LONG if is_long else SCORING_RULES_SHORT
+    return canonical_key in rules
+
+
+def merge_results(input_dir, output_path=None, is_long=False):
+    result_files = [f for f in os.listdir(input_dir) if f.endswith("_results.json")]
+    if not result_files:
+        return None, None
+
+    merged = {
+        "rating_scale": RATING_SCALE,
+        "summary": {"non_drifting": {}, "drifting": {}},
+        "per_video": {},
+    }
+
+    for result_file in sorted(result_files):
+        metric_key = result_file.replace("_results.json", "")
+        if not is_valid_metric(metric_key, is_long):
+            continue
+
+        try:
+            with open(os.path.join(input_dir, result_file), "r") as f:
+                data = json.load(f)
+
+            score = data.get("average_score") or data.get("average_drift_score")
+            norm_score = normalize_score(score, metric_key)
+            rating = convert_to_rating(norm_score, metric_key, is_long)
+
+            metric_summary = {
+                "name": metric_key.replace("_", " ").title(),
+                "raw_score": score,
+                "normalized_score": norm_score,
+                "rating": rating,
+                "num_videos": data.get("num_videos", 0),
+            }
+
+            if metric_key.startswith("drifting_"):
+                merged["summary"]["drifting"][metric_key] = metric_summary
+            else:
+                merged["summary"]["non_drifting"][metric_key] = metric_summary
+
+        except Exception as e:
+            print(f" Error loading {result_file}: {e}")
+
+    total_weighted = calculate_weighted_rating(merged["summary"], is_long)
+    merged["summary"]["total_weighted_rating"] = total_weighted
+    print(f"\n>>> FINAL WEIGHTED RATING: {total_weighted}\n")
+
+    if output_path is None:
+        output_path = os.path.join(input_dir, "merged_results.json")
+    with open(output_path, "w") as f:
+        json.dump(merged, f, indent=2)
+
+    return merged, output_path
+
+
+def main(args):
+    merge_results(args.input_dir, args.output_path, args.is_long)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_dir", type=str, default="playground/results/toy-video")
+    parser.add_argument("--output_path", type=str, default=None)
+    parser.add_argument("--is_long", action="store_true")
+    args = parser.parse_args()
+    main(args)

Helios/eval/README.md

@@ -0,0 +1,167 @@
+# <u>Evaluation Pipeline</u> by *Helios*
+This repository shows how to evaluate custom models described in the [Helios](https://arxiv.org/abs/2603.04379) paper.
+
+## 🎉 Overview
+
+### Basic Metrics
+Measuring the basic quality of videos.
+
+| Metric | Description | Method |
+|--------|-------------|-------|
+| **Aesthetic** | Aesthetic quality score | CLIP + LAION Aesthetic |
+| **Motion Amplitude** | Motion dynamics degree | Farneback |
+| **Motion Smoothness** | Temporal motion smoothness | AMT |
+| **Semantic** | Overall semantic consistency | ViCLIP |
+| **Naturalness** | Overall semantic consistency | GPT-5.2-2025-12-11 |
+
+### Drifting Metrics
+Measuring start-end quality contrast to detect temporal drifting:
+
+$$\Delta M_{drift}(V) = |M(V_{start}) - M(V_{end})|$$
+
+Where $V_{start}$ is the first 15% of frames and $V_{end}$ is the last 15% of frames.
+
+| Metric | Description |
+|--------|-------------|
+| **Drifting Aesthetic** | Aesthetic drifting |
+| **Drifting Motion Smoothness** | Motion smoothness drifting |
+| **Drifting Semantic** | Semantic consistency drifting |
+| **Drifting Naturalness** | Naturalness drifting |
+
+### Throughput Metrics
+Measureing the end-to-end performance at a resolution of 384 × 640 under default frame lengths. The reported results include the latency of both the VAE and the text encoder. We should enable all acceleration techniques officially adopted by each model—such as FlashAttention, torch compile,
+KV-cache, and warm-up—to achieve optimal throughput.
+
+| Metric | Description |
+|--------|-------------|
+| **Throughput (FPS)** | Inference speed |
+| **Throughput Score** | Inference speed |
+
+
+## ⚙️ Requirements and Installation
+
+### Prepare Environment
+
+```bash
+# Activate conda environment
+conda activate helios
+
+# Install additional dependencies
+pip install -r requirements.txt
+```
+
+### Prepare Ckpts
+```bash
+# Option 1: via script
+cd checkpoints/ && bash get_checkpoints.sh
+
+# Option 2: via Hugging Face CLI
+hf download BestWishYsh/HeliosBench-Weights --local-dir ./
+```
+
+Once ready, the weights will be organized in this format:
+
+```
+📦 checkpoints/
+├── 📂 aesthetic_model/
+│   ├── 📄 sa_0_4_vit_l_14_linear.pth
+│   └── 📄 ViT-L-14.pt
+└── 📂 ViCLIP/
+    ├── 📄 bpe_simple_vocab_16e6.txt.gz
+    └── 📄 ViClip-InternVid-10M-FLT.pth
+```
+
+
+## 🗝️ Usage
+
+### Prepare Your Videos
+
+```
+📦 model_name/
+├── 📄 1_*_ori*.mp4
+├── 📄 2_*_ori*.mp4
+├── ...
+└── 📄 {id}_{target-duration}_{true-duration}.mp4
+```
+
+### Run Metrics:
+
+```bash
+# Option 1: Run all metrics (recommended)
+bash run_metrics.sh          # for single GPU
+bash run_metrics_ddp.sh      # for multi-GPU
+
+# Option 2: Run individual scripts (same results)
+python 0_get_aesthetic.py
+python 1_get_motion_amplitude.py
+python 2_get_motion_smoothness.py
+python 3_get_semantic.py
+python 4_get_naturalness.py
+
+python 5_get_drifting_aesthetic.py
+python 6_get_drifting_motion_smoothness.py
+python 7_get_drifting_semantic.py
+python 8_get_drifting_naturalness.py
+```
+
+## Output
+
+Results are saved as JSON files in the `playground/results` directory:
+
+```bash
+# Convert raw metrics to rating and merge them into one json
+python 9_merge_all_scores.py
+python 10_merge_all_results.py
+```
+
+A merged summary is saved to `playground/results/merged_results.json`.
+
+```json
+{
+  "num_models": 1,
+  "score_type": "rating",
+  "metrics": [
+    "aesthetic",
+    "drifting_aesthetic",
+    "drifting_motion_smoothness",
+    "drifting_naturalness",
+    "drifting_semantic",
+    "motion_amplitude",
+    "motion_smoothness",
+    "naturalness",
+    "semantic",
+    "total_weighted_rating"
+  ],
+  "models": {
+    "toy-video": {
+      "aesthetic": 9,
+      "motion_amplitude": 3,
+      "motion_smoothness": 10,
+      "naturalness": 7,
+      "semantic": 8,
+      "drifting_aesthetic": 8,
+      "drifting_motion_smoothness": 10,
+      "drifting_naturalness": 10,
+      "drifting_semantic": 10,
+      "total_weighted_rating": 8.247
+    }
+  },
+  "rating_scale": 10
+}
+```
+
+For the **Throughput Score**, you should first measure the end-to-end throughput (in FPS). The score increases by 1 point for every 3.2 FPS and is clipped to the range $[1, 10]$ like other metrics. Formally,
+
+$$
+\text{Throughput Score} =
+\begin{cases}
+1, & \text{if } \text{FPS} \le 3.2, \\
+\left\lceil \dfrac{\text{FPS}}{3.2} \right\rceil, & \text{if } 3.2 < \text{FPS} < 32, \\
+10, & \text{if } \text{FPS} \ge 32.
+\end{cases}
+$$
+
+## 🔒 Acknowledgement
+
+* This project wouldn't be possible without the following open-sourced repositories: [OpenS2V-Nexus](https://github.com/PKU-YuanGroup/OpenS2V-Nexus), [VBench](https://github.com/Vchitect/VBench), [ChronoMagic-Bench](https://github.com/PKU-YuanGroup/ChronoMagic-Bench), [FramePack](https://github.com/lllyasviel/FramePack).
+* Existing metrics are insufficient for accurately assessing the performance of video generation models. A promising direction is to develop perceptually aligned metrics that better reflect human judgment.

Helios/eval/kill.sh

@@ -0,0 +1,13 @@
+pkill -9 -f 0_get_aesthetic.py
+pkill -9 -f 1_get_motion_amplitude.py
+pkill -9 -f 2_get_motion_smoothness.py
+pkill -9 -f 3_get_semantic.py
+pkill -9 -f 4_get_naturalness.py
+
+pkill -9 -f 0_get_drifting_aesthetic.py
+pkill -9 -f 1_get_drifting_motion_smoothness.py
+pkill -9 -f 2_get_drifting_semantic.py
+pkill -9 -f 3_get_drifting_naturalness.py
+
+pkill -9 -f run_metrics.sh
+pkill -9 -f run_metrics_ddp.sh

Helios/eval/requirements.txt

@@ -0,0 +1,31 @@
+torch==2.7.1
+torchvision==0.22.1
+torchaudio==2.7.1
+triton==3.3.1
+# diffusers==0.36.0
+# transformers==4.57.6
+# sentence-transformers==5.2.3
+git+https://github.com/SHYuanBest/diffusers.git@test
+git+https://github.com/huggingface/transformers.git
+git+https://github.com/huggingface/sentence-transformers.git
+accelerate==1.12.0
+deepspeed==0.18.4
+peft==0.18.1
+huggingface-hub==1.4.1
+zstandard==0.25.0
+wandb==0.23.0
+video-reader-rs==0.4.1
+numpy<2.0.0
+pandas
+pillow
+tqdm
+scipy
+opencv-python
+scikit-image
+ffmpeg-python
+video-reader-rs
+openai-clip
+pyiqa
+timm>=0.9
+omegaconf
+easydict

Helios/eval/run_metrics.sh

@@ -0,0 +1,104 @@
+INPUT_CSV="playground/helios_t2v_prompts.csv"
+BASE_OUTPUT_DIR="playground/results"
+PLAYGROUND_DIR="playground"
+
+SCORE_TYPE="rating"  # ["raw", "normalized", "rating"]
+
+NUM_WORKERS=32
+API_KEY=""
+BASE_URL=""
+
+GPU_ID=0
+
+for MODEL_DIR in "$PLAYGROUND_DIR"/*/ ; do
+    MODEL_NAME=$(basename "$MODEL_DIR")
+    OUTPUT_DIR="$BASE_OUTPUT_DIR/$MODEL_NAME"
+
+    if [ ! -d "$MODEL_DIR" ]; then
+        continue
+    fi
+    
+    echo "Processing model: $MODEL_NAME"
+    VIDEO_DIR="$MODEL_DIR"
+
+    # Aesthetic
+    CUDA_VISIBLE_DEVICES=$GPU_ID python 0_get_aesthetic.py \
+        --input_csv $INPUT_CSV \
+        --video_dir $VIDEO_DIR \
+        --output_path $OUTPUT_DIR \
+        --clip_model_path "checkpoints/aesthetic_model/ViT-L-14.pt" \
+        --aesthetic_model_path "checkpoints/aesthetic_model/sa_0_4_vit_l_14_linear.pth" &
+
+    # Motion Amplitude
+    CUDA_VISIBLE_DEVICES=$GPU_ID python 1_get_motion_amplitude.py \
+        --input_csv $INPUT_CSV \
+        --video_dir $VIDEO_DIR \
+        --output_path $OUTPUT_DIR \
+        --num_workers $NUM_WORKERS &
+
+    # Motion Smoothness
+    CUDA_VISIBLE_DEVICES=$GPU_ID python 2_get_motion_smoothness.py \
+        --input_csv $INPUT_CSV \
+        --video_dir $VIDEO_DIR \
+        --output_path $OUTPUT_DIR \
+        --smoothness_model_path "checkpoints/amt_model/amt-s.pth" &
+
+    # Semantic
+    CUDA_VISIBLE_DEVICES=$GPU_ID python 3_get_semantic.py \
+        --input_csv $INPUT_CSV \
+        --video_dir $VIDEO_DIR \
+        --output_path $OUTPUT_DIR \
+        --semantic_model_path "checkpoints/ViCLIP" &
+
+    # Naturalness
+    CUDA_VISIBLE_DEVICES=$GPU_ID python 4_get_naturalness.py \
+        --input_csv $INPUT_CSV \
+        --video_dir $VIDEO_DIR \
+        --output_path $OUTPUT_DIR \
+        --api_key $API_KEY \
+        --base_url $BASE_URL \
+        --num_workers $NUM_WORKERS &
+
+    # Drifting Aesthetic
+    CUDA_VISIBLE_DEVICES=$GPU_ID python 5_get_drifting_aesthetic.py \
+        --input_csv $INPUT_CSV \
+        --video_dir $VIDEO_DIR \
+        --output_path $OUTPUT_DIR \
+        --clip_model_path "checkpoints/aesthetic_model/ViT-L-14.pt" \
+        --aesthetic_model_path "checkpoints/aesthetic_model/sa_0_4_vit_l_14_linear.pth" &
+
+    # Drifting Motion Smoothness
+    CUDA_VISIBLE_DEVICES=$GPU_ID python 6_get_drifting_motion_smoothness.py \
+        --input_csv $INPUT_CSV \
+        --video_dir $VIDEO_DIR \
+        --output_path $OUTPUT_DIR \
+        --smoothness_model_path "checkpoints/amt_model/amt-s.pth" &
+
+    # Drifting Semantic
+    CUDA_VISIBLE_DEVICES=$GPU_ID python 7_get_drifting_semantic.py \
+        --input_csv $INPUT_CSV \
+        --video_dir $VIDEO_DIR \
+        --output_path $OUTPUT_DIR \
+        --semantic_model_path "checkpoints/ViCLIP" &
+
+    # Drifting Naturalness
+    CUDA_VISIBLE_DEVICES=$GPU_ID python 8_get_drifting_naturalness.py \
+        --input_csv $INPUT_CSV \
+        --video_dir $VIDEO_DIR \
+        --output_path $OUTPUT_DIR \
+        --api_key $API_KEY \
+        --base_url $BASE_URL \
+        --num_workers $NUM_WORKERS &
+
+    wait
+
+    # Merge All Scores
+    python 9_merge_all_scores.py \
+        --input_dir "$OUTPUT_DIR" \
+        --is_long
+done
+
+# Merge All Results
+python 10_merge_all_results.py \
+    --input_dir "$BASE_OUTPUT_DIR" \
+    --score_type "$SCORE_TYPE"

Helios/eval/run_metrics_ddp.sh

@@ -0,0 +1,138 @@
+INPUT_CSV="playground/helios_t2v_prompts.csv"
+BASE_OUTPUT_DIR="playground/results"
+PLAYGROUND_DIR="playground"
+
+SCORE_TYPE="rating"  # ["raw", "normalized", "rating"]
+
+NUM_WORKERS=32
+API_KEY=""
+BASE_URL=""
+
+NUM_MACHINES=${ARNOLD_WORKER_NUM:-1}
+NUM_PROCESSES_PER_MACHINE=${ARNOLD_WORKER_GPU:-$(nvidia-smi --list-gpus | wc -l)}
+TOTAL_GPUS=$((NUM_MACHINES * NUM_PROCESSES_PER_MACHINE))
+
+echo "Detected configuration:"
+echo "  Number of machines: $NUM_MACHINES"
+echo "  GPUs per machine: $NUM_PROCESSES_PER_MACHINE"
+echo "  Total GPUs: $TOTAL_GPUS"
+
+MODEL_DIRS=()
+for MODEL_DIR in "$PLAYGROUND_DIR"/*/ ; do
+    if [ -d "$MODEL_DIR" ]; then
+        MODEL_DIRS+=("$MODEL_DIR")
+    fi
+done
+
+echo "Found ${#MODEL_DIRS[@]} models to process"
+
+process_model() {
+    MODEL_DIR=$1
+    GPU_ID=$2
+    
+    MODEL_NAME=$(basename "$MODEL_DIR")
+    OUTPUT_DIR="$BASE_OUTPUT_DIR/$MODEL_NAME"
+    VIDEO_DIR="$MODEL_DIR"
+    
+    echo "Processing model: $MODEL_NAME on GPU $GPU_ID"
+
+    # Aesthetic
+    CUDA_VISIBLE_DEVICES=$GPU_ID python 0_get_aesthetic.py \
+        --input_csv $INPUT_CSV \
+        --video_dir $VIDEO_DIR \
+        --output_path $OUTPUT_DIR \
+        --clip_model_path "checkpoints/aesthetic_model/ViT-L-14.pt" \
+        --aesthetic_model_path "checkpoints/aesthetic_model/sa_0_4_vit_l_14_linear.pth" &
+    
+    # Motion Amplitude
+    CUDA_VISIBLE_DEVICES=$GPU_ID python 1_get_motion_amplitude.py \
+        --input_csv $INPUT_CSV \
+        --video_dir $VIDEO_DIR \
+        --output_path $OUTPUT_DIR \
+        --num_workers $NUM_WORKERS &
+
+    # Motion Smoothness
+    CUDA_VISIBLE_DEVICES=$GPU_ID python 2_get_motion_smoothness.py \
+        --input_csv $INPUT_CSV \
+        --video_dir $VIDEO_DIR \
+        --output_path $OUTPUT_DIR \
+        --smoothness_model_path "checkpoints/amt_model/amt-s.pth" &
+    
+    # Semantic
+    CUDA_VISIBLE_DEVICES=$GPU_ID python 3_get_semantic.py \
+        --input_csv $INPUT_CSV \
+        --video_dir $VIDEO_DIR \
+        --output_path $OUTPUT_DIR \
+        --semantic_model_path "checkpoints/ViCLIP" &
+
+    # Naturalness
+    CUDA_VISIBLE_DEVICES=$GPU_ID python 4_get_naturalness.py \
+        --input_csv $INPUT_CSV \
+        --video_dir $VIDEO_DIR \
+        --output_path $OUTPUT_DIR \
+        --api_key $API_KEY \
+        --base_url $BASE_URL \
+        --num_workers $NUM_WORKERS &
+
+    # Drifting Aesthetic
+    CUDA_VISIBLE_DEVICES=$GPU_ID python 5_get_drifting_aesthetic.py \
+        --input_csv $INPUT_CSV \
+        --video_dir $VIDEO_DIR \
+        --output_path $OUTPUT_DIR \
+        --clip_model_path "checkpoints/aesthetic_model/ViT-L-14.pt" \
+        --aesthetic_model_path "checkpoints/aesthetic_model/sa_0_4_vit_l_14_linear.pth" &
+    
+    # Drifting Motion Smoothness
+    CUDA_VISIBLE_DEVICES=$GPU_ID python 6_get_drifting_motion_smoothness.py \
+        --input_csv $INPUT_CSV \
+        --video_dir $VIDEO_DIR \
+        --output_path $OUTPUT_DIR \
+        --smoothness_model_path "checkpoints/amt_model/amt-s.pth" &
+    
+    # Drifting Semantic
+    CUDA_VISIBLE_DEVICES=$GPU_ID python 7_get_drifting_semantic.py \
+        --input_csv $INPUT_CSV \
+        --video_dir $VIDEO_DIR \
+        --output_path $OUTPUT_DIR \
+        --semantic_model_path "checkpoints/ViCLIP" &
+
+    # Drifting Naturalness
+    CUDA_VISIBLE_DEVICES=$GPU_ID python 8_get_drifting_naturalness.py \
+        --input_csv $INPUT_CSV \
+        --video_dir $VIDEO_DIR \
+        --output_path $OUTPUT_DIR \
+        --api_key $API_KEY \
+        --base_url $BASE_URL \
+        --num_workers $NUM_WORKERS &
+
+    wait 
+
+    # Merge All Scores
+    python 9_merge_all_scores.py \
+        --input_dir "$OUTPUT_DIR" \
+        --is_long
+    
+    echo "Finished processing model: $MODEL_NAME on GPU $GPU_ID"
+}
+
+idx=0
+for MODEL_DIR in "${MODEL_DIRS[@]}"; do
+    LOCAL_GPU_ID=$((idx % NUM_PROCESSES_PER_MACHINE))
+    
+    process_model "$MODEL_DIR" $LOCAL_GPU_ID &
+    
+    idx=$((idx + 1))
+    
+    if [ $((idx % NUM_PROCESSES_PER_MACHINE)) -eq 0 ]; then
+        wait -n
+    fi
+done
+
+wait
+
+echo "All models processed!"
+
+# Merge All Results
+python 10_merge_all_results.py \
+    --input_dir "$BASE_OUTPUT_DIR" \
+    --score_type "$SCORE_TYPE"

Helios/eval_moviebench/0_get_aesthetic.py

@@ -0,0 +1,171 @@
+import argparse
+import json
+import os
+
+import clip
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from tqdm import tqdm
+
+from utils.utils import clip_transform, discover_benchmark_videos, enrich_result_record, load_existing_results, load_video
+
+
+BATCH_SIZE = 32
+
+
+def get_aesthetic_model(path_to_model):
+    """Load the aesthetic predictor model"""
+    m = nn.Linear(768, 1)
+    s = torch.load(path_to_model, map_location="cpu", weights_only=False)
+    m.load_state_dict(s)
+    m.eval()
+    return m
+
+
+def evaluate_aesthetic(aesthetic_model, clip_model, video_path, height=384, width=640, device="cuda"):
+    """Evaluate aesthetic quality for a single video"""
+    aesthetic_model.eval()
+    clip_model.eval()
+
+    # Load video frames
+    images = load_video(video_path, height=height, width=width)
+    image_transform = clip_transform(224)
+    aesthetic_scores_list = []
+
+    # Process in batches
+    for i in range(0, len(images), BATCH_SIZE):
+        image_batch = images[i : i + BATCH_SIZE]
+        image_batch = image_transform(image_batch)
+        image_batch = image_batch.to(device)
+
+        with torch.no_grad():
+            image_feats = clip_model.encode_image(image_batch).to(torch.float32)
+            image_feats = F.normalize(image_feats, dim=-1, p=2)
+            aesthetic_scores = aesthetic_model(image_feats).squeeze(dim=-1)
+
+        aesthetic_scores_list.append(aesthetic_scores)
+
+    # Combine all scores
+    aesthetic_scores = torch.cat(aesthetic_scores_list, dim=0)
+    normalized_aesthetic_scores = aesthetic_scores / 10.0
+    avg_score = torch.mean(normalized_aesthetic_scores, dim=0, keepdim=True)
+
+    return avg_score.item()
+
+
+def main(args):
+    baseline_name = os.path.basename(args.video_dir)
+    output_path = os.path.join(args.output_path, baseline_name)
+    output_json_path = os.path.join(output_path, "aesthetic_results.json")
+
+    # Set device
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Using device: {device}")
+
+    # Load existing results if available
+    existing_results = load_existing_results(output_json_path)
+    if existing_results:
+        print(f"Found existing results at {output_json_path}, loading...")
+        print(f"Loaded {len(existing_results)} existing results")
+
+    # Get all videos to process
+    video_records = discover_benchmark_videos(args.video_dir, args.input_csv)
+    print(f"\nFound {len(video_records)} videos in directory")
+
+    # Check which videos need processing
+    results = []
+    scores = []
+    videos_to_process = []
+
+    for record in video_records:
+        if record["id"] in existing_results:
+            results.append(existing_results[record["id"]])
+            scores.append(existing_results[record["id"]]["aesthetic_score"])
+        else:
+            videos_to_process.append(record)
+
+    print(f"Already processed: {len(existing_results)} videos")
+    print(f"Need to process: {len(videos_to_process)} videos")
+
+    # Process remaining videos
+    if videos_to_process:
+        # Load models
+        print("Loading CLIP model...")
+        clip_model, preprocess = clip.load(args.clip_model_path, device=device)
+
+        print("Loading aesthetic predictor model...")
+        aesthetic_model = get_aesthetic_model(args.aesthetic_model_path).to(device)
+
+        print("\nEvaluating remaining videos...")
+        for record in tqdm(videos_to_process):
+            try:
+                score = evaluate_aesthetic(
+                    aesthetic_model,
+                    clip_model,
+                    record["video_path"],
+                    height=args.height,
+                    width=args.width,
+                    device=device,
+                )
+
+                result_item = enrich_result_record(record, aesthetic_score=score)
+                results.append(result_item)
+                scores.append(score)
+
+            except Exception as e:
+                print(f"Error processing {record['video_name']}: {str(e)}")
+                continue
+    else:
+        print("No videos to process. Skipping evaluation.")
+        return
+
+    # Calculate overall metrics
+    if scores:
+        avg_score = sum(scores) / len(scores)
+
+        # Sort results by video_id
+        results_sorted = sorted(results, key=lambda x: x["id"])
+
+        output = {
+            "metric": "aesthetic",
+            "average_score": avg_score,
+            "num_videos": len(scores),
+            "per_video_results": results_sorted,
+        }
+
+        # Save results
+        os.makedirs(output_path, exist_ok=True)
+        with open(output_json_path, "w") as f:
+            json.dump(output, f, indent=2)
+
+        print(f"\n{'=' * 60}")
+        print("Results Summary:")
+        print(f"{'=' * 60}")
+        print(f"Average Aesthetic Score: {avg_score:.4f}")
+        print(f"Number of videos evaluated: {len(scores)}")
+        print(f"Results saved to: {output_json_path}")
+        print(f"{'=' * 60}\n")
+    else:
+        print("No videos were successfully evaluated!")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Evaluate video aesthetic using CLIP + LAION aesthetic predictor")
+
+    # Input/Output arguments
+    parser.add_argument("--height", type=int, default=384)
+    parser.add_argument("--width", type=int, default=640)
+    parser.add_argument("--input_csv", type=str, default="playground/helios_t2v_prompts.csv")
+    parser.add_argument("--video_dir", type=str, default="playground/toy-video")
+    parser.add_argument("--output_path", type=str, default="playground/results")
+
+    # Model arguments
+    parser.add_argument("--clip_model_path", type=str, default="checkpoints/aesthetic_model/ViT-L-14.pt")
+    parser.add_argument(
+        "--aesthetic_model_path", type=str, default="checkpoints/aesthetic_model/sa_0_4_vit_l_14_linear.pth"
+    )
+
+    args = parser.parse_args()
+
+    main(args)