Diffusion Model Outputs

# Gemini and text diffusion models
text_output = gemini_diffusion.generate(
    prompt="Write a technical blog post about quantum computing",
    max_tokens=1000,
    temperature=0.7,
    output_format="markdown"  # or "plain", "json", "code"
)
# Outputs: Structured text, code, documentation

# Stable Diffusion family
image_output = stable_diffusion.generate(
    prompt="ethereal landscape with bioluminescent plants",
    size=(1024, 1024),
    output_format="png"  # or "jpeg", "webp", "exr"
)

# AudioLDM, Stable Audio
audio_output = audio_diffusion.generate(
    prompt="jazz piano in a cozy cafe",
    duration=30.0,
    output_format="wav"  # or "mp3", "flac"
)

class TextDiffusionPipeline:
    def __init__(self, model="gemini-diffusion"):
        self.model = model
        self.output_formats = {
            "markdown": self.format_markdown,
            "json": self.format_json,
            "code": self.format_code,
            "latex": self.format_latex
        }
    
    def generate_documentation(self, topic, style="technical"):
        # Generate with diffusion model
        raw_output = self.diffusion_generate(
            prompt=f"Create {style} documentation for {topic}",
            structure_tokens=True,  # Maintain formatting
            coherence_weight=0.8    # Long-form consistency
        )
        
        # Post-process for different formats
        outputs = {
            "web": self.format_markdown(raw_output),
            "pdf": self.format_latex(raw_output),
            "api": self.format_json(raw_output)
        }
        
        return outputs

# Example usage
doc_gen = TextDiffusionPipeline()
docs = doc_gen.generate_documentation(
    topic="REST API endpoints",
    style="developer-friendly"
)

# Optimizing text diffusion outputs
text_optimization = {
    "coherence": {
        "technique": "semantic_guidance",
        "weight": 0.7,
        "benefit": "Better long-form consistency"
    },
    "structure": {
        "technique": "format_tokens",
        "examples": ["<h1>", "```code", "* bullet"],
        "benefit": "Maintains formatting"
    },
    "quality": {
        "technique": "multi_pass_refinement",
        "passes": 3,
        "benefit": "Reduces errors and improves flow"
    }
}

# Step 1: Generate your base asset
base_image = generate(
    prompt="fantasy sword, game asset, transparent background",
    width=1024,
    height=1024,
    model="SDXL"  # Great for detailed objects
)

# Step 2: Export for different uses
exports = {
    "game_asset": {"format": "png", "bit_depth": 16},      # Full quality
    "ui_preview": {"format": "webp", "quality": 85},      # Compressed
    "icon_set": {"format": "png", "resize": [64, 128, 256]} # Multiple sizes
}

# Optimized for quality AND efficiency
generation_config = {
    "base_resolution": {  # Start here, upscale later if needed
        "FLUX": (1024, 1024),
        "SDXL": (1024, 1024),
        "SD1.5": (512, 512)
    },
    "batch_strategy": {
        "variations": 4,     # Generate options
        "cherry_pick": true, # Select best
        "seed_increment": 1  # Consistent variations
    },
    "metadata_preservation": {  # Never lose your settings!
        "embed_in_file": true,
        "save_to_json": true,
        "include_workflow": true
    }
}

# Method 1: Two-Stage Generation (Recommended)
stage1 = generate(
    prompt="epic landscape",
    size=(1024, 1024),  # GPU-friendly
    model="FLUX"
)

stage2 = upscale(
    image=stage1,
    scale=4,  # → 4096×4096
    method="ESRGAN",  # or "Real-ESRGAN", "SwinIR"
    enhance=True  # Add details during upscale
)

# Method 2: Direct High-Res (16GB+ VRAM)
if gpu_memory >= 16:
    result = generate(
        prompt="epic landscape",
        size=(2048, 2048),
        steps=30,
        tiled_vae=True  # Memory optimization
    )

# Multi-channel export for professional workflows
exr_export = {
    "format": "exr",
    "channels": {
        "beauty": "RGBA",      # Final render
        "depth": "Z",          # Depth information
        "normals": "XYZ",      # Surface normals
        "cryptomatte": "ID"    # Object selection
    },
    "compression": "PIZ",      # Lossless compression
    "bit_depth": 32           # Full float precision
}

# ComfyUI: Enable multi-pass output
[VAE Decode] → [Save EXR] with channels

# ComfyUI Workflow for perfect loops
workflow = {
    "checkpoint": "your_favorite_model.safetensors",
    "motion_module": "animatediff_motion_adapter.ckpt",
    "settings": {
        "frames": 16,        # Powers of 2 work best
        "fps": 8,            # Double in post for smoothness
        "context_overlap": 4  # For seamless loops
    }
}

# Pro tip: Generate at 8fps, interpolate to 24fps

# The SVD Pipeline
Step 1: Generate stunning still image (FLUX/SDXL)
    ↓
Step 2: Feed to SVD
    ↓
Step 3: Get 4-second video
    ↓
Step 4: Loop or extend as needed

# Optimal settings
svd_config = {
    "model": "svd_xt",     # Extended version
    "frames": 25,          # Max quality
    "motion_scale": 1.0,   # Amount of movement
    "fps": 6,              # Native output
    "decode_chunk": 5      # For lower VRAM
}

# The Loop Master Pipeline
[Checkpoint] → [AnimateDiff] → [Context Options]
                                      ↓
                              frames=16, overlap=4
                                      ↓
                              [VAE Decode] → GIF/MP4

# Key settings for loops
loop_settings = {
    "frame_count": 16,      # Divisible by overlap
    "context_overlap": 4,    # Smooth transitions
    "fps_output": 30,       # Smooth playback
    "format": "gif",        # or "mp4" with loop flag
}

# SVD Pipeline for Dynamic Scenes
step1_generate = {
    "prompt": "serene lake at sunset",
    "model": "FLUX",
    "size": (1024, 576)  # SVD optimal ratio
}

step2_animate = {
    "model": "svd_xt_1_1",
    "conditioning_frames": 1,
    "motion_bucket": 127,  # 0-255, higher = more motion
    "augmentation": 0.0    # Keep original framing
}

step3_enhance = {
    "interpolate": "RIFE 4.6",
    "target_fps": 30,
    "smoothing": True
}

# The Interpolation Pipeline
original_video = "animatediff_8fps.mp4"  # Your AI output

# Option 1: RIFE (Fastest, great quality)
rife_interpolate(
    input=original_video,
    target_fps=30,  # 4x interpolation
    model="rife-v4.6"
)

# Option 2: FILM (Best quality, slower)
film_interpolate(
    input=original_video,
    target_fps=24,  # Film standard
    model="film_net"
)

# Option 3: Optical Flow (Built into most editors)
# Use After Effects, DaVinci Resolve, or Premiere

# Using AudioLDM 2 for sound effects
prompt = "peaceful forest ambience, birds chirping, gentle breeze"

sound = generate_audio(
    prompt=prompt,
    duration=10.0,      # seconds
    quality="high",     # auto-selects optimal settings
    format="game"       # optimizes for game engine
)

# Result: Perfectly loopable forest ambience

# Creating a complete track
music_prompt = """
genre: lo-fi hip hop
mood: relaxing, study music
instruments: piano, soft drums, vinyl crackle
tempo: 70 BPM
key: C minor
"""

track = stable_audio.generate(
    prompt=music_prompt,
    duration=45.0,
    sample_rate=44100,  # CD quality
    format="stems"      # Separate instruments!
)

# Export options
exports = {
    "master": "lofi_track.wav",      # Full mix
    "stems": {                       # For remixing
        "drums": "drums.wav",
        "melody": "melody.wav",
        "bass": "bass.wav"
    }
}

# Expressive speech generation
narration = bark.generate(
    text="Welcome... to the adventure of a lifetime. [laughs]",
    voice="narrator",     # Or clone a voice!
    emotion="mysterious",
    language="en",
    output_format={
        "sample_rate": 24000,  # Optimal for speech
        "encoding": "mp3",     # Compressed for dialogue
        "bitrate": 128         # Clear speech quality
    }
)

# Pro tip: Bark understands emotion markers
# [sighs], [laughs], [gasps], [clears throat]

# Method 1: Direct Generation (FLUX)
logo_prompt = '''
a modern minimalist logo design for "NEXUS AI", 
clean typography, tech company branding, 
white background, professional
'''

# Method 2: ControlNet Precision (Any model)
workflow = {
    "text_image": create_text_image("NEXUS AI", font="Arial"),
    "controlnet": "canny",
    "prompt": "futuristic tech logo, gradient colors",
    "strength": 0.8
}

# Method 3: Multi-pass Refinement
pass1 = generate("logo shape and colors")
pass2 = inpaint(pass1, mask=text_area, prompt="NEXUS AI text")

# Effective text style prompts
working_styles = {
    "neon": 'neon sign saying "OPEN 24/7" on brick wall, night photography',
    "carved": 'ancient stone tablet with carved text "WISDOM", archaeological photo',
    "handwritten": 'handwritten note saying "Thank You" in cursive on paper',
    "digital": 'LED display board showing "ARRIVAL GATE 5" in airport',
    "graffiti": 'street art mural with spray painted text "IMAGINE"',
    "3d": '3D metallic text "PREMIUM" with reflections and shadows',
    "vintage": 'vintage circus poster with text "AMAZING SHOW TONIGHT"'
}

# Each style includes context for better results

# Professional Book Cover Pipeline
step1 = "Background"
background = generate(
    "fantasy landscape, magical forest, ethereal lighting",
    size=(1600, 2400)  # 6x9 inch at 400 DPI
)

step2 = "Add Title"
title_area = define_region(top_third)
titled = inpaint(
    background,
    mask=title_area,
    prompt='book title "THE LAST MAGE" in golden fantasy lettering'
)

step3 = "Add Author"
author_area = define_region(bottom)
final = inpaint(
    titled,
    mask=author_area,
    prompt='author name "Jane Smith" in elegant serif font'
)

# Export for print
export_settings = {
    "format": "PDF",
    "color_space": "CMYK",
    "resolution": 400,
    "bleed": 0.125  # inches
}

# Single generation, multiple outputs
character_gen = ComfyUIWorkflow()

# Step 1: Generate the character
character_gen.add_node("CheckpointLoader", model="epicrealism")
character_gen.add_node("Prompt", text="fantasy warrior, full body")

# Step 2: Extract depth information
character_gen.add_node("MiDaS-DepthMapPreprocessor")
character_gen.add_node("SaveEXR", channels=["RGB", "Depth"])

# Result: One file with both image and depth
# Perfect for ARKit, ARCore, or Lens Studio

# Auto-segment for easy editing
segmentation_pipeline = {
    "generate": "complex scene with multiple objects",
    "segment": {
        "method": "SAM",  # Segment Anything Model
        "granularity": "object",  # or "part", "material"
        "output": "layered_psd"
    },
    "export": {
        "format": "PSD",
        "layers": [
            "background",
            "foreground_objects",
            "characters",
            "effects"
        ],
        "preserve_transparency": True
    }
}

# Open in Photoshop: Every object on its own layer!

# The Game Dev Special
game_export = MultiChannelExport()

game_export.configure({
    "base_color": {
        "format": "PNG",
        "sRGB": True,
        "resolution": 2048
    },
    "normal_map": {
        "format": "PNG", 
        "linear": True,
        "resolution": 2048
    },
    "roughness_metallic": {
        "format": "PNG",
        "channels": "RG",  # R=roughness, G=metallic
        "resolution": 1024
    },
    "ambient_occlusion": {
        "format": "PNG",
        "grayscale": True,
        "resolution": 1024
    }
})

# Generate once, get complete PBR texture set
result = game_export.process(ai_generation)

# Step 1: Generate perfect input image
concept = generate(
    prompt="fantasy sword, game asset, neutral lighting, white background",
    model="SDXL",
    # Pro tip: Simple backgrounds = better 3D
)

# Step 2: Convert to 3D (TripoSR for speed)
model_3d = triposr.process(
    image=concept,
    output_format="gltf",  # Web and game ready
    texture_resolution=1024
)

# Step 3: Export for your platform
exports = {
    "unity": export_fbx(model_3d, embed_textures=True),
    "web": export_gltf(model_3d, draco_compression=True),
    "blender": export_obj(model_3d, separate_materials=True)
}

# DreamGaussian Pipeline
image_to_gaussian = {
    "input": "character_portrait.png",
    "settings": {
        "elevation": 0,      # Camera angle
        "resolution": 512,   # Training resolution
        "iterations": 500    # Quality vs speed
    },
    "output": {
        "format": "ply",     # Point cloud format
        "splat_viewer": "web"  # Real-time preview
    }
}

# Result: Photorealistic 3D that runs everywhere

# NeRF for product visualization
product_nerf = {
    "capture": "36 photos around object",
    "training": {
        "model": "instant-ngp",  # NVIDIA's fast NeRF
        "time": "5-30 minutes",
        "quality": "photorealistic"
    },
    "export_options": [
        "video_turntable.mp4",
        "mesh_with_texture.obj",
        "voxel_grid.vdb",
        "point_cloud.ply"
    ]
}

# Multi-Modal Diffusion Pipeline
diffusion_pipeline = UnifiedDiffusionProcessor()

# Define base and variations
base_prompt = "minimalist {product} on white background, professional lighting"
products = ["watch", "headphones", "smartphone", "laptop", "camera"]
angles = ["front", "side", "angle", "detail"]

# Generate all combinations efficiently
for product in products:
    for angle in angles:
        product_pipeline.add_job({
            "prompt": base_prompt.format(product=product) + f", {angle} view",
            "model": "SDXL",
            "batch_size": 4,  # 4 variations per combo
            "export": {
                "web": {"format": "webp", "quality": 85},
                "print": {"format": "png", "dpi": 300},
                "thumbnail": {"format": "jpeg", "size": 256}
            }
        })

# Process overnight, wake up to 400+ images
product_pipeline.run(parallel=True, gpu_scheduling="efficient")

# The Content Creator's Smart Pipeline

class ContentPipeline:
    def __init__(self):
        self.platforms = {
            "instagram": {"size": (1080, 1080), "format": "jpeg"},
            "youtube": {"size": (1920, 1080), "format": "png"},
            "tiktok": {"size": (1080, 1920), "format": "mp4"},
            "twitter": {"size": (1200, 675), "format": "jpeg"}
        }
    
    def process_generation(self, image, base_name):
        results = {}
        
        # Generate once at high res
        master = enhance_to_4k(image)
        
        # Create platform-specific versions
        for platform, specs in self.platforms.items():
            processed = master.resize(specs["size"])
            
            # Platform-specific optimizations
            if platform == "instagram":
                processed = add_subtle_filter(processed)
            elif platform == "youtube":
                processed = add_thumbnail_text(processed)
            
            # Smart export
            filename = f"{base_name}_{platform}.{specs['format']}"
            processed.save(filename, optimize=True)
            results[platform] = filename
        
        return results

# Usage: One generation, all platforms covered
pipeline = ContentPipeline()
ai_image = generate("stunning sunset landscape")
all_versions = pipeline.process_generation(ai_image, "sunset_001")

# GPU Memory Management
optimization_tricks = {
    "batch_processing": {
        "tip": "Process similar resolutions together",
        "speedup": "2-3x"
    },
    "vae_tiling": {
        "tip": "Enable for high-res on limited VRAM",
        "tradeoff": "Slightly slower, much less memory"
    },
    "sequential_offload": {
        "tip": "Move models to CPU between uses",
        "benefit": "Run larger models on smaller GPUs"
    },
    "attention_slicing": {
        "tip": "Slice attention computation",
        "benefit": "50% memory reduction"
    }
}

# Diffusion-Aware Post-Processing
class DiffusionPostProcessor:
    def __init__(self):
        self.processors = {
            "text": self.process_text_diffusion,
            "image": self.process_image_diffusion,
            "audio": self.process_audio_diffusion,
            "video": self.process_video_diffusion,
            "3d": self.process_3d_diffusion
        }
    
    def process(self, image, generation_data):
        # Each step enhances the image
        for step_name, step_func in self.pipeline:
            image = step_func(image, generation_data)
            
        return image
    
    def smart_denoise(self, img, data):
        # Only denoise if high CFG was used
        if data.get('cfg_scale', 7) > 10:
            return denoise(img, strength=0.3)
        return img
    
    def color_grade(self, img, data):
        # Subtle enhancements
        img = adjust_vibrance(img, 1.1)  # 10% boost
        img = adjust_contrast(img, 1.05)  # 5% boost
        return img
    
    def adaptive_sharpen(self, img, data):
        # Sharpen based on resolution
        if img.width > 2048:
            return unsharp_mask(img, radius=1.5, amount=0.5)
        return img

# Usage
processor = ProPostProcessor()
final_image = processor.process(raw_ai_output, generation_settings)

# The Cinematic Video Pipeline
video_enhancement = {
    "step1_stabilize": {
        "tool": "DaVinci Resolve",
        "method": "AI stabilization",
        "why": "Remove AI generation jitter"
    },
    "step2_interpolate": {
        "tool": "RIFE or Topaz",
        "from_fps": 8,
        "to_fps": 24,
        "why": "Smooth motion"
    },
    "step3_color": {
        "lut": "cinematic_warm.cube",
        "adjustments": {
            "contrast": 1.2,
            "saturation": 0.9,
            "grain": "film_emulation"
        }
    },
    "step4_audio": {
        "sync": "auto_align",
        "mix": "dialogue_norm",
        "master": "-3dB headroom"
    }
}

# Complete Metadata System
class MetadataManager:
    def __init__(self):
        self.standards = {
            "png": self.png_metadata,
            "jpeg": self.exif_metadata,
            "webp": self.xmp_metadata,
            "mp4": self.mp4_metadata
        }
    
    def embed_complete_metadata(self, file_path, generation_data):
        """Never forget your settings again"""
        metadata = {
            # Generation settings
            "prompt": generation_data['prompt'],
            "negative_prompt": generation_data.get('negative', ''),
            "model": generation_data['model'],
            "model_hash": generation_data.get('model_hash', ''),
            "sampler": generation_data['sampler'],
            "steps": generation_data['steps'],
            "cfg_scale": generation_data['cfg_scale'],
            "seed": generation_data['seed'],
            "size": f"{generation_data['width']}x{generation_data['height']}",
            
            # Technical details
            "vae": generation_data.get('vae', 'default'),
            "clip_skip": generation_data.get('clip_skip', 1),
            "enhancements": generation_data.get('postprocess', []),
            
            # Workflow info
            "workflow": "ComfyUI",
            "workflow_version": "2024.1",
            "created": datetime.now().isoformat(),
            
            # Custom fields
            "project": generation_data.get('project', ''),
            "client": generation_data.get('client', ''),
            "usage_rights": generation_data.get('rights', 'all')
        }
        
        # Embed based on format
        file_format = file_path.split('.')[-1].lower()
        if file_format in self.standards:
            self.standards[file_format](file_path, metadata)
        
        # Also save JSON sidecar for safety
        json_path = file_path.replace(f'.{file_format}', '_metadata.json')
        with open(json_path, 'w') as f:
            json.dump(metadata, f, indent=2)

# Never lose settings again!
metadata_mgr = MetadataManager()
metadata_mgr.embed_complete_metadata("masterpiece.png", ai_settings)

# Professional Audio Post-Processing
audio_mastering = {
    "chain": [
        {"effect": "noise_gate", "threshold": -40},
        {"effect": "eq", "type": "parametric", "boost_presence": True},
        {"effect": "compressor", "ratio": "3:1", "knee": "soft"},
        {"effect": "limiter", "ceiling": -0.3},
        {"effect": "normalize", "target": -14}  # LUFS for streaming
    ],
    "export": {
        "master": {"format": "wav", "bit_depth": 24},
        "streaming": {"format": "mp3", "bitrate": 320},
        "preview": {"format": "mp3", "bitrate": 128}
    }
}

# Real-Time Preview System
class LiveGenerationStream:
    def __init__(self, websocket):
        self.ws = websocket
        self.preview_quality = {
            "interval": 5,      # Show every 5 steps
            "resolution": 512,  # Fast preview size
            "format": "jpeg",   # Quick transmission
            "quality": 70       # Balance speed/quality
        }
    
    async def stream_generation(self, prompt, steps=30):
        # Initialize generation
        pipeline = StableDiffusionPipeline()
        
        # Stream previews during generation
        for step in range(steps):
            if step % self.preview_quality['interval'] == 0:
                # Decode current latents
                preview = pipeline.decode_latents_to_preview(
                    size=self.preview_quality['resolution']
                )
                
                # Send to client
                await self.ws.send({
                    "type": "preview",
                    "step": step,
                    "total": steps,
                    "image": encode_image(preview)
                })
        
        # Send final full-quality result
        final = pipeline.get_final_image()
        await self.ws.send({
            "type": "complete",
            "image": encode_image(final)
        })

# Usage: Connect to any WebSocket client
# Perfect for web apps, Discord bots, stream overlays

# Twitch/YouTube Integration
interactive_config = {
    "platform": "twitch",
    "commands": {
        "!style": "change_art_style",
        "!color": "adjust_color_palette",
        "!remix": "variation_seed"
    },
    "preview_stream": {
        "protocol": "RTMP",
        "resolution": "1920x1080",
        "fps": 30,
        "keyframe_interval": 2
    }
}

# Hollywood-Grade Export
vfx_export = {
    "plates": {
        "beauty": {"format": "EXR", "bit_depth": 32, "linear": True},
        "depth": {"format": "EXR", "channels": "Z"},
        "motion": {"format": "EXR", "channels": "UV"},
        "normal": {"format": "EXR", "channels": "XYZ"},
        "crypto": {"format": "EXR", "cryptomatte": True}
    },
    "delivery": {
        "format": "DPX sequence",
        "color_space": "ACEScg",
        "naming": "shot_####.dpx"
    }
}

# Game-Ready Asset Export
game_export = {
    "textures": {
        "resolution": [512, 1024, 2048, 4096],  # LODs
        "compression": "BC7",  # GPU-friendly
        "channels": {
            "albedo": "RGB + Alpha",
            "normal": "RG (reconstructed B)",
            "orm": "R=AO, G=Rough, B=Metal"
        }
    },
    "optimization": {
        "atlas_packing": True,
        "power_of_two": True,
        "mipmaps": "pregenerated"
    }
}

# Responsive Web Export
web_pipeline = ResponsiveExporter()

# Generate all required formats automatically
web_pipeline.export(
    image=ai_generation,
    formats={
        "modern": ["avif", "webp"],  # Next-gen
        "fallback": ["jpeg"],         # Compatibility
        "sizes": [320, 768, 1024, 1920, 3840],
        "pixel_density": [1, 2, 3]    # Retina support
    },
    output_pattern="{name}-{width}w-{density}x.{format}"
)

# Generates srcset-ready images:
# hero-320w-1x.avif, hero-320w-2x.avif, etc.

# Future-Proof Pipeline Architecture
class FormatAgnosticPipeline:
    def __init__(self):
        # Register current and future formats
        self.formats = {
            "image": {
                "current": ["jpeg", "png", "webp"],
                "emerging": ["avif", "jxl"],
                "future": ["neural_image_format"]
            },
            "3d": {
                "current": ["obj", "fbx", "gltf"],
                "emerging": ["usd", "gaussian_splat"],
                "future": ["neural_radiance_format"]
            }
        }
    
    def export(self, content, target):
        # Automatically use best available format
        format = self.select_optimal_format(content, target)
        
        # Fallback chain for compatibility
        try:
            return self.export_to(content, format)
        except FormatNotSupported:
            return self.export_to(content, self.get_fallback(format))

# Your pipeline stays relevant as formats evolve

# Coming Soon: Neural Compression
future_tech = {
    "neural_compression": {
        "concept": "AI learns optimal compression per image",
        "benefit": "90% smaller than JPEG at better quality",
        "timeline": "2025-2026"
    },
    "semantic_formats": {
        "concept": "Store meaning, not pixels",
        "benefit": "Infinite resolution, tiny files",
        "timeline": "2026+"
    },
    "holographic_formats": {
        "concept": "Full light field capture",
        "benefit": "True 3D from any angle",
        "timeline": "2025+"
    }
}

# Diffusion models work in latent space
diffusion_quality = {
    "text": "Preserve semantic embeddings",
    "image": "Maintain VAE precision (16-bit+)",
    "audio": "Keep spectral resolution",
    "video": "Preserve temporal coherence",
    "3d": "Maintain geometric accuracy"
}

# Each modality uses different decoders
decoders = {
    "text": "Token decoder → Text formatter",
    "image": "VAE decoder → Pixel space",
    "audio": "Vocoder → Waveform",
    "video": "Frame decoder → Sequence",
    "3d": "Geometry decoder → Mesh/Points"
}

# Essential diffusion parameters to preserve
diffusion_metadata = {
    "num_inference_steps": 50,
    "guidance_scale": 7.5,
    "scheduler": "DPMSolverMultistep",
    "eta": 0.0,
    "latent_shape": [4, 64, 64],
    "conditioning": "prompt_embeddings"
}