Nemotron Nano 12B v2 VL: วิธีใช้ NVIDIA API ฟรี

นักพัฒนาแสวงหาเครื่องมือที่มีประสิทธิภาพที่สามารถจัดการได้ทั้งข้อความและรูปภาพโดยไม่เสียค่าใช้จ่ายจำนวนมาก NVIDIA Nemotron Nano 12B v2 VL โดดเด่นในฐานะโมเดลวิสัยทัศน์-ภาษาที่กะทัดรัดแต่ทรงพลัง และการเข้าถึงผ่าน NVIDIA API free tier บนแพลตฟอร์มอย่าง OpenRouter ทำให้การทดลองเป็นเรื่องง่าย

💡

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

ปุ่ม

โพสต์นี้จะแนะนำคุณตลอดกระบวนการใช้ประโยชน์จาก NVIDIA Nemotron Nano 12B v2 VL API ได้ฟรี คุณจะได้เรียนรู้เกี่ยวกับสถาปัตยกรรมของโมเดล ข้อกำหนดในการตั้งค่า ขั้นตอนการนำไปใช้งานจริง และรูปแบบการใช้งานขั้นสูง เมื่ออ่านจบ คุณจะมีความรู้ที่จะนำโมเดลนี้ไปปรับใช้ในแอปพลิเคชันของคุณ ตั้งแต่การสร้างคำบรรยายภาพไปจนถึงการตอบคำถามด้วยภาพ

ทำความเข้าใจ NVIDIA Nemotron Nano 12B v2 VL: สถาปัตยกรรมหลักและความสามารถ

วิศวกรของ NVIDIA ได้ออกแบบโมเดล Nemotron Nano 12B v2 VL เพื่อตอบสนองความต้องการที่เพิ่มขึ้นสำหรับการประมวลผลวิสัยทัศน์-ภาษาที่มีประสิทธิภาพ โมเดลพารามิเตอร์ 12 พันล้านตัวนี้รวมความเข้าใจภาษาที่ใช้หม้อแปลงไฟฟ้าเข้ากับตัวเข้ารหัสภาพ ทำให้สามารถประมวลผลลำดับข้อความและรูปภาพที่สลับกันได้ Nemotron Nano 12B v2 VL แตกต่างจากโมเดลขนาดใหญ่ที่ต้องการทรัพยากร GPU จำนวนมาก โดยได้รับการปรับให้เหมาะสมสำหรับการใช้งานบน Edge และการอนุมานที่มีความหน่วงต่ำ ทำให้เหมาะสำหรับแอปพลิเคชันแบบเรียลไทม์

หัวใจหลักของโมเดลนี้คือการใช้ Vision Transformer (ViT) เพื่อดึงคุณสมบัติจากภาพที่ป้อนเข้ามา ตามด้วย Multimodal Projector ที่ปรับคุณสมบัติเหล่านี้ให้เข้ากับพื้นที่การฝังข้อความ ส่วนประกอบภาษาถูกสร้างขึ้นบนสถาปัตยกรรม Nemotron ของ NVIDIA ซึ่งรวมเอา Rotary Positional Embeddings เพื่อจัดการบริบทที่ยาวขึ้น การตั้งค่านี้รองรับความยาวบริบทได้สูงสุด 4,096 โทเค็น ซึ่งเพียงพอสำหรับงานปฏิบัติส่วนใหญ่ที่เกี่ยวข้องกับคำอธิบายสั้นๆ หรือคำถามที่จับคู่กับภาพ

ความสามารถหลักประกอบด้วย:

การจัดเรียงภาพและข้อความ: โมเดลสร้างคำบรรยายภาพหรือตอบคำถามตามเนื้อหาภาพ
การให้เหตุผลแบบหลายโมดอล (Multimodal Reasoning): สามารถทำงานต่างๆ เช่น การตอบคำถามด้วยภาพ (VQA) ซึ่งผู้ใช้สอบถามรายละเอียดเฉพาะจากภาพ เช่น "รถยนต์ที่อยู่ด้านหน้ามีสีอะไร?"
การทำความเข้าใจเอกสาร: ประมวลผลเอกสารที่สแกนหรือแผนภูมิโดยการรวมการแยกข้อความแบบ OCR เข้ากับการตีความเชิงความหมาย

ผลการทดสอบแสดงให้เห็นประสิทธิภาพที่แข็งแกร่ง: บนชุดข้อมูล VQAv2, Nemotron Nano 12B v2 VL บรรลุความแม่นยำประมาณ 75% ซึ่งเทียบเท่ากับโมเดลขนาดใหญ่ในขณะที่ใช้ทรัพยากรคอมพิวเตอร์น้อยกว่ามาก สำหรับนักพัฒนา นี่หมายถึงรอบการสร้างต้นแบบที่เร็วขึ้น โดยเฉพาะอย่างยิ่งเมื่อใช้การเข้าถึง NVIDIA API ฟรี

นอกจากนี้ ตัวเลือกการควอนไทซ์ของโมเดล เช่น น้ำหนัก 4 บิตหรือ 8 บิต ช่วยลดการใช้หน่วยความจำโดยไม่สูญเสียความแม่นยำอย่างมีนัยสำคัญ NVIDIA ให้บริการสิ่งเหล่านี้ผ่านแคตตาล็อก NGC ของพวกเขา แต่สำหรับการใช้งานแบบ API แพลตฟอร์มเช่น OpenRouter จะจัดการงานหนัก โดยเปิดเผยโมเดลผ่านเอนด์พอยต์ HTTP ที่ได้มาตรฐาน

การเข้าถึง NVIDIA API Free Tier: การผสานรวม OpenRouter

หากต้องการใช้ NVIDIA Nemotron Nano 12B v2 VL API ได้ฟรี คุณจะต้องส่งคำขอผ่าน OpenRouter ซึ่งเป็นเกตเวย์แบบรวมสำหรับโมเดล AI OpenRouter มี Free Tier ที่ใจกว้างสำหรับโมเดลเฉพาะรุ่นนี้ โดยอนุญาตให้ส่งคำขอได้สูงสุด 10 คำขอต่อนาที และ 1,000 โทเค็นต่อนาทีโดยไม่มีค่าใช้จ่าย ข้อจำกัดนี้เหมาะสำหรับการทดสอบและการพัฒนาขนาดเล็ก และคุณสามารถอัปเกรดเป็นแผนแบบชำระเงินเพื่อรองรับปริมาณงานที่สูงขึ้นได้หากจำเป็น

ก่อนอื่น ให้สร้างบัญชีบน OpenRouter ไปที่แดชบอร์ดของพวกเขาและลงทะเบียนโดยใช้อีเมลหรือข้อมูลประจำตัว GitHub ของคุณ เมื่อเข้าสู่ระบบแล้ว ให้สร้างคีย์ API จากส่วน "Keys" คีย์นี้จะยืนยันการเรียกใช้ที่ตามมาทั้งหมด โดยใช้รูปแบบ Bearer token ที่เรียบง่าย

OpenRouter ทำให้อินเทอร์เฟซ API เป็นมาตรฐานเพื่อเลียนแบบรูปแบบของ OpenAI ซึ่งช่วยลดความซับซ้อนในการย้ายข้อมูลสำหรับนักพัฒนาที่คุ้นเคยกับเอนด์พอยต์ GPT URL พื้นฐานสำหรับคำขอคือ https://openrouter.ai/api/v1 และคุณระบุโมเดลเป็น nvidia/nemotron-nano-12b-v2-vl:free แท็กนี้ช่วยให้แน่ใจว่าคุณจะเรียกใช้เอนด์พอยต์ Free Tier โดยหลีกเลี่ยงค่าใช้จ่ายที่ไม่ตั้งใจ

สำหรับการป้อนข้อมูลภาพ คุณจะเข้ารหัสภาพเป็นสตริง base64 ภายในเพย์โหลด JSON API รองรับรูปแบบ JPEG และ PNG โดยมีความละเอียดสูงสุด 1024x1024 พิกเซลต่อภาพ หากมีความละเอียดสูงกว่าจะมีการปรับขนาดอัตโนมัติเพื่อป้องกันการโอเวอร์โฟลว์ ข้อมูลป้อนเข้าที่เป็นข้อความยังคงเป็นสตริง UTF-8 มาตรฐาน และโมเดลจะส่งออกการตอบกลับในรูปแบบ JSON ที่มีข้อความที่สร้างขึ้น

เมื่อเปลี่ยนจากการตั้งค่าไปสู่การนำไปใช้งาน คุณจะต้องเตรียมสภาพแวดล้อมการพัฒนาของคุณ ติดตั้ง Python 3.8 หรือใหม่กว่า พร้อมกับไลบรารี requests สำหรับการจัดการ HTTP สำหรับการทดสอบขั้นสูงยิ่งขึ้น Apidog ผสานรวมได้อย่างราบรื่น ช่วยให้คุณสามารถมองเห็นวัฏจักรของคำขอ/การตอบกลับ และส่งออกคอลเลกชันเพื่อการทำงานร่วมกันในทีม

การตั้งค่าทีละขั้นตอน: ข้อกำหนดเบื้องต้นและการกำหนดค่าสภาพแวดล้อม

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

ถัดไป สร้างสภาพแวดล้อมเสมือนเพื่อแยกการพึ่งพา:

python -m venv nemotron_env
source nemotron_env/bin/activate  # บน Windows: nemotron_env\Scripts\activate

ติดตั้งแพ็กเกจที่จำเป็น:

pip install requests

จัดเก็บคีย์ API ของ OpenRouter ของคุณอย่างปลอดภัย ใช้ตัวแปรสภาพแวดล้อมสำหรับจุดประสงค์นี้ — สร้างไฟล์ .env ในไดเรกทอรีโปรเจกต์ของคุณด้วย OPENROUTER_API_KEY=your_key_here โหลดโดยใช้ไลบรารี python-dotenv:

pip install python-dotenv

ในโค้ดของคุณ นำเข้าและใช้งานดังนี้:

import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENROUTER_API_KEY')

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

นอกจากนี้ หากคุณชื่นชอบการทดสอบแบบ GUI, Apidog ก็โดดเด่นในด้านนี้ คุณสามารถนำเข้า OpenRouter schema เข้าสู่ Apidog ได้โดยตรง กำหนดค่าคีย์ NVIDIA API ฟรีของคุณ และเรียกใช้การจำลองโดยไม่ต้องเขียนโค้ด วิธีนี้ช่วยเร่งการแก้ไขข้อบกพร่อง โดยเฉพาะอย่างยิ่งสำหรับเพย์โหลดแบบหลายโมดอลที่โครงสร้าง JSON มีความสำคัญ

การใช้งาน API พื้นฐาน: ตัวอย่างเฉพาะข้อความและเฉพาะรูปภาพ

คุณเริ่มต้นด้วยคำขอแบบง่ายๆ เพื่อสร้างความมั่นใจ เอนด์พอยต์หลักคือ /chat/completions ซึ่งเป็นเมธอด POST ที่รับ JSON body ที่มี model, messages และพารามิเตอร์เสริม เช่น temperature (0-2 สำหรับการควบคุมความคิดสร้างสรรค์) และ max_tokens (สูงสุด 2048)

พิจารณาคำถามที่เป็นข้อความเท่านั้นเพื่อทำความคุ้นเคยกับโมเดล:

import requests
import json
import base64

url = "https://openrouter.ai/api/v1/chat/completions"
headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json"
}

payload = {
    "model": "nvidia/nemotron-nano-12b-v2-vl:free",
    "messages": [
        {"role": "user", "content": "Explain the basics of vision-language models in 100 words."}
    ],
    "max_tokens": 150,
    "temperature": 0.7
}

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

สคริปต์นี้จะส่งคำสั่งและดึงคำอธิบายที่กระชับ การตอบกลับจะถูกส่งกลับมาภายในเวลาเฉลี่ยไม่ถึง 2 วินาที ต้องขอบคุณการกำหนดเส้นทางที่ปรับให้เหมาะสมของ OpenRouter

ตอนนี้ ขยายไปสู่การประมวลผลเฉพาะรูปภาพ เข้ารหัสไฟล์รูปภาพเป็น base64:

with open("sample_image.jpg", "rb") as image_file:
    base64_image = base64.b64encode(image_file.read()).decode('utf-8')

content = [
    {
        "type": "text",
        "text": "Describe this image in detail."
    },
    {
        "type": "image_url",
        "image_url": {
            "url": f"data:image/jpeg;base64,{base64_image}"
        }
    }
]

payload["messages"] = [{"role": "user", "content": content}]
# ทำซ้ำคำขอ POST เหมือนข้างต้น

โมเดลจะวิเคราะห์ภาพ โดยให้คำอธิบายเช่น "รถสปอร์ตสีแดงจอดอยู่บนถนนในเมืองยามพลบค่ำ โดยมีคนเดินเท้าเบลอๆ อยู่เบื้องหลัง" ผลลัพธ์ดังกล่าวแสดงให้เห็นถึงการหลอมรวม VL ได้อย่างมีประสิทธิภาพ

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

การใช้งานขั้นสูง: การค้นหาแบบหลายโมดอลด้วย NVIDIA Nemotron Nano 12B v2 VL

การรวมข้อความและรูปภาพจะปลดล็อกศักยภาพสูงสุดของโมเดล คุณสร้างข้อความด้วยอาร์เรย์เนื้อหาที่สลับกัน ซึ่งแต่ละองค์ประกอบจะระบุประเภท ("text" หรือ "image_url") และค่า

ตัวอย่างสำหรับการตอบคำถามด้วยภาพ:

content = [
    {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{base64_chart_image}"}},
    {"type": "text", "text": "What is the trend in sales from Q1 to Q4 in this chart?"}
]

payload["messages"] = [{"role": "user", "content": content}]
response = requests.post(url, headers=headers, json=payload)

API จะส่งคืนการตอบสนองที่มีเหตุผล เช่น "ยอดขายเพิ่มขึ้นอย่างต่อเนื่องจาก 100,000 ดอลลาร์ในไตรมาสที่ 1 เป็น 400,000 ดอลลาร์ในไตรมาสที่ 4 แสดงถึงการเติบโต 300%" ความสามารถนี้มีคุณค่าอย่างยิ่งสำหรับเครื่องมือแสดงข้อมูลหรือระบบรายงานอัตโนมัติ

เพื่อเพิ่มความน่าเชื่อถือ คุณสามารถรวมข้อความแจ้งระบบสำหรับการเล่นบทบาท:

payload["messages"] = [
    {"role": "system", "content": "You are a precise image analyst."},
    {"role": "user", "content": content}
]

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

สำหรับการประมวลผลแบบแบตช์ OpenRouter รองรับการเรียกแบบอะซิงโครนัสผ่าน WebSockets แต่ควรใช้ POST แบบซิงโครนัสเพื่อความเรียบง่ายของ Free Tier ตรวจสอบการใช้งานผ่านแดชบอร์ดเพื่อให้อยู่ในขีดจำกัด — การเกินขีดจำกัดจะทำให้เกิดข้อผิดพลาด 429 ซึ่งคุณจัดการได้ด้วย Exponential Backoff:

import time
try:
    response = requests.post(url, headers=headers, json=payload)
    if response.status_code == 429:
        time.sleep(60)  # รอ 1 นาที
        response = requests.post(url, headers=headers, json=payload)
except Exception as e:
    print(f"Error: {e}")

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

การใช้ประโยชน์จาก Apidog สำหรับการทดสอบและจัดทำเอกสาร NVIDIA API ฟรี

Apidog ยกระดับการโต้ตอบ API ของคุณให้เหนือกว่าสคริปต์ดิบ เครื่องมือโอเพนซอร์สนี้รองรับการนำเข้า OpenAPI specs และ OpenRouter มีให้สำหรับเอนด์พอยต์ Nemotron

ดาวน์โหลด Apidog ได้ฟรี ตามที่กล่าวไว้ก่อนหน้านี้ และทำตามขั้นตอนเหล่านี้:

เปิด Apidog และสร้างโปรเจกต์ใหม่
นำเข้าคอลเลกชัน OpenRouter จากที่เก็บ GitHub ของพวกเขา หรือวาง Schema JSON
เพิ่มคีย์ NVIDIA API ฟรีของคุณภายใต้ตัวแปรสภาพแวดล้อม
ออกแบบคำขอ: การอัปโหลดรูปภาพแบบลากและวางจะแปลงเป็น base64 โดยอัตโนมัติ
เรียกใช้การทดสอบและดูร่องรอย — Apidog จะเน้นจุดที่เกิดความหน่วงสูงหรือข้อผิดพลาดของเพย์โหลด

คุณจัดทำเอกสารเอนด์พอยต์ได้อย่างง่ายดาย โดยสร้างรายงาน Markdown พร้อมตัวอย่าง เช่น ส่งออกคำสั่ง curl สำหรับคำถาม VQA ของคุณ:

curl -X POST https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Content-Type: application/json" \
  -d '{"model":"nvidia/nemotron-nano-12b-v2-vl:free","messages":[{"role":"user","content":[{"type":"image_url","image_url":{"url":"data:image/jpeg;base64,..."},"type":"text","text":"Analyze this."}]}]}'

การส่งออกดังกล่าวช่วยอำนวยความสะดวกในการแบ่งปันกับทีม ยิ่งไปกว่านั้น โหมดการทำงานร่วมกันของ Apidog ยังติดตามการเปลี่ยนแปลง ควบคุมเวอร์ชันการทดลอง NVIDIA Nemotron Nano 12B v2 VL ของคุณ

ในทางปฏิบัติ นักพัฒนารายงานว่ารอบการวนซ้ำเร็วขึ้น 40% ด้วย Apidog เนื่องจากมันช่วยลดโค้ดที่ไม่จำเป็นลง เปลี่ยนไปสู่การผลิตโดยการส่งออกไปยัง Postman หรือรวมโดยตรงผ่าน SDK

การจัดการข้อผิดพลาด แนวทางปฏิบัติที่ดีที่สุด และกลยุทธ์การเพิ่มประสิทธิภาพ

ข้อผิดพลาดเกิดขึ้นในการใช้งาน API ดังนั้นคุณควรคาดการณ์ล่วงหน้า ปัญหาทั่วไป ได้แก่ 401 (คีย์ไม่ถูกต้อง) — ตรวจสอบ Bearer token ของคุณซ้ำ สำหรับ 400 (JSON ผิดรูปแบบ) ให้ตรวจสอบเพย์โหลดด้วยเครื่องมืออย่าง JSONLint ข้อผิดพลาดเฉพาะรูปภาพ เช่น สตริง base64 ที่มีขนาดใหญ่เกินไป สามารถแก้ไขได้โดยการบีบอัดไฟล์ล่วงหน้าโดยใช้ Pillow:

from PIL import Image
img = Image.open("large_image.jpg")
img = img.resize((512, 512))
img.save("resized.jpg", quality=85)

แนวทางปฏิบัติที่ดีที่สุดรวมถึงการจำกัดอัตราการส่งคำขอจากฝั่งคุณด้วย time.sleep(6) ระหว่างการเรียกใช้เพื่อเคารพขีดจำกัด 10 RPM แคชการตอบสนองที่เกิดขึ้นบ่อยโดยใช้ Redis เพื่อลดการเรียกใช้ API

การเพิ่มประสิทธิภาพมุ่งเน้นไปที่ Prompt Engineering ใช้คำถามที่กระชับ: "ระบุวัตถุและความสัมพันธ์ในภาพนี้" ให้ผลลัพธ์ที่ดีกว่าคำถามที่ไม่ชัดเจน ลองใช้ค่า temperature ที่แตกต่างกัน — ต่ำกว่าสำหรับงานที่เน้นข้อเท็จจริง สูงกว่าสำหรับการสร้างสรรค์

สำหรับการปรับขนาดโดยไม่มีค่าใช้จ่ายภายในขีดจำกัด ให้รวมคำถามเชิงตรรกะหลายคำถามเข้าเป็นข้อความเดียว เพื่อเพิ่มประสิทธิภาพการใช้โทเค็นสูงสุด ตรวจสอบการใช้โทเค็นผ่านข้อมูลเมตาของการตอบสนอง: result['usage']['total_tokens']

นอกจากนี้ ให้รวมการบันทึก (logging) ด้วยโมดูล logging เพื่อติดตามประสิทธิภาพ:

import logging
logging.basicConfig(level=logging.INFO)
logging.info(f"Response tokens: {result['usage']['total_tokens']}")

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

บทสรุป

ตอนนี้คุณมีเครื่องมือที่จะใช้ประโยชน์จาก NVIDIA Nemotron Nano 12B v2 VL API ได้ฟรี ตั้งแต่การตั้งค่าเริ่มต้นไปจนถึงการใช้งานขั้นสูง คู่มือนี้จะเตรียมคุณให้พร้อมสำหรับความสำเร็จ ทดลองอย่างกล้าหาญ — เริ่มต้นด้วยการเรียกใช้ง่ายๆ และทำซ้ำไปสู่แอปพลิเคชันที่ซับซ้อน โปรดจำไว้ว่าการปรับเปลี่ยนเล็กๆ น้อยๆ อย่างสม่ำเสมอ เช่น การปรับปรุงพรอมต์หรือการทดสอบโดย Apidog จะนำมาซึ่งผลกำไรมหาศาล

สำหรับการอ่านเพิ่มเติม โปรดสำรวจฟอรัมสำหรับนักพัฒนาของ NVIDIA หรือบันทึกการเปลี่ยนแปลงของ OpenRouter ดาวน์โหลด Apidog วันนี้หากคุณยังไม่ได้ดาวน์โหลด และเปลี่ยนโฉมเวิร์กโฟลว์ API ของคุณ คุณจะเริ่มต้นโปรเจกต์ใดก่อนเป็นอันดับแรก?

ปุ่ม