Sora Turbo ve API: Video Üretimde Hız Devrimi

1# Knowledge distillation pseudocode
2class DistillationTrainer:
3    def __init__(self, teacher_model, student_model):
4        self.teacher = teacher_model  # Sora 2 (30B params)
5        self.student = student_model  # Sora Turbo (8B params)
6        self.temperature = 4.0
7 
8    def distill_step(self, batch):
9        # Ogretmen modelin ciktilari (soft targets)
10        with torch.no_grad():
11            teacher_logits = self.teacher(batch)
12            teacher_probs = F.softmax(teacher_logits / self.temperature, dim=-1)
13 
14        # Ogrenci modelin ciktilari
15        student_logits = self.student(batch)
16        student_probs = F.log_softmax(student_logits / self.temperature, dim=-1)
17 
18        # KL Divergence loss
19        distill_loss = F.kl_div(student_probs, teacher_probs, reduction='batchmean')
20 
21        # Hard label loss (gercek veri ile)
22        hard_loss = F.mse_loss(self.student(batch), batch['target'])
23 
24        # Toplam loss: alpha * distill + (1-alpha) * hard
25        total_loss = 0.7 * distill_loss + 0.3 * hard_loss
26        return total_loss

1POST /v1/videos/generations        # Video uret
2GET  /v1/videos/{id}               # Video durumunu sorgula
3GET  /v1/videos/{id}/download      # Video indir
4POST /v1/videos/edits              # Video duzenle(remix/inpaint)
5POST /v1/videos/storyboards        # Storyboard modu
6DELETE /v1/videos/{id}             # Video sil
7GET  /v1/videos                    # Videolari listele

1# API Key ile authentication
2curl -X POST https://api.openai.com/v1/videos/generations \
3  -H "Authorization: Bearer sk-proj-xxxxx" \
4  -H "Content-Type: application/json" \
5  -d '{
6    "model": "sora-turbo",
7    "prompt": "A serene mountain lake at sunrise, mist rising from the water",
8    "resolution": "1080p",
9    "aspect_ratio": "16:9",
10    "duration": 10
11  }'

1from openai import OpenAI
2import asyncio
3from typing import List
4 
5client = OpenAI()
6 
7async def generate_video(prompt: str, config: dict) -> dict:
8    """Tek bir video uret ve sonucu dondur"""
9    response = await client.videos.generations.create(
10        model="sora-turbo",
11        prompt=prompt,
12        resolution=config.get("resolution", "1080p"),
13        aspect_ratio=config.get("aspect_ratio", "16:9"),
14        duration=config.get("duration", 10),
15        style=config.get("style", "natural"),
16    )
17    return {
18        "id": response.id,
19        "status": response.status,
20        "prompt": prompt,
21        "estimated_time": response.estimated_completion_time
22    }
23 
24async def batch_generate(prompts: List[str], config: dict) -> List[dict]:
25    """Birden fazla videoyu paralel uret"""
26    tasks = [generate_video(p, config) for p in prompts]
27    results = await asyncio.gather(*tasks, return_exceptions=True)
28 
29    successful = [r for r in results if isinstance(r, dict)]
30    failed = [r for r in results if isinstance(r, Exception)]
31 
32    print(f"Basarili: {len(successful)}, Basarisiz: {len(failed)}")
33    return successful
34 
35# Kullanim ornegi
36prompts = [
37    "Product showcase: sleek smartwatch on marble surface, rotating slowly",
38    "Product showcase: wireless earbuds floating with light particles",
39    "Product showcase: laptop opening with screen glow in dark room",
40]
41 
42config = {
43    "resolution": "1080p",
44    "aspect_ratio": "1:1",
45    "duration": 8,
46    "style": "commercial"
47}
48 
49results = asyncio.run(batch_generate(prompts, config))

1import OpenAI from 'openai';
2 
3const client = new OpenAI();
4 
5interface VideoConfig {
6  resolution: '720p' | '1080p';
7  aspectRatio: '16:9' | '9:16' | '1:1';
8  duration: number;
9  style?: string;
10}
11 
12async function generateProductVideo(
13  productName: string,
14  description: string,
15  config: VideoConfig
16): Promise {
17  const prompt = \`Product showcase: ${productName}. ${description}.
18    Professional studio lighting, clean background,
19    smooth 360-degree rotation, ${config.style || 'commercial'} style\`;
20 
21  const response = await client.videos.generations.create({
22    model: 'sora-turbo',
23    prompt,
24    resolution: config.resolution,
25    aspect_ratio: config.aspectRatio,
26    duration: config.duration,
27  });
28 
29  // Polling ile tamamlanmayi bekle
30  let video = await client.videos.retrieve(response.id);
31  while (video.status === 'processing') {
32    await new Promise(resolve => setTimeout(resolve, 5000));
33    video = await client.videos.retrieve(response.id);
34  }
35 
36  if (video.status === 'completed') {
37    return video.download_url;
38  }
39 
40  throw new Error(\`Video generation failed: ${video.error?.message}\`);
41}

1# Video uretimini webhook ile baslat
2response = client.videos.generations.create(
3    model="sora-turbo",
4    prompt="Epic drone shot over Norwegian fjords at golden hour",
5    resolution="1080p",
6    duration=15,
7    webhook_url="https://myapp.com/api/sora-webhook",
8    webhook_events=["completed", "failed", "progress"]
9)
10 
11# Webhook handler (Flask ornegi)
12from flask import Flask, request, jsonify
13 
14app = Flask(__name__)
15 
16@app.route('/api/sora-webhook', methods=['POST'])
17def sora_webhook():
18    event = request.json
19 
20    if event['type'] == 'video.completed':
21        video_id = event['data']['id']
22        download_url = event['data']['download_url']
23        # Video'yu isle, CDN'e yukle, kullaniciyi bilgilendir
24        process_completed_video(video_id, download_url)
25 
26    elif event['type'] == 'video.failed':
27        error = event['data']['error']
28        # Hata logla, retry mekanizmasi tetikle
29        handle_failure(event['data']['id'], error)
30 
31    elif event['type'] == 'video.progress':
32        progress = event['data']['progress_percent']
33        # Kullaniciya ilerleme bilgisi gonder
34        notify_progress(event['data']['id'], progress)
35 
36    return jsonify({"received": True}), 200

1Senaryo: 30 adet 10 saniyelik urun tanitim videosu(aylik)
2 
3Geleneksel Yontem:
4- Videographer gunlugu: $500 x 3 gun = $1,500
5- Studio kirasi: $200 x 3 gun = $600
6- Post-production: $100 x 30 video = $3,000
7- TOPLAM: ~$5,100/ay
8 
9Sora Turbo(Pro Plan):
10- Pro abonelik: $200/ay
11- 30 x 10s = 300 saniye = dahil credit'te
12- Post-production(minimal): $500
13- TOPLAM: ~$700/ay
14 
15TASARRUF: %86 maliyet azalmasi

1import time
2from tenacity import retry, stop_after_attempt, wait_exponential
3 
4@retry(
5    stop=stop_after_attempt(3),
6    wait=wait_exponential(multiplier=1, min=4, max=60)
7)
8async def reliable_generate(prompt: str, config: dict) -> dict:
9    """Guvenilir video uretimi — retry ile"""
10    try:
11        response = await client.videos.generations.create(
12            model="sora-turbo",
13            prompt=prompt,
14            **config
15        )
16 
17        # Polling with timeout
18        timeout = 300  # 5 dakika
19        start = time.time()
20        while time.time() - start < timeout:
21            video = await client.videos.retrieve(response.id)
22            if video.status == 'completed':
23                return {"url": video.download_url, "id": video.id}
24            if video.status == 'failed':
25                raise Exception(f"Generation failed: {video.error}")
26            await asyncio.sleep(5)
27 
28        raise TimeoutError("Video generation timed out")
29 
30    except OpenAI.RateLimitError:
31        print("Rate limit - bekleniyor...")
32        raise  # tenacity retry edecek
33    except OpenAI.APIError as e:
34        print(f"API error: {e}")
35        raise

1import boto3
2 
3async def upload_to_cdn(video_url: str, key: str) -> str:
4    """Sora ciktisini S3/CloudFront'a yukle"""
5    s3 = boto3.client('s3')
6 
7    # Video'yu indir
8    response = requests.get(video_url, stream=True)
9 
10    # S3'e yukle
11    s3.upload_fileobj(
12        response.raw,
13        'my-video-bucket',
14        f'sora-output/{key}.mp4',
15        ExtraArgs={'ContentType': 'video/mp4'}
16    )
17 
18    cdn_url = f'https://cdn.myapp.com/sora-output/{key}.mp4'
19    return cdn_url