วิธีใช้ Qwen3.5 API ฟรี ด้วย NVIDIA

สรุปเนื้อหา

Qwen3.5 คือโมเดลวิสัยทัศน์-ภาษา (Vision-Language Model - VLM) ขนาด 397 พันล้านพารามิเตอร์สุดล้ำของ Alibaba ที่มาพร้อมสถาปัตยกรรม Mixture of Experts (MoE) คุณสามารถเข้าถึงได้ฟรีผ่านปลายทางที่เร่งด้วย GPU ของ NVIDIA เพียงลงทะเบียนเข้าร่วมโปรแกรม NVIDIA Developer Guide นี้จะแนะนำคุณตลอดขั้นตอนการขอคีย์ API การเรียกใช้ครั้งแรก และการผสานรวมความสามารถแบบหลายโมดอล (multimodal) ของ Qwen3.5 เข้ากับแอปพลิเคชันของคุณ

บทนำ

Qwen3.5 ของ Alibaba แสดงถึงความก้าวหน้าครั้งสำคัญใน AI แบบหลายโมดอล โมเดลขนาด 397 พันล้านพารามิเตอร์นี้ผสมผสานสถาปัตยกรรม Mixture of Experts (MoE) เข้ากับ Gated Delta Networks มอบความสามารถในการให้เหตุผลอันทรงพลังในขณะที่ยังคงพารามิเตอร์ที่ใช้งานอยู่เพียง 17 พันล้านพารามิเตอร์ ผลลัพธ์ที่ได้คือโมเดลที่สามารถเข้าใจรูปภาพ นำทางส่วนต่อประสานผู้ใช้ และจัดการงานหลายโมดอลที่ซับซ้อน ซึ่งทั้งหมดนี้เข้าถึงได้ผ่าน API ฟรี

ส่วนที่ดีที่สุด? คุณสามารถเริ่มใช้ Qwen3.5 ได้ฟรีตอนนี้เลยผ่านแพลตฟอร์มสำหรับนักพัฒนาของ NVIDIA ไม่ว่าคุณจะกำลังสร้างเอเจนต์ AI พัฒนาแอปพลิเคชันการให้เหตุผลด้วยภาพ หรือสำรวจ AI แบบหลายโมดอล คู่มือนี้จะแนะนำคุณในทุกขั้นตอน

Qwen3.5 VLM คืออะไร?

Qwen3.5 คือโมเดลวิสัยทัศน์-ภาษา (VLM) ดั้งเดิมรุ่นแรกของ Alibaba ในซีรีส์ Qwen3.5 ซึ่งออกแบบมาโดยเฉพาะสำหรับการสร้างเอเจนต์อัตโนมัติ Qwen3.5 สร้างขึ้นตั้งแต่ต้นสำหรับการให้เหตุผลแบบหลายโมดอลและการนำทาง UI ซึ่งแตกต่างจาก VLM รุ่นก่อนหน้าที่ปรับมาจากโมเดลข้อความเท่านั้น

ข้อมูลจำเพาะหลัก

อะไรที่ทำให้ Qwen3.5 พิเศษ

สถาปัตยกรรม Mixture of Experts (MoE) หมายความว่ามีเพียงพารามิเตอร์ย่อยๆ ของโมเดลเท่านั้นที่ทำงานสำหรับอินพุตที่กำหนด ซึ่งทำให้โมเดลมีประสิทธิภาพในการคำนวณในขณะที่ยังคงความสามารถในการให้เหตุผลที่ซับซ้อนในพารามิเตอร์ทั้งหมด 397 พันล้าน

ความสามารถของเอเจนต์หลายโมดอลโดยกำเนิด ทำให้ Qwen3.5 แตกต่างจาก VLM อื่นๆ:

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

กรณีการใช้งานที่เหมาะสม

• การเขียนโค้ดและการพัฒนาเว็บ: เขียนและดีบักโค้ดพร้อมบริบทภาพ
• การให้เหตุผลด้วยภาพ: วิเคราะห์ภาพหน้าจอ รูปภาพ และองค์ประกอบ UI
• แอปพลิเคชันแชท: สร้าง AI สนทนาด้วยความเข้าใจแบบหลายโมดอล
• การค้นหาที่ซับซ้อน: ค้นหาทั้งรูปภาพและข้อความพร้อมกัน
• การทำงานอัตโนมัติของ UI: นำทางและโต้ตอบกับอินเทอร์เฟซโดยอัตโนมัติ

โปรแกรม NVIDIA Developer: รับคีย์ API ฟรีของคุณ

NVIDIA ให้การเข้าถึง Qwen3.5 ฟรีผ่านปลายทางที่เร่งด้วย GPU นี่คือวิธีเริ่มต้น:

ขั้นตอนที่ 1: เข้าร่วมโปรแกรม NVIDIA Developer

1. เยี่ยมชม build.nvidia.com
2. คลิก ลงชื่อเข้าใช้ หรือ สร้างบัญชี
3. ลงทะเบียนสำหรับ โปรแกรม NVIDIA Developer (ฟรี)
4. ยืนยันที่อยู่อีเมลของคุณ

ขั้นตอนที่ 2: รับคีย์ API ของคุณ

1. หลังจากเข้าสู่ระบบ ให้ไปที่การตั้งค่าบัญชีของคุณ
2. ค้นหา คีย์ API หรือ คีย์ API ของ NVIDIA
3. คัดลอกคีย์ API ของคุณ (ขึ้นต้นด้วย nvapi-)
4. จัดเก็บอย่างปลอดภัย (คุณจะต้องใช้สำหรับการยืนยันตัวตน)

สำคัญ

ขั้นตอนที่ 3: ทดสอบการเข้าถึงของคุณ

คุณสามารถทดสอบ Qwen3.5 ได้โดยตรงในเบราว์เซอร์ของคุณที่ build.nvidia.com/qwen/qwen3.5-397b-a17b สิ่งนี้ช่วยให้คุณทดลองใช้พรอมต์และประเมินโมเดลด้วยข้อมูลของคุณเองก่อนที่จะเขียนโค้ดใดๆ

การเรียกใช้ Qwen3.5 API ครั้งแรกของคุณ

ตอนนี้เรามาลองเรียกใช้ Qwen3.5 API ครั้งแรกกัน API นี้เข้ากันได้กับรูปแบบของ OpenAI ทำให้ง่ายต่อการผสานรวมเข้ากับแอปพลิเคชันที่มีอยู่

การเรียกใช้ API พื้นฐาน

import requests

# Configuration
invoke_url = "https://integrate.api.nvidia.com/v1/chat/completions"
api_key = "YOUR_NVIDIA_API_KEY"  # แทนที่ด้วยคีย์ API ของคุณ

headers = {
    "Authorization": f"Bearer {api_key}",
    "Accept": "application/json",
}

# Payload - คำขอแบบข้อความธรรมดา
payload = {
    "messages": [
        {
            "role": "user",
            "content": "What are the key features of Qwen3.5 VLM?"
        }
    ],
    "model": "qwen/qwen3.5-397b-a17b",
    "max_tokens": 1024,
    "temperature": 0.7,
}

# ทำการร้องขอ
session = requests.Session()
response = session.post(invoke_url, headers=headers, json=payload)
response.raise_for_status()

# พิมพ์การตอบกลับ
result = response.json()
print(result['choices'][0]['message']['content'])

การร้องขอแบบหลายโมดอล (พร้อมรูปภาพ)

หากต้องการใช้ความสามารถด้านการมองเห็นของ Qwen3.5 ให้รวมข้อมูลรูปภาพไว้ในคำขอของคุณ:

import requests
import base64

# ฟังก์ชันสำหรับเข้ารหัสรูปภาพเป็น base64
def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')

# เข้ารหัสรูปภาพของคุณ
image_base64 = encode_image("screenshot.png")

invoke_url = "https://integrate.api.nvidia.com/v1/chat/completions"
api_key = "YOUR_NVIDIA_API_KEY"

headers = {
    "Authorization": f"Bearer {api_key}",
    "Accept": "application/json",
}

# คำขอแบบหลายโมดอลพร้อมรูปภาพ
payload = {
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/png;base64,{image_base64}"}
                },
                {
                    "type": "text",
                    "text": "What do you see in this image? Describe the UI elements."
                }
            ]
        }
    ],
    "model": "qwen/qwen3.5-397b-a17b",
    "max_tokens": 1024,
}

response = requests.post(invoke_url, headers=headers, json=payload)
result = response.json()
print(result['choices'][0]['message']['content'])

ตัวอย่างโค้ดใน Python และ JavaScript

Python: ตัวอย่างการผสานรวมที่สมบูรณ์

import os
import requests
from requests.exceptions import RequestException

class QwenClient:
    """Python client สำหรับ Qwen3.5 API"""

    def __init__(self, api_key=None):
        self.api_key = api_key or os.getenv("NVIDIA_API_KEY")
        self.endpoint = "https://integrate.api.nvidia.com/v1/chat/completions"
        self.model = "qwen/qwen3.5-397b-a17b"

    def chat(self, message, system_prompt=None, **kwargs):
        """ส่งข้อความแชทไปยัง Qwen3.5"""
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }

        messages = []
        if system_prompt:
            messages.append({"role": "system", "content": system_prompt})
        messages.append({"role": "user", "content": message})

        payload = {
            "messages": messages,
            "model": self.model,
            "max_tokens": kwargs.get("max_tokens", 2048),
            "temperature": kwargs.get("temperature", 0.7),
            "top_p": kwargs.get("top_p", 0.9),
        }

        # เปิดใช้งานโหมดการคิดหากมีการร้องขอ
        if kwargs.get("thinking", False):
            payload["chat_template_kwargs"] = {"thinking": True}

        try:
            response = requests.post(
                self.endpoint,
                headers=headers,
                json=payload,
                timeout=kwargs.get("timeout", 60)
            )
            response.raise_for_status()
            return response.json()
        except RequestException as e:
            return {"error": str(e)}

    def chat_with_image(self, message, image_path, **kwargs):
        """ส่งข้อความแชทพร้อมรูปภาพไปยัง Qwen3.5"""
        import base64

        with open(image_path, "rb") as f:
            image_base64 = base64.b64encode(f.read()).decode("utf-8")

        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }

        payload = {
            "messages": [{
                "role": "user",
                "content": [
                    {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_base64}"}},
                    {"type": "text", "text": message}
                ]
            }],
            "model": self.model,
            "max_tokens": kwargs.get("max_tokens", 2048),
            "temperature": kwargs.get("temperature", 0.7),
        }

        response = requests.post(self.endpoint, headers=headers, json=payload)
        response.raise_for_status()
        return response.json()


# ตัวอย่างการใช้งาน
client = QwenClient(api_key="YOUR_NVIDIA_API_KEY")

# แชทแบบข้อความเท่านั้น
result = client.chat("Explain Mixture of Experts architecture in simple terms")
print(result['choices'][0]['message']['content'])

# แชทแบบหลายโมดอล
result = client.chat_with_image(
    "What UI elements are in this screenshot?",
    "screenshot.png"
)
print(result['choices'][0]['message']['content'])

JavaScript/Node.js: ตัวอย่างการผสานรวมที่สมบูรณ์

const axios = require('axios');

class QwenClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.endpoint = 'https://integrate.api.nvidia.com/v1/chat/completions';
    this.model = 'qwen/qwen3.5-397b-a17b';
  }

  async chat(message, options = {}) {
    const { systemPrompt, temperature = 0.7, maxTokens = 2048, thinking = false } = options;

    const messages = [];
    if (systemPrompt) {
      messages.push({ role: 'system', content: systemPrompt });
    }
    messages.push({ role: 'user', content: message });

    const payload = {
      messages,
      model: this.model,
      temperature,
      max_tokens: maxTokens,
      ...(thinking && { chat_template_kwargs: { thinking: true } })
    };

    try {
      const response = await axios.post(this.endpoint, payload, {
        headers: {
          'Authorization': `Bearer ${this.apiKey}`,
          'Content-Type': 'application/json'
        },
        timeout: 60000
      });

      return response.data;
    } catch (error) {
      console.error('API Error:', error.response?.data || error.message);
      throw error;
    }
  }

  async chatWithImage(message, imageBase64, options = {}) {
    const { temperature = 0.7, maxTokens = 2048 } = options;

    const payload = {
      messages: [{
        role: 'user',
        content: [
          { type: 'image_url', image_url: { url: `data:image/png;base64,${imageBase64}` } },
          { type: 'text', text: message }
        ]
      }],
      model: this.model,
      temperature,
      max_tokens: maxTokens
    };

    const response = await axios.post(this.endpoint, payload, {
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      }
    });

    return response.data;
  }
}

// การใช้งาน
const client = new QwenClient(process.env.NVIDIA_API_KEY);

// แชทข้อความ
const result = await client.chat('What is the advantage of MoE architecture?');
console.log(result.choices[0].message.content);

// เปิดใช้งานการคิด
const deepResult = await client.chat('Explain how reasoning works in LLMs', {
  thinking: true
});
console.log(deepResult.choices[0].message.content);

คุณสมบัติขั้นสูง: โหมดการคิดและการเรียกใช้เครื่องมือ

โหมดการคิด

Qwen3.5 รองรับโหมด "การคิด" ขั้นสูงที่ช่วยให้โมเดลสามารถแสดงกระบวนการคิดของมันได้ สิ่งนี้มีประโยชน์อย่างยิ่งสำหรับงานการแก้ปัญหาที่ซับซ้อน

payload = {
    "messages": [{"role": "user", "content": "Solve this step by step: If a train travels 120km in 2 hours, what is its speed?"}],
    "model": "qwen/qwen3.5-397b-a17b",
    "chat_template_kwargs": {"thinking": True},
    "max_tokens": 4096,
}

response = session.post(invoke_url, headers=headers, json=payload)
result = response.json()
print(result['choices'][0]['message']['content'])

การเรียกใช้เครื่องมือ

Qwen3.5 รองรับการเรียกใช้ฟังก์ชันผ่านเครื่องมือที่เข้ากันได้กับ OpenAI สิ่งนี้ช่วยให้คุณสามารถสร้างแอปพลิเคชันเอเจนต์ที่สามารถดำเนินการจริงได้

import json

# กำหนดเครื่องมือสำหรับโมเดลที่จะใช้
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "City name"}
                },
                "required": ["location"]
            }
        }
    }
]

payload = {
    "messages": [
        {"role": "user", "content": "What's the weather like in Tokyo?"}
    ],
    "model": "qwen/qwen3.5-397b-a17b",
    "tools": tools,
    "tool_choice": "auto"
}

response = session.post(invoke_url, headers=headers, json=payload)
result = response.json()

# ตรวจสอบว่าโมเดลต้องการเรียกใช้เครื่องมือหรือไม่
if 'tool_calls' in result['choices'][0]['message']:
    tool_call = result['choices'][0]['message']['tool_calls'][0]
    print(f"Model wants to call: {tool_call['function']['name']}")
    print(f"Arguments: {tool_call['function']['arguments']}")

ทำความเข้าใจข้อจำกัดอัตราและราคา

ระดับฟรีปัจจุบัน (โปรแกรม NVIDIA Developer)

สิ่งนี้มีความหมายต่อคุณอย่างไร

• ไม่ต้องใช้บัตรเครดิต: เพียงลงทะเบียนสำหรับโปรแกรม NVIDIA Developer ฟรี
• เร่งด้วย GPU: คำขอจะทำงานบน NVIDIA Blackwell GPUs
• พร้อมสำหรับการใช้งานจริง: ปลายทางเดียวกันที่ใช้สำหรับเวิร์กโหลดการผลิต

การขยายสู่การใช้งานจริง

เมื่อคุณพร้อมที่จะก้าวข้ามระดับฟรี:

1. NVIDIA NIM: ปรับใช้โมเดลในคอนเทนเนอร์ได้ทุกที่ (คลาวด์, ในองค์กร, ไฮบริด)
2. NeMo: ปรับแต่งโมเดลสำหรับโดเมนเฉพาะของคุณ
3. การสนับสนุนระดับองค์กร: ติดต่อ NVIDIA สำหรับโครงสร้างพื้นฐานโดยเฉพาะ

การปรับใช้สำหรับการใช้งานจริงด้วย NVIDIA NIM

NVIDIA NIM (NVIDIA Inference Microservices) ทำให้การนำ Qwen3.5 จากการพัฒนาไปสู่การใช้งานจริงเป็นเรื่องง่าย

NIM คืออะไร?

NIM ให้คอนเทนเนอร์ที่สร้างไว้ล่วงหน้าและปรับแต่งให้เหมาะสมสำหรับการอนุมาน AI ไมโครเซอร์วิส NIM แต่ละรายการประกอบด้วย:

• โมเดลพร้อมการปรับแต่งประสิทธิภาพ
• API มาตรฐาน (เข้ากันได้กับ OpenAI)
• ความยืดหยุ่นในการปรับใช้ (คลาวด์, ในองค์กร, ที่ Edge)

การปรับใช้ Qwen3.5 ด้วย NIM

# ดึงคอนเทนเนอร์ Qwen3.5 NIM
docker pull nvcr.io/nim/qwen/qwen3.5-397b-a17b:latest

# รันคอนเทนเนอร์
docker run --gpus all --rm -p 8000:8000 \
  -e NVIDIA_API_KEY=$NVIDIA_API_KEY \
  nvcr.io/nim/qwen/qwen3.5-397b-a17b:latest

ตอนนี้โมเดลของคุณกำลังทำงานอยู่ภายในเครื่องที่ http://localhost:8000/v1/chat/completions

ประโยชน์ของ NIM

• ปรับใช้ได้ทุกที่: รันบนเครื่อง ในคลาวด์ หรือแบบไฮบริด
• ประสิทธิภาพที่ปรับแต่ง: ปรับแต่งสำหรับการอนุมาน GPU ของ NVIDIA
• API ที่สอดคล้องกัน: อินเทอร์เฟซที่เข้ากันได้กับ OpenAI
• ปรับขนาดได้: ขยายขนาดจากการพัฒนาสู่การผลิตได้อย่างราบรื่น

การปรับแต่งด้วย NVIDIA NeMo

สำหรับแอปพลิเคชันเฉพาะโดเมน คุณสามารถปรับแต่ง Qwen3.5 ได้โดยใช้ NVIDIA NeMo

ความสามารถของเฟรมเวิร์ก NeMo

• การปรับแต่งที่รวดเร็ว: การฝึกอบรมแบบ PyTorch-native
• รองรับ LoRA: การปรับแต่งที่มีประสิทธิภาพด้านหน่วยความจำ
• การฝึกอบรมแบบหลายโหนด: รองรับ Slurm และ Kubernetes
• การผสานรวม Hugging Face: การฝึกอบรมโดยตรงบนจุดตรวจสอบที่มีอยู่

ตัวอย่าง: การปรับแต่งสำหรับ Medical VQA

NVIDIA มีบทแนะนำทางเทคนิคสำหรับการปรับแต่ง Qwen3.5 บนชุดข้อมูลรังสีวิทยาสำหรับ Medical Visual Question Answering สิ่งนี้แสดงให้เห็นถึงวิธีปรับโมเดลสำหรับโดเมนเฉพาะทาง เช่น การดูแลสุขภาพ

สรุป

Qwen3.5 แสดงถึงโอกาสที่น่าตื่นเต้นในการใช้โมเดล AI หลายโมดอลที่ล้ำสมัยโดยไม่มีค่าใช้จ่ายผ่านแพลตฟอร์มสำหรับนักพัฒนาของ NVIDIA ด้วยสถาปัตยกรรม MoE ขนาด 397 พันล้านพารามิเตอร์ ความสามารถในการมองเห็นโดยกำเนิด และการเข้าถึง API ฟรี ทำให้เป็นตัวเลือกที่ยอดเยี่ยมสำหรับ:

• การสร้างเอเจนต์ AI แบบหลายโมดอล
• การพัฒนาแอปพลิเคชันการให้เหตุผลด้วยภาพ
• การสร้างผู้ช่วยเขียนโค้ดพร้อมบริบทภาพ
• การทำงานอัตโนมัติของงานนำทาง UI

การเริ่มต้นนั้นง่ายดาย: ลงทะเบียนสำหรับโปรแกรม NVIDIA Developer รับคีย์ API ของคุณ และเริ่มสร้างสรรค์ได้เลย

หากคุณกำลังสร้างแอปพลิเคชันที่ผสานรวมกับ Qwen3.5 หรือ API AI อื่นๆ Apidog มีโครงสร้างพื้นฐานการทดสอบที่คุณต้องการ ทดสอบการผสานรวม API ของคุณ ตรวจสอบการตอบสนอง จัดการตัวแปรสภาพแวดล้อม และทำให้เวิร์กโฟลว์การทดสอบของคุณเป็นอัตโนมัติด้วยแพลตฟอร์มที่ครอบคลุมของ Apidog

คำถามที่พบบ่อย

Qwen3.5 ใช้งานได้ฟรีจริงหรือ?

ใช่ NVIDIA ให้การเข้าถึงปลายทางที่เร่งด้วย GPU ของ Qwen3.5 ฟรีผ่านโปรแกรมสำหรับนักพัฒนาของพวกเขา ไม่ต้องใช้บัตรเครดิต เพียงลงทะเบียนที่ build.nvidia.com เพื่อรับคีย์ API ของคุณ

อะไรที่ทำให้ Qwen3.5 แตกต่างจาก VLM อื่นๆ?

Qwen3.5 สร้างขึ้นโดยเฉพาะสำหรับเอเจนต์อัตโนมัติ ไม่ได้ปรับจากโมเดลข้อความเท่านั้น สถาปัตยกรรม Mixture of Experts (รวม 397 พันล้าน, ใช้งานอยู่ 17 พันล้าน) ให้การให้เหตุผลที่ทรงพลังในขณะที่ยังคงประสิทธิภาพในการคำนวณ โดยเฉพาะอย่างยิ่งดีในการนำทาง UI และงานการให้เหตุผลด้วยภาพ

ฉันสามารถใช้ Qwen3.5 สำหรับโครงการเชิงพาณิชย์ได้หรือไม่?

ตรวจสอบเงื่อนไขการอนุญาตใช้งานปัจจุบันบนแพลตฟอร์มของ NVIDIA สำหรับการใช้งานจริง ให้พิจารณา NVIDIA NIM สำหรับการปรับใช้ หรือติดต่อ NVIDIA เกี่ยวกับตัวเลือกสำหรับองค์กร

ความแตกต่างระหว่างระดับฟรีกับ NIM คืออะไร?

ระดับฟรี (โปรแกรมสำหรับนักพัฒนา) ใช้ปลายทางที่ NVIDIA โฮสต์ NIM ช่วยให้คุณปรับใช้โมเดลด้วยตัวเองโดยใช้คอนเทนเนอร์ ไม่ว่าจะในองค์กร ในคลาวด์ของคุณ หรือสภาพแวดล้อมแบบไฮบริด NIM ได้รับการออกแบบมาสำหรับการปรับใช้ขนาดใหญ่ในระดับการผลิต

ฉันจะจัดการข้อจำกัดอัตราได้อย่างไร?

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

ฉันสามารถปรับแต่ง Qwen3.5 ได้หรือไม่?

ได้! เฟรมเวิร์ก NVIDIA NeMo มีเครื่องมือสำหรับการปรับแต่ง Qwen3.5 บนข้อมูลเฉพาะโดเมนของคุณ ซึ่งรวมถึง LoRA สำหรับการปรับแต่งที่มีประสิทธิภาพด้านหน่วยความจำและการรองรับหลายโหนดสำหรับการฝึกอบรมขนาดใหญ่