Input Processing Pipeline:
┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   Image Input   │ -> │  Patch Embedding │ -> │ Position Embed  │
│   (224×224×3)   │    │   (196 patches)  │    │   + [CLS] Token │
└─────────────────┘    └──────────────────┘    └─────────────────┘
                                ↓
┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│ Classification  │ <- │  Transformer     │ <- │  Input Sequence │
│     Head        │    │  Encoder (12×)   │    │  (197 tokens)   │
└─────────────────┘    └──────────────────┘    └─────────────────┘

class PatchEmbedding(nn.Module):
    def __init__(self, img_size=224, patch_size=16, in_channels=3, embed_dim=768):
        super().__init__()
        self.num_patches = (img_size // patch_size) ** 2
        self.projection = nn.Conv2d(in_channels, embed_dim, 
                                   kernel_size=patch_size, stride=patch_size)
    
    def forward(self, x):
        # x: [B, C, H, W] -> [B, num_patches, embed_dim]
        x = self.projection(x).flatten(2).transpose(1, 2)
        return x

# Each patch attends to all other patches globally
attention_weights = softmax(Q @ K.T / sqrt(d_k)) @ V

Text-to-Image Generation Pipeline:
┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   Text Prompt   │ -> │  CLIP Text       │ -> │  Text Embedding │
│ "A red bicycle" │    │  Encoder         │    │   (77×768)      │
└─────────────────┘    └──────────────────┘    └─────────────────┘
                                                        ↓
┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│  Generated      │ <- │      VAE         │ <- │     U-Net       │
│     Image       │    │    Decoder       │    │   Denoising     │
│   (512×512×3)   │    │                  │    │   Process       │
└─────────────────┘    └──────────────────┘    └─────────────────┘
                                                        ↑
                              ┌─────────────────────────┘
                              │
                    ┌─────────────────┐
                    │  Random Noise   │
                    │    Latent       │
                    │   (64×64×4)     │
                    └─────────────────┘

# Transformer-based text encoder
text_embeddings = clip_text_encoder(tokenized_text)
# Output: [batch_size, 77, 768]

class UNet2DConditionModel:
    def __init__(self):
        self.down_blocks = nn.ModuleList([...])  # Encoder
        self.mid_block = UNetMidBlock2DCrossAttn(...)  # Bottleneck
        self.up_blocks = nn.ModuleList([...])    # Decoder
        
    def forward(self, latent, timestep, text_embedding):
        # Cross-attention between image and text features
        return denoised_latent

def timestep_embedding(timesteps, dim):
    """Sinusoidal timestep embeddings"""
    half = dim // 2
    freqs = torch.exp(-math.log(10000) * torch.arange(half) / half)
    args = timesteps[:, None] * freqs[None, :]
    embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
    return embedding

# Encode image to latent space (8× compression)
latent = vae.encode(image).latent_dist.sample() * 0.18215
 
# Decode latent back to image space
image = vae.decode(latent / 0.18215).sample

# Global self-attention across all patches
Q = patches @ W_q  # Query matrix
K = patches @ W_k  # Key matrix  
V = patches @ W_v  # Value matrix
 
attention = softmax(Q @ K.T / sqrt(d_k)) @ V

# Cross-attention between image features and text embeddings
Q = image_features @ W_q     # Query from image
K = text_embeddings @ W_k    # Key from text
V = text_embeddings @ W_v    # Value from text
 
cross_attention = softmax(Q @ K.T / sqrt(d_k)) @ V

def process_input(image):
    # Step 1: Divide into patches
    patches = image.unfold(dimension=2, size=16, step=16)
                  .unfold(dimension=3, size=16, step=16)
    
    # Step 2: Flatten patches
    flattened = patches.reshape(batch_size, num_patches, -1)
    
    # Step 3: Linear projection
    tokens = linear_projection(flattened)
    
    # Step 4: Add position embeddings
    tokens += position_embeddings
    
    return tokens

def process_inputs(text_prompt, noise_latent, timestep):
    # Text processing
    text_tokens = tokenizer(text_prompt)
    text_embeddings = clip_text_encoder(text_tokens)
    
    # Noise timestep embedding
    time_embedding = timestep_embedding(timestep)
    
    # Latent preparation
    noisy_latent = add_noise(clean_latent, noise, timestep)
    
    return text_embeddings, noisy_latent, time_embedding

def training_objective(model, images, labels):
    # Forward pass
    patch_embeddings = patch_embed(images)
    features = transformer_encoder(patch_embeddings)
    cls_token = features[:, 0]  # CLS token representation
    logits = classification_head(cls_token)
    
    # Cross-entropy loss
    loss = cross_entropy(logits, labels)
    return loss

def training_objective(model, images, text_embeddings):
    # Add noise to images
    noise = torch.randn_like(images)
    timesteps = torch.randint(0, 1000, (batch_size,))
    noisy_images = add_noise(images, noise, timesteps)
    
    # Predict noise
    predicted_noise = model(noisy_images, timesteps, text_embeddings)
    
    # MSE loss between predicted and actual noise
    loss = mse_loss(predicted_noise, noise)
    return loss

Healthcare:
- Medical imaging analysis
- Pathology slide classification
- Radiology report automation
 
Autonomous Vehicles:
- Scene understanding
- Traffic sign recognition
- Pedestrian detection
 
E-commerce:
- Product categorization
- Visual search
- Quality assessment
 
Manufacturing:
- Defect detection
- Quality control
- Assembly verification

Media & Entertainment:
- Movie concept art
- Game asset creation
- Advertising visuals
 
Fashion & Design:
- Product visualization
- Pattern generation
- Virtual try-on
 
Architecture:
- Building visualization
- Interior design
- Landscape planning
 
Education:
- Textbook illustrations
- Historical reconstructions
- Scientific visualizations

Model: ViT-Base/16
Parameters: 86M
Training Data: ImageNet-21k (14M images)
Hardware: 8× V100 GPUs
Training Time: ~3 days
Memory: ~32GB per GPU

Input Size: 224×224×3
Latency: ~5ms (V100)
Throughput: ~2000 images/second
Memory: ~2GB
Power: ~300W

Model: Stable Diffusion v1.5
Parameters: 860M (total pipeline)
Training Data: LAION-5B subset
Hardware: Multiple A100 clusters
Training Time: Several weeks
Memory: ~40GB per GPU

Input: Text prompt
Output Size: 512×512×3
Latency: ~3-10 seconds (50 steps)
Memory: ~8-12GB
Power: ~300W
Batch Processing: Limited by memory

# Performance scales with:
# 1. Model size (parameters)
# 2. Dataset size
# 3. Compute budget
 
performance ∝ log(parameters) × log(data_size) × log(compute)
 
# Scaling trends:
ViT-Base:   86M params  -> 81.8% ImageNet accuracy
ViT-Large:  307M params -> 85.2% ImageNet accuracy  
ViT-Huge:   632M params -> 88.5% ImageNet accuracy

# Quality scales with:
# 1. Model parameters
# 2. Training steps
# 3. Data diversity
 
quality ∝ log(parameters) × log(training_steps) × log(data_diversity)
 
# Recent scaling examples:
SD v1.5:    860M params  -> High quality 512×512
SD v2.1:    865M params  -> Improved 768×768
SDXL:       3.5B params  -> Superior 1024×1024

def vit_memory_analysis():
    """Memory breakdown for ViT-Base inference"""
    
    input_image = 224 * 224 * 3 * 4  # 0.6MB (float32)
    patch_embeddings = 196 * 768 * 4  # 0.6MB
    attention_weights = 12 * 12 * 196 * 196 * 4  # 221MB
    intermediate_activations = 196 * 3072 * 4  # 2.4MB
    
    total_memory = 225MB  # Approximate
    return total_memory

def sd_memory_analysis():
    """Memory breakdown for Stable Diffusion inference"""
    
    text_encoder = 123M * 4  # 492MB
    unet_model = 860M * 4   # 3.4GB
    vae_model = 84M * 4     # 336MB
    latent_space = 64 * 64 * 4 * 4  # 65KB
    attention_maps = 1000MB  # Variable
    
    total_memory = ~6GB  # Approximate
    return total_memory

# Required libraries
import torch
import torch.nn as nn
import torchvision.transforms as transforms
from timm import create_model  # PyTorch Image Models
 
# Model initialization
model = create_model('vit_base_patch16_224', pretrained=True)
model.eval()
 
# Input preprocessing
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], 
                        std=[0.229, 0.224, 0.225])
])

# Training hyperparameters
config = {
    'learning_rate': 3e-4,
    'batch_size': 512,
    'epochs': 300,
    'weight_decay': 0.3,
    'warmup_epochs': 10,
    'optimizer': 'AdamW',
    'scheduler': 'cosine',
    'augmentation': 'RandAugment',
    'mixup_alpha': 0.8,
    'cutmix_alpha': 1.0,
    'label_smoothing': 0.1
}

def fine_tune_vit(model, num_classes, learning_rate=1e-4):
    # Freeze backbone layers
    for param in model.parameters():
        param.requires_grad = False
    
    # Replace classification head
    model.head = nn.Linear(model.head.in_features, num_classes)
    
    # Unfreeze last few layers for fine-tuning
    for param in model.blocks[-2:].parameters():
        param.requires_grad = True
    
    # Use lower learning rate for fine-tuning
    optimizer = torch.optim.AdamW([
        {'params': model.head.parameters(), 'lr': learning_rate},
        {'params': model.blocks[-2:].parameters(), 'lr': learning_rate * 0.1}
    ])
    
    return model, optimizer

# Required libraries
import torch
from diffusers import StableDiffusionPipeline, DDIMScheduler
from transformers import CLIPTextModel, CLIPTokenizer
 
# Pipeline initialization
pipe = StableDiffusionPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    torch_dtype=torch.float16,
    safety_checker=None,
    requires_safety_checker=False
)
pipe = pipe.to("cuda")

# Generation parameters
generation_config = {
    'num_inference_steps': 50,
    'guidance_scale': 7.5,
    'height': 512,
    'width': 512,
    'generator': torch.Generator().manual_seed(42),
    'negative_prompt': "blurry, low quality, distorted"
}
 
# Generate image
image = pipe(
    prompt="A serene landscape with mountains and lake",
    **generation_config
).images[0]

class CustomStableDiffusion:
    def __init__(self, model_path):
        self.vae = AutoencoderKL.from_pretrained(model_path, subfolder="vae")
        self.tokenizer = CLIPTokenizer.from_pretrained(model_path, subfolder="tokenizer")
        self.text_encoder = CLIPTextModel.from_pretrained(model_path, subfolder="text_encoder")
        self.unet = UNet2DConditionModel.from_pretrained(model_path, subfolder="unet")
        self.scheduler = DDIMScheduler.from_pretrained(model_path, subfolder="scheduler")
    
    def generate(self, prompt, num_steps=50):
        # Encode text
        text_inputs = self.tokenizer(prompt, return_tensors="pt")
        text_embeddings = self.text_encoder(text_inputs.input_ids)[0]
        
        # Initialize random latent
        latent = torch.randn(1, 4, 64, 64)
        
        # Denoising loop
        self.scheduler.set_timesteps(num_steps)
        for timestep in self.scheduler.timesteps:
            noise_pred = self.unet(latent, timestep, text_embeddings).sample
            latent = self.scheduler.step(noise_pred, timestep, latent).prev_sample
        
        # Decode to image
        image = self.vae.decode(latent).sample
        return image

class DiffusionTransformer(nn.Module):
    def __init__(self, input_size=32, patch_size=2, in_channels=4, 
                 hidden_size=1152, depth=28, num_heads=16):
        super().__init__()
        self.patch_embed = PatchEmbed(input_size, patch_size, in_channels, hidden_size)
        self.pos_embed = nn.Parameter(torch.zeros(1, num_patches, hidden_size))
        
        # Transformer blocks with adaptive layer norm
        self.blocks = nn.ModuleList([
            DiTBlock(hidden_size, num_heads) for _ in range(depth)
        ])
        
        # Final layer for noise prediction
        self.final_layer = FinalLayer(hidden_size, patch_size, out_channels)
    
    def forward(self, x, t, y):
        """
        x: Noisy latent patches
        t: Timestep embedding
        y: Class label embedding
        """
        x = self.patch_embed(x) + self.pos_embed
        
        for block in self.blocks:
            x = block(x, t, y)  # Condition on timestep and class
        
        x = self.final_layer(x, t)
        return x

# DiT scaling results (ImageNet 256×256)
models = {
    'DiT-S/2': {'params': '33M', 'FID': 5.02},
    'DiT-B/2': {'params': '130M', 'FID': 3.04},
    'DiT-L/2': {'params': '458M', 'FID': 2.55},
    'DiT-XL/2': {'params': '675M', 'FID': 2.27}  # SOTA
}
 
# Clear scaling trend: larger models → better FID scores

class AdaLN(nn.Module):
    """Adaptive Layer Normalization conditioned on timestep and class"""
    def __init__(self, hidden_size, conditioning_size):
        super().__init__()
        self.ln = nn.LayerNorm(hidden_size, elementwise_affine=False)
        self.linear = nn.Linear(conditioning_size, 2 * hidden_size)
    
    def forward(self, x, conditioning):
        scale, shift = self.linear(conditioning).chunk(2, dim=-1)
        return self.ln(x) * (1 + scale) + shift

# U-Net: Local receptive field
conv_layer = nn.Conv2d(in_channels, out_channels, kernel_size=3)
 
# DiT: Global receptive field  
attention_layer = MultiHeadAttention(embed_dim, num_heads)

# SD3 Architecture (Simplified)
class SD3DiffusionTransformer:
    def __init__(self):
        self.joint_transformer = MultiModalDiT(
            text_dim=4096,
            image_dim=1536,
            depth=24,
            heads=24
        )
    
    def forward(self, image_latents, text_embeddings, timestep):
        # Joint attention between image and text
        joint_features = torch.cat([image_latents, text_embeddings], dim=1)
        
        # Process with transformer
        output = self.joint_transformer(joint_features, timestep)
        
        # Split back to image predictions
        image_output = output[:, :image_latents.shape[1]]
        return image_output

class CoAtNet(nn.Module):
    """Combines convolutional and attention mechanisms"""
    def __init__(self):
        super().__init__()
        # Early layers: Convolution for local features
        self.conv_stem = ConvStem()
        self.conv_stages = nn.ModuleList([ConvBlock() for _ in range(2)])
        
        # Later layers: Attention for global features  
        self.attn_stages = nn.ModuleList([AttnBlock() for _ in range(2)])
        
    def forward(self, x):
        # Convolutional processing
        for conv_block in self.conv_stages:
            x = conv_block(x)
        
        # Attention processing
        for attn_block in self.attn_stages:
            x = attn_block(x)
        
        return x

def select_vit_model(use_case, data_size, compute_budget):
    """Guide for selecting appropriate ViT variant"""
    
    if use_case == "mobile_deployment":
        return "Mobile-ViT" if compute_budget == "low" else "DeiT-Small"
    
    elif data_size < 100000:  # Small dataset
        return "ViT-Base/16 (pre-trained)" 
    
    elif data_size < 1000000:  # Medium dataset
        return "ViT-Large/16" if compute_budget == "high" else "ViT-Base/16"
    
    else:  # Large dataset
        return "ViT-Huge/14" if compute_budget == "unlimited" else "ViT-Large/16"

# 1. Model Quantization
def quantize_vit(model):
    quantized_model = torch.quantization.quantize_dynamic(
        model, {nn.Linear}, dtype=torch.qint8
    )
    return quantized_model  # ~4x smaller, minimal accuracy loss
 
# 2. Knowledge Distillation
def distill_vit(teacher_model, student_model, data_loader):
    for images, labels in data_loader:
        teacher_logits = teacher_model(images)
        student_logits = student_model(images)
        
        # Distillation loss
        distill_loss = nn.KLDivLoss()(
            F.log_softmax(student_logits / temperature, dim=1),
            F.softmax(teacher_logits / temperature, dim=1)
        )
 
# 3. Efficient Attention
def efficient_attention(q, k, v, chunk_size=512):
    """Memory-efficient attention for large sequences"""
    b, h, n, d = q.shape
    
    # Chunked computation to reduce memory
    outputs = []
    for i in range(0, n, chunk_size):
        chunk_q = q[:, :, i:i+chunk_size]
        attn_chunk = torch.softmax(chunk_q @ k.transpose(-2, -1) / math.sqrt(d), dim=-1)
        output_chunk = attn_chunk @ v
        outputs.append(output_chunk)
    
    return torch.cat(outputs, dim=2)

# 1. Memory Optimization
def optimize_sd_memory():
    # Enable CPU offloading
    pipe.enable_model_cpu_offload()
    
    # Use memory-efficient attention
    pipe.enable_xformers_memory_efficient_attention()
    
    # Enable VAE slicing for large images
    pipe.enable_vae_slicing()
    
    # Reduce precision
    pipe = pipe.to(torch.float16)
 
# 2. Speed Optimization
def optimize_sd_speed():
    # Use faster schedulers
    pipe.scheduler = DPMSolverMultistepScheduler.from_config(
        pipe.scheduler.config
    )
    
    # Reduce inference steps
    num_inference_steps = 20  # vs default 50
    
    # Use TensorRT optimization (NVIDIA GPUs)
    pipe = pipeline_to_tensorrt(pipe)
 
# 3. Batch Generation
def batch_generate(prompts, batch_size=4):
    """Generate multiple images efficiently"""
    results = []
    for i in range(0, len(prompts), batch_size):
        batch_prompts = prompts[i:i+batch_size]
        batch_images = pipe(
            batch_prompts,
            num_inference_steps=20,
            guidance_scale=7.5
        ).images
        results.extend(batch_images)
    return results

class ProductionSDPipeline:
    def __init__(self, model_path):
        self.pipe = StableDiffusionPipeline.from_pretrained(
            model_path,
            torch_dtype=torch.float16,
            safety_checker=ContentSafetyChecker(),
            feature_extractor=CLIPImageProcessor()
        )
        self.pipe.enable_model_cpu_offload()
        
    def generate_with_safety(self, prompt, negative_prompt=None):
        # Content filtering
        if self.is_unsafe_prompt(prompt):
            return self.get_safe_fallback_image()
        
        # Generate with error handling
        try:
            image = self.pipe(
                prompt=prompt,
                negative_prompt=negative_prompt or self.default_negative_prompt,
                num_inference_steps=20,
                guidance_scale=7.5,
                generator=torch.Generator().manual_seed(random.randint(0, 2**32-1))
            ).images[0]
            
            # Post-process and validate
            if self.is_safe_image(image):
                return self.post_process(image)
            else:
                return self.get_safe_fallback_image()
                
        except Exception as e:
            logger.error(f"Generation failed: {e}")
            return self.get_error_image()
    
    def is_unsafe_prompt(self, prompt):
        # Implement content filtering logic
        unsafe_keywords = ["violence", "explicit", ...]
        return any(keyword in prompt.lower() for keyword in unsafe_keywords)

1. **Architectural Improvements**
   - Hierarchical Vision Transformers (Swin, PVT)
   - Efficient attention mechanisms (Linear, Sparse)
   - Multi-scale processing capabilities
 
2. **Training Innovations**
   - Self-supervised pre-training (MAE, SimMIM)
   - Few-shot learning capabilities
   - Continual learning approaches
 
3. **Application Expansion**
   - Video understanding (ViViT, TimeSformer)
   - 3D vision tasks
   - Multi-modal integration

# 1. Efficient ViT Architectures
class EfficientViT(nn.Module):
    """Next-generation efficient Vision Transformer"""
    def __init__(self):
        super().__init__()
        self.patch_embed = ConvPatchEmbed()  # Convolutional patch embedding
        self.local_attention = LocalAttention()  # Reduced complexity
        self.global_attention = SparseAttention()  # Sparse global attention
        
# 2. Multimodal ViT
class MultiModalViT(nn.Module):
    """Vision Transformer with multi-modal capabilities"""
    def __init__(self):
        super().__init__()
        self.vision_encoder = ViTEncoder()
        self.text_encoder = TextEncoder()
        self.fusion_layer = CrossModalAttention()

1. **Architecture Advances**
   - Full transformer adoption (DiT, SD3)
   - Better conditioning mechanisms
   - Improved latent representations
 
2. **Efficiency Improvements**
   - Faster sampling algorithms
   - Distilled models
   - Progressive generation
 
3. **Quality Enhancements**
   - Higher resolution generation
   - Better prompt adherence
   - Reduced artifacts

# 1. Controllable Generation
class ControllableSD:
    def __init__(self):
        self.base_model = StableDiffusionPipeline()
        self.controlnet = ControlNet()  # Pose, depth, edge control
        self.inpainting = InpaintingPipeline()
        
    def generate_with_control(self, prompt, control_image, control_type):
        return self.controlnet(
            prompt=prompt,
            image=control_image,
            control_type=control_type
        )
 
# 2. Real-time Generation
class RealTimeSD:
    def __init__(self):
        self.model = OptimizedSDPipeline()
        self.cache = LatentCache()
        
    def generate_stream(self, prompt):
        # Progressive refinement for real-time feedback
        for step in range(20):
            partial_result = self.model.single_step(prompt, step)
            yield partial_result

class UnifiedVisionTransformer(nn.Module):
    """Unified model for both understanding and generation"""
    def __init__(self, mode='dual'):
        super().__init__()
        self.shared_encoder = TransformerEncoder()
        
        if mode in ['dual', 'classification']:
            self.classification_head = ClassificationHead()
        
        if mode in ['dual', 'generation']:
            self.generation_decoder = DiffusionDecoder()
    
    def forward(self, x, task='classify'):
        shared_features = self.shared_encoder(x)
        
        if task == 'classify':
            return self.classification_head(shared_features)
        elif task == 'generate':
            return self.generation_decoder(shared_features)
        else:  # dual task
            return {
                'classification': self.classification_head(shared_features),
                'generation': self.generation_decoder(shared_features)
            }

def should_use_vit(task_type, data_size, compute_budget, latency_requirement):
    use_vit = (
        task_type in ['classification', 'feature_extraction', 'similarity_search'] and
        data_size > 100000 and  # Sufficient training data
        compute_budget == 'high' and
        latency_requirement < 100  # ms
    )
    
    # Additional considerations
    if task_type == 'fine_grained_classification':
        use_vit = True  # ViT excels at fine-grained tasks
    
    if 'global_context' in task_requirements:
        use_vit = True  # Global attention is beneficial
    
    return use_vit

def should_use_stable_diffusion(task_type, output_quality, compute_budget, time_constraint):
    use_sd = (
        task_type in ['image_generation', 'editing', 'augmentation'] and
        output_quality == 'high' and
        compute_budget in ['medium', 'high'] and
        time_constraint > 3  # seconds per image
    )
    
    # Specific use cases
    creative_tasks = ['art_generation', 'concept_design', 'marketing_visuals']
    if task_type in creative_tasks:
        use_sd = True
    
    return use_sd

development_costs = {
    'vit': {
        'research_time': '2-4 weeks',
        'data_collection': '$$',
        'compute_training': '$$$',
        'expertise_required': 'Computer Vision',
        'deployment_complexity': 'Low'
    },
    'stable_diffusion': {
        'research_time': '1-2 weeks',
        'data_collection': '$',  # Pre-trained available
        'compute_inference': '$$$$',
        'expertise_required': 'Generative AI',
        'deployment_complexity': 'High'
    }
}

def analyze_tradeoffs(model_type, use_case):
    """Analyze performance vs resource requirements"""
    
    tradeoffs = {
        'vit': {
            'accuracy': 'high',
            'speed': 'fast',
            'memory': 'medium',
            'interpretability': 'medium',
            'scalability': 'high'
        },
        'stable_diffusion': {
            'quality': 'very_high',
            'speed': 'slow',
            'memory': 'very_high',
            'creativity': 'excellent',
            'control': 'medium'
        }
    }
    
    return tradeoffs[model_type]

class ModelRecommendationEngine:
    def __init__(self):
        self.decision_tree = self._build_decision_tree()
    
    def recommend(self, requirements):
        """
        requirements = {
            'task': 'classification' | 'generation' | 'both',
            'data_size': int,
            'compute_budget': 'low' | 'medium' | 'high',
            'latency_req': float (seconds),
            'quality_req': 'medium' | 'high' | 'very_high',
            'interpretability': bool
        }
        """
        
        if requirements['task'] == 'classification':
            if requirements['data_size'] > 100000:
                return self._recommend_vit(requirements)
            else:
                return "CNN or small ViT with pre-training"
        
        elif requirements['task'] == 'generation':
            return self._recommend_diffusion(requirements)
        
        else:  # both tasks
            return self._recommend_hybrid(requirements)
    
    def _recommend_vit(self, req):
        if req['compute_budget'] == 'high':
            return "ViT-Large/16 or ViT-Huge/14"
        elif req['latency_req'] < 0.01:
            return "Mobile-ViT or DeiT-Small"
        else:
            return "ViT-Base/16"
    
    def _recommend_diffusion(self, req):
        if req['compute_budget'] == 'low':
            return "Use API service (OpenAI DALL-E, Midjourney)"
        elif req['quality_req'] == 'very_high':
            return "Stable Diffusion XL or SD3"
        else:
            return "Stable Diffusion v1.5"
    
    def _recommend_hybrid(self, req):
        return {
            'primary': self._recommend_vit(req),
            'secondary': self._recommend_diffusion(req),
            'integration': 'Feature conditioning pipeline'
        }