วิธีใช้ LTX-2 API

LTX-2 API ช่วยให้นักพัฒนาสร้างสรรค์เนื้อหาวิดีโอที่น่าสนใจผ่านปัญญาประดิษฐ์ บริการนี้จัดทำโดย Lightricks ช่วยให้ผู้ใช้สามารถแปลงคำอธิบายข้อความหรือรูปภาพนิ่งให้เป็นวิดีโอที่มีเสียงและซิงโครไนซ์กัน วิศวกรนำไปรวมเข้ากับแอปพลิเคชันสำหรับงานต่างๆ ตั้งแต่การสร้างเนื้อหาไปจนถึงการสร้างต้นแบบของเอฟเฟกต์ภาพ นอกจากนี้ API ยังรองรับโมเดลต่างๆ ที่ปรับให้เหมาะสมสำหรับความเร็วหรือคุณภาพ ทำให้สามารถปรับแต่งได้ตามความต้องการของโปรเจกต์

ดังนั้น ลองดาวน์โหลด Apidog ฟรี เพื่อปรับปรุงการทำงานร่วมกับ LTX-2 API และมุ่งเน้นไปที่นวัตกรรมมากกว่าการตั้งค่า

LTX-2 API คืออะไร?

นักพัฒนาใช้ LTX-2 API เพื่อสร้างวิดีโอด้วยโปรแกรม บริการ RESTful นี้ใช้ประโยชน์จากโมเดล AI ขั้นสูงเพื่อสร้างผลลัพธ์แบบภาพยนตร์จากอินพุตที่เรียบง่าย โดยเฉพาะอย่างยิ่ง มันมีความสามารถหลักสามประการ: การสร้างวิดีโอจากข้อความ (text-to-video), การแปลงรูปภาพเป็นวิดีโอ (image-to-video) และฟังก์ชันรีเทค (retake) สำหรับการแก้ไขส่วนต่างๆ ของวิดีโอ

API สร้างขึ้นบนโมเดล LTX-2 ซึ่งเป็นรากฐานที่ใช้ diffusion transformer (DiT) ที่สร้างเสียงและวิดีโอที่ซิงโครไนซ์กันได้ในครั้งเดียว ผู้ใช้ส่งพรอมต์ และระบบจะสร้างวิดีโอที่มีความยาวสูงสุด 20 วินาที ขึ้นอยู่กับโมเดลและการกำหนดค่าที่เลือก นอกจากนี้ ยังรองรับความละเอียดสูง เช่น 4K และอัตราเฟรมสูงสุด 50 FPS ทำให้เหมาะสำหรับแอปพลิเคชันระดับมืออาชีพ

Lightricks เป็นผู้ให้บริการ API ซึ่งรับประกันความสามารถในการปรับขนาดและความน่าเชื่อถือ ผู้ใช้เข้าถึงได้ผ่านปลายทาง HTTPS โดยการตอบกลับจะส่งไฟล์ MP4 โดยตรง แนวทางแบบซิงโครนัสนี้ช่วยลดความซับซ้อนของเวิร์กโฟลว์ เนื่องจากนักพัฒนาจะได้รับวิดีโอที่สร้างขึ้นในส่วนเนื้อหาการตอบกลับโดยไม่ต้องทำการตรวจสอบสถานะ อย่างไรก็ตาม มีการจำกัดอัตรา (rate limits) เพื่อป้องกันการโอเวอร์โหลด ดังนั้นทีมงานจึงต้องตรวจสอบการใช้งานอย่างระมัดระวัง

เมื่อเทียบกับทางเลือกโอเพนซอร์ส LTX-2 API ที่โฮสต์ไว้นั้นช่วยลดความซับซ้อนของข้อกำหนดด้านฮาร์ดแวร์ นักพัฒนาไม่ต้องจัดการ GPU หรือติดตั้งเฟรมเวิร์กอย่าง ComfyUI แต่เน้นไปที่การรวมระบบแทน อย่างไรก็ตาม สำหรับผู้ที่ต้องการรันแบบโลคัล Lightricks มีโมเดล LTX-2 แบบโอเพนซอร์สให้บน GitHub แต่คู่มือนี้เน้นที่การใช้ API เพื่อประสิทธิภาพบนคลาวด์

เริ่มต้นใช้งาน LTX-2 API

ผู้ใช้เริ่มต้นด้วยการขอรับข้อมูลประจำตัว ขั้นแรก ให้เข้าสู่ระบบ Developer Console แพลตฟอร์มจะแนะนำคุณในการสร้างบัญชีหากจำเป็น เมื่อเข้าสู่ระบบแล้ว ให้สร้างคีย์ API ได้โดยตรงจากแดชบอร์ด

คีย์นี้ทำหน้าที่เป็นโทเค็นการเข้าถึงของคุณ จัดเก็บไว้อย่างปลอดภัย เนื่องจากใช้ในการรับรองความถูกต้องของคำขอทั้งหมด ตัวอย่างเช่น ให้จัดเก็บไว้ในตัวแปรสภาพแวดล้อม (environment variables) เพื่อหลีกเลี่ยงการ hardcoding ในสคริปต์ ใน Bash ให้รัน export LTXV_API_KEY="your_key_here" นักพัฒนา Python ดึงค่าได้ด้วย import os; api_key = os.environ.get("LTXV_API_KEY") ผู้ใช้ Node.js เข้าถึงได้ผ่าน process.env.LTXV_API_KEY

หลังจากรักษาความปลอดภัยคีย์แล้ว ให้ทดสอบการเชื่อมต่อด้วยคำขอที่เรียบง่าย ใช้เครื่องมืออย่าง curl หรือ Apidog เพื่อตรวจสอบการตั้งค่า ขั้นตอนนี้เป็นการยืนยันสถานะบัญชีของคุณ และช่วยให้คุณคุ้นเคยกับรูปแบบการตอบกลับของ API หากเกิดปัญหา ให้ตรวจสอบข้อผิดพลาดทั่วไป เช่น คีย์ไม่ถูกต้อง ซึ่งจะคืนค่าสถานะ 401

นอกจากนี้ ให้ตรวจสอบรายละเอียดแผนของคุณในคอนโซล ระดับที่แตกต่างกันจะมีเครดิตและข้อจำกัดที่แตกต่างกัน ซึ่งส่งผลต่อความถี่ในการสร้างวิดีโอของคุณ ทีมสามารถอัปเกรดแผนได้ตามความจำเป็นเพื่อรองรับปริมาณที่สูงขึ้น

วิธีการรับรองความถูกต้องของคำขอใน LTX-2 API?

การรับรองความถูกต้องช่วยปกป้องการเข้าถึง API ใส่คีย์ในส่วนหัว Authorization ของทุกคำขอโดยใช้รูปแบบ Bearer โดยเฉพาะ ให้ตั้งค่า Authorization: Bearer YOUR_API_KEY

ตัวอย่างเช่น คำสั่ง curl มีลักษณะดังนี้:

curl -X POST https://api.ltx.video/v1/text-to-video \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"prompt": "A serene mountain landscape at dawn", "model": "ltx-2-pro", "duration": 8, "resolution": "1920x1080"}'

การนำไปใช้งานด้วย Python ใช้ไลบรารี requests:

import requests
import os

api_key = os.environ.get("LTXV_API_KEY")
headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json"
}
payload = {
    "prompt": "A serene mountain landscape at dawn",
    "model": "ltx-2-pro",
    "duration": 8,
    "resolution": "1920x1080"
}
response = requests.post("https://api.ltx.video/v1/text-to-video", headers=headers, json=payload)
if response.status_code == 200:
    with open("video.mp4", "wb") as f:
        f.write(response.content)

ปฏิบัติตามแนวทางปฏิบัติด้านความปลอดภัยอย่างเคร่งครัด ห้ามเปิดเผยคีย์ในโค้ดฝั่งไคลเอ็นต์หรือใน repository หมุนเวียนคีย์เป็นระยะผ่านคอนโซล นอกจากนี้ ให้ใช้ตัวแปรสภาพแวดล้อมสำหรับการจัดเก็บเพื่อเพิ่มความยืดหยุ่นในการพกพา

หากการรับรองความถูกต้องล้มเหลว API จะตอบกลับด้วยสถานะ 401 Unauthorized ส่วนเนื้อหาจะรวมรายละเอียด เช่น "Invalid API key" หรือ "Missing authorization header" แก้ไขปัญหาโดยการตรวจสอบรูปแบบและวันหมดอายุของคีย์ การแก้ไขทั่วไปได้แก่ การสร้างคีย์ใหม่หรือการแก้ไขไวยากรณ์ของส่วนหัว

ทำความเข้าใจโมเดลที่รองรับใน LTX-2 API

LTX-2 API มีโมเดลหลักสองแบบ: ltx-2-fast และ ltx-2-pro แต่ละแบบได้รับการปรับให้เหมาะสมสำหรับลำดับความสำคัญที่แตกต่างกัน

โมเดล ltx-2-fast ให้ความสำคัญกับประสิทธิภาพ รองรับความละเอียดสูงสุด 3840x2160, อัตราเฟรม (FPS) ที่ 25 หรือ 50 และระยะเวลาตั้งแต่ 6 ถึง 20 วินาทีในการกำหนดค่าบางอย่าง ตัวอย่างเช่น ที่ความละเอียด 1920x1080 และ 25 FPS สามารถจัดการได้สูงสุด 20 วินาที โมเดลนี้เหมาะสำหรับการสร้างต้นแบบอย่างรวดเร็วที่ความเร็วมีความสำคัญมากกว่าความสมบูรณ์แบบ

ในทางกลับกัน โมเดล ltx-2-pro เน้นที่คุณภาพ มันจำกัดระยะเวลาไว้ที่ 6, 8 หรือ 10 วินาที แต่ให้รายละเอียดและความสอดคล้องกันที่เหนือกว่า นอกจากนี้ยังรองรับความละเอียดสูงสุด 3840x2160 และอัตราเฟรมที่ 25 หรือ 50 FPS นักพัฒนาเลือกใช้สำหรับผลลัพธ์สุดท้ายที่ต้องการความประณีต

อ้างอิงจากตารางการรองรับโมเดลนี้สำหรับการผสมผสานที่แม่นยำ:

เลือกโมเดลตามความต้องการ ตัวอย่างเช่น ใช้ ltx-2-fast ในระหว่างการพัฒนาซ้ำๆ แล้วจึงเปลี่ยนไปใช้ ltx-2-pro สำหรับการผลิตจริง โปรดทราบว่าความละเอียดและระยะเวลาที่สูงขึ้นจะใช้เครดิตมากขึ้น

การใช้ Text-to-Video Endpoint ใน LTX-2 API อย่างเชี่ยวชาญ

นักพัฒนาเรียกใช้ปลายทาง text-to-video เพื่อสร้างวิดีโอจากคำอธิบาย URL คือ https://api.ltx.video/v1/text-to-video โดยใช้วิธี POST

พารามิเตอร์ที่จำเป็น ได้แก่:

• prompt: สตริง (String) สูงสุด 5000 ตัวอักษร สำหรับอธิบายฉาก
• model: Enum, เลือก "ltx-2-fast" หรือ "ltx-2-pro"
• duration: จำนวนเต็ม (Integer) เป็นวินาที ตามข้อจำกัดของโมเดล
• resolution: สตริง (String) เช่น "1920x1080"

พารามิเตอร์เสริมช่วยเพิ่มการควบคุม:

• fps: จำนวนเต็ม (Integer) ค่าเริ่มต้นคือ 25
• camera_motion: Enum สำหรับเอฟเฟกต์ เช่น แพน (pan) หรือ ซูม (zoom) (ไม่ได้ระบุค่าเฉพาะที่นี่ โปรดดูเอกสารประกอบ)
• generate_audio: บูลีน (Boolean) ค่าเริ่มต้นเป็นจริง (true) สำหรับเสียงที่ซิงโครไนซ์

คำขอคาดหวังเนื้อหาเป็น JSON การตอบกลับที่สำเร็จจะส่งไฟล์ MP4 ในส่วนเนื้อหา พร้อม Content-Type: video/mp4

ตัวอย่างเช่น สร้างวิดีโอ 8 วินาที:

curl -X POST https://api.ltx.video/v1/text-to-video \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"prompt": "A majestic eagle soaring through clouds at sunset", "model": "ltx-2-pro", "duration": 8, "resolution": "1920x1080"}' \
-o video.mp4

โค้ด Python ที่เทียบเท่าจะบันทึกไฟล์โดยตรง หากเกิดข้อผิดพลาด ให้จัดการรหัส เช่น 400 สำหรับพารามิเตอร์ไม่ถูกต้อง หรือ 429 สำหรับการจำกัด

ทดลองใช้พรอมต์เพื่อปรับปรุงผลลัพธ์ ใส่รายละเอียดเกี่ยวกับการกระทำ ตัวละคร และเสียงเพื่อผลลัพธ์ที่ดีขึ้น ปลายทางนี้เป็นรากฐานสำหรับการสร้างวิดีโอจากข้อความ

สำรวจ Image-to-Video Endpoint ใน LTX-2 API

ปลายทาง image-to-video ทำให้รูปภาพนิ่งเคลื่อนไหวได้ ใช้เมธอด POST ไปที่ https://api.ltx.video/v1/image-to-video

พารามิเตอร์หลักคล้ายกับ text-to-video แต่เพิ่ม image_uri: สตริง (String) ซึ่งเป็น URL ไปยังรูปภาพอินพุต (HTTPS, สูงสุด 32MB, รูปแบบเช่น JPG)

ตัวอย่างคำขอ:

curl -X POST https://api.ltx.video/v1/image-to-video \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"image_uri": "https://example.com/sunset.jpg", "prompt": "Clouds drifting across the sky as the sun sets slowly", "model": "ltx-2-pro", "duration": 8, "resolution": "1920x1080"}' \
-o video.mp4

การตอบกลับจะส่งวิดีโอ MP4 แบบเคลื่อนไหว ใช้สิ่งนี้เพื่อทำให้รูปภาพมีชีวิตชีวา เช่น ในแอปการตลาดหรือการศึกษา ตรวจสอบให้แน่ใจว่ารูปภาพสอดคล้องกับพรอมต์เพื่อให้ได้การเคลื่อนไหวที่สอดคล้องกัน

ข้อจำกัดสอดคล้องกับโมเดล: ตรวจสอบความถูกต้องของระยะเวลาและความละเอียด หากการดึงรูปภาพล้มเหลว คาดว่าจะได้รับข้อผิดพลาด 400

การใช้คุณสมบัติ Retake ใน LTX-2 API

ความสามารถในการรีเทคช่วยแก้ไขส่วนต่างๆ ของวิดีโอโดยไม่ต้องสร้างใหม่ทั้งหมด มันกำหนดเป้าหมายช่วงเวลาเฉพาะ โดยแทนที่เสียง วิดีโอ หรือทั้งสองอย่างผ่าน AI

แม้ว่าข้อกำหนดปลายทางโดยละเอียดกำลังอยู่ระหว่างการพัฒนา แต่ก็มีแนวโน้มที่จะใช้ POST ไปยังเส้นทางเช่น /v1/retake พารามิเตอร์จะรวมถึง video_uri สำหรับวิดีโอต้นฉบับ, start_time และ end_time เป็นวินาที และ prompt สำหรับการเปลี่ยนแปลง

ตัวอย่างเช่น เขียนส่วนบทสนทนาใหม่ ซึ่งช่วยประหยัดทรัพยากรเมื่อเทียบกับการสร้างวิดีโอทั้งหมดใหม่ นักพัฒนานำไปใช้สำหรับการปรับปรุงซ้ำๆ ในเวิร์กโฟลว์หลังการผลิต

ตรวจสอบการอัปเดตในเอกสารประกอบสำหรับพารามิเตอร์ทั้งหมด ปัจจุบัน มันเขียนช่วงเวลาใหม่ได้อย่างมีประสิทธิภาพ โดยยังคงการซิงโครไนซ์ไว้

การจัดการข้อผิดพลาดใน LTX-2 API

API กำหนดรูปแบบการตอบสนองข้อผิดพลาดให้เป็นมาตรฐาน:

{
  "type": "error",
  "error": {
    "type": "error_type",
    "message": "Description"
  }
}

รหัสทั่วไป:

• 400: คำขอไม่ถูกต้อง เช่น ไม่มีพรอมต์
• 401: ปัญหาการรับรองความถูกต้อง
• 402: เครดิตไม่เพียงพอ
• 413: เพย์โหลดใหญ่เกินไป
• 422: เนื้อหาถูกกรอง
• 429: เกินขีดจำกัดอัตรา (Rate limit) หรือการทำงานพร้อมกัน (Concurrency limit)
• 500: ข้อผิดพลาดเซิร์ฟเวอร์
• 503: ไม่สามารถให้บริการได้

จัดการอย่างเหมาะสม: ลองอีกครั้งเมื่อเกิด 429 โดยใช้ส่วนหัว Retry-After ตรวจสอบยอดคงเหลือสำหรับ 402 บันทึกข้อความสำหรับการแก้ไขข้อผิดพลาด

แนวทางปฏิบัติที่ดีที่สุด: ตรวจสอบความถูกต้องของอินพุตฝั่งไคลเอ็นต์ ใช้วิธี exponential backoff สำหรับการลองใหม่

การจัดการ Rate Limits ใน LTX-2 API

การจำกัดอัตรา (Rate limits) ช่วยป้องกันการใช้งานในทางที่ผิด ซึ่งรวมถึงการทำงานพร้อมกัน (คำขอที่เกิดขึ้นพร้อมกัน) และอัตรา (คำขอต่อช่วงเวลา) ซึ่งแตกต่างกันไปตามแผน

การเกินขีดจำกัดจะเรียก 429 พร้อมส่วนหัว Retry-After ประเภทข้อผิดพลาด: rate_limit_error หรือ concurrency_limit_error

ตรวจสอบผ่านส่วนหัว ปรับปรุงประสิทธิภาพโดยการรวมกลุ่มคำขอเมื่อทำได้ ใช้ความละเอียดที่ต่ำลงสำหรับการทดสอบ และอัปเกรดแผน

ติดต่อฝ่ายสนับสนุนเพื่อขอเพิ่มขีดจำกัด

แนวทางปฏิบัติที่ดีที่สุดสำหรับการรวม LTX-2 API

ใช้การจัดการข้อผิดพลาดและการบันทึกข้อมูลที่มีประสิทธิภาพ ใช้การประมวลผลแบบอะซิงโครนัสหากต้องการขยายขนาด

รักษาความปลอดภัยคีย์ด้วย vaults ทดสอบพรอมต์อย่างละเอียด

สำหรับการผลิตจริง ให้คำนวณ ค่าใช้จ่าย: วิดีโอที่ยาวขึ้นจะใช้เครดิตมากขึ้น

ผสานรวมกับเวิร์กโฟลว์: สร้างภาพขนาดย่อจากรูปภาพ จากนั้นจึงสร้างวิดีโอเต็มรูปแบบ

การใช้ Apidog กับ LTX-2 API

Apidog ช่วยให้การทดสอบเป็นไปอย่างราบรื่น นำเข้าปลายทาง ตั้งค่าส่วนหัว และส่งคำขอด้วยภาพ

สร้างคอลเลกชันสำหรับการเรียก LTX-2 API แก้ไขข้อผิดพลาดการตอบกลับ รวมถึงไฟล์ MP4 ไบนารี

รองรับสภาพแวดล้อมสำหรับคีย์ ทำให้การสลับใช้งานเป็นเรื่องง่าย

ดาวน์โหลด Apidog ฟรีเพื่อเพิ่มประสิทธิภาพการทำงาน

ตัวอย่างขั้นสูงด้วย LTX-2 API

ใน Python ให้สร้าง wrapper:

import requests
import os

class LTX2API:
    def __init__(self):
        self.api_key = os.environ.get("LTXV_API_KEY")
        self.base_url = "https://api.ltx.video/v1"

    def generate_text_to_video(self, prompt, model="ltx-2-pro", duration=8, resolution="1920x1080"):
        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
        payload = {"prompt": prompt, "model": model, "duration": duration, "resolution": resolution}
        response = requests.post(f"{self.base_url}/text-to-video", headers=headers, json=payload)
        if response.status_code == 200:
            return response.content
        else:
            raise Exception(response.json()["error"]["message"])

# Usage
api = LTX2API()
video_data = api.generate_text_to_video("A futuristic cityscape at night")
with open("output.mp4", "wb") as f:
    f.write(video_data)

ขยายเพื่อรองรับ image-to-video ใช้ในเว็บแอปผ่าน Flask หรือ Django

บทสรุป

LTX-2 API เปลี่ยนแปลงการสร้างวิดีโอ ด้วยการปฏิบัติตามคู่มือนี้ นักพัฒนาจะสามารถใช้ประโยชน์จากพลังของมันได้อย่างมีประสิทธิภาพ เริ่มต้นจากพื้นฐาน ปรับปรุงพรอมต์ และขยายการรวมระบบ เครื่องมืออย่าง Apidog ช่วยลดความซับซ้อนของกระบวนการ ทำให้มั่นใจได้ถึงการพัฒนาที่ราบรื่น