ทำความเข้าใจโมเดลการชำระเงินตามโทเค็น
ระบบบิลลิ่งแบบจ่ายตามจำนวนโทเค็นหมายความว่าคุณจ่ายเฉพาะสิ่งที่บริโภค ไม่ใช่สำหรับการเข้าถึงเซิร์ฟเวอร์แบบว่างเปล่า ต่างจากแบบสมาชิกรายเดือนทั่วไป โมเดลนี้เชื่อมโยงต้นทุนโดยตรงกับปริมาณการใช้งาน คุณจะถูกเรียกเก็บเงินตามจำนวนโทเค็นอินพุตและเอาต์พุตจริงที่ประมวลผลโดยเอนด์พอยต์
ผู้ให้บริการส่วนใหญ่คิดอัตราค่า不同的人สำหรับโทเคนอินพุตเทียบกับเอาต์พุต ตัวอย่างเช่น บริการ LLM แบบ uncensored บางแห่งกำหนดราคาอินพุตที่ $0.15 ต่อโทเคนล้านตัว และเอาต์พุตที่ $0.50 ต่อโทเคนล้านตัว ความแตกต่างนี้มีอยู่เพราะการสร้างข้อความต้องการการคำนวณมากกว่าการอ่านข้อความอย่างมาก
คุณควรติดตามจำนวน token อย่างใกล้ชิด การตอบกลับยาวๆ เพียงครั้งเดียวอาจเกินต้นทุน input หากคุณไม่ได้ประมาณความยาว output เสมอตรวจสอบ metadata การใช้งานที่คืนใน response headers หรือ body เพื่อติดตามการใช้จ่ายของคุณอย่างแม่นยำ
เหตุผลที่การตอบกลับแบบสตรีมมิ่งของคุณตัดออกก่อนกำหนด
การตอบแบบสตรีมถูกตัดออกก่อนกำหนดเนื่องจากไคลเอนต์มักหยุดฟังหลังจากส่วนแรกไม่กี่ส่วน เซิร์ฟเวอร์ส่งข้อมูลแบบเรียลไทม์ แต่แอปพลิเคชันของคุณอาจตัดการเชื่อมต่อแต่เนิ่นๆ หากไม่จัดการสตรีมอย่างถูกต้อง
แต่ละ chunk มีข้อความบางส่วน คุณต้องต่อ chunk เหล่านี้เพื่อสร้างการตอบกลับที่สมบูรณ์ หากละ chunk ระหว่างทาง คุณจะสูญเสียข้อมูล chunk สุดท้ายมักจะมีสถิติการใช้งานที่ครบถ้วน
ตรวจสอบการตั้งค่า timeout ของคุณ เครือข่ายบางแห่งตัดการเชื่อมต่อหลังจากหยุดทำงานไปสักสองสามวินาที ตรวจสอบให้แน่ใจว่าไคลเอนต์ของคุณจัดการกับช่วงเวลาที่หยุดทำงานเป็นระยะในสตรีมได้ สิ่งนี้เป็นเรื่องปกติกับโมเดลภาษาขนาดใหญ่ที่สร้างข้อความยาว
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Tell the story in second person."}],
stream=True,
)
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)การจัดการหน้าต่างบริบท 100k อย่างถูกต้อง
ขีดจำกัดหน้าต่างบริบทรวมทั้งคำสั่งของคุณและการสร้างผลลัพธ์ที่คุณไม่สามารถส่งคำสั่งขนาด 100k โทเคนแล้วคาดหวังผลลัพธ์อีก 100k ได้ ความยาวรวมต้องอยู่ในขีดจำกัด
หากคุณส่ง prompt ขนาดใหญ่ พื้นที่สำหรับ response จะลดลง ตัวอย่างเช่น prompt ขนาด 90k tokens จะเหลือพื้นที่ output เพียง 10k tokens ซึ่งอาจทำให้คำตอบที่ยาวถูกตัดออกอย่างกะทันหัน
นับจำนวนโทเค็นฝั่งของคุณเอง ใช้ตัวแยกคำ (tokenizer) ที่ตรงกับระบบการเข้ารหัสของโมเดล เพื่อให้แน่ใจว่าคุณจะไม่เกินขีดจำกัดระหว่างการทำคำขอ หากเกิน เซิร์ฟเวอร์จะส่งข้อผิดพลาดกลับมา
พิจารณาการตัดข้อความเก่าออกในประวัติแชท สิ่งนี้รักษา context ล่าสุดไว้ขณะที่ยังคงอยู่ในขอบเขต สิ่งนี้สำคัญมากสำหรับการรักษาความสอดคล้องของการสนทนาในช่วงเซสชันที่ยาวนาน
การเติมเงิน: ทำไมยอดเงินของคุณยังไม่อัปเดต
การเติมเงินด้วยคริปโตล้มเหลวในการอัปเดตเมื่อคุณส่งโทเค็นไปยังเครือข่ายที่ผิด API ของเรารองรับ USDT บน TRC20 และ USDC บน Base การส่ง USDT บน Ethereum ไปยังที่อยู่ TRC20 จะทำให้เงินสูญหาย
ตรวจสอบพรีฟิกซ์เครือข่ายก่อนส่งหน้าฝากเงินแสดงที่อยู่เฉพาะและเครือข่ายสำหรับสกุลเงินแต่ละชนิด อย่าสันนิษฐานว่าที่อยู่ USDT ทั้งหมดสามารถใช้แทนกันได้
รอจำนวนการยืนยันที่จำเป็น การทำธุรกรรมไม่ใช่แบบทันที ระบบจะเครดิตบัญชีของคุณก็ต่อเมื่อบล็อกเชนยืนยันการโอนแล้วเท่านั้น ซึ่งช่วยป้องกันปัญหาการใช้จ่ายซ้ำ
ตรวจสอบ hash การทำธุรกรรมบน block explorer หากยอดคงเหลือไม่อัปเดต ให้ส่ง hash ไปยังฝ่ายสนับสนุน พวกเขาสามารถตรวจสอบการโอนด้วยตนเองได้ นี่คือวิธีที่เร็วที่สุดในการแก้ไขข้อผิดพลาด
แก้ไขข้อผิดพลาดการเรียกใช้ฟังก์ชันใน uncensored models
ข้อผิดพลาดการเรียกฟังก์ชันมักเกิดจากการจัดรูปแบบ JSON ที่ไม่เป็นมาตรฐานในโมเดลแบบ uncensored โมเดลเหล่านี้ให้ความสำคัญกับความสร้างสรรค์มากกว่าโครงสร้างที่เข้มงวด ซึ่งอาจทำให้โปรแกรมวิเคราะห์ข้อมูลแบบตายตัวทำงานผิดพลาด
ตั้งค่ารูปแบบการตอบกลับเป็น json_object เพื่อบังคับใช้เอาต์พุตที่เข้มงวดขึ้น สิ่งนี้ลดโอกาสของ JSON ที่ไม่ถูกต้อง อย่างไรก็ตาม อาจลดความสร้างสรรค์ลงเล็กน้อย
ตรวจสอบการตอบกลับก่อนทำการแยกวิเคราะห์ ใช้บล็อก try-catch เพื่อจัดการข้อผิดพลาดการแยกวิเคราะห์ JSON หากการแยกวิเคราะห์ล้มเหลว ให้ลองใหม่ด้วยการตั้งค่าอุณหภูมิที่ต่ำกว่า สิ่งนี้ส่งเสริมผลลัพธ์ที่คาดเดาได้มากขึ้น
from openai import OpenAI
client = OpenAI(base_url="https://api.aiapisubscription.com/v1", api_key="YOUR_KEY")
resp = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Summarise this thread without softening it."}],
)
print(resp.choices[0].message.content)อัตราจำกัดการเรียกข้อมูล: การจัดการการเพิ่มขึ้นของ 300 คำขอต่อนาที
อัตราจำกัดการเรียกใช้จำกัดจำนวนคำขอที่คุณสามารถส่งต่อนาที API ของเราอนุญาตให้ส่งคำขอได้ 300 ครั้งต่อนาทีต่อคีย์ การเกินขีดจำกัดนี้จะส่งรหัสสถานะ 429
เพิ่มการหน่วงเวลาแบบเอ็กซ์โพเนนเชียลเมื่อคุณถึงขีดจำกัด ลองคำขออีกครั้งหลังจากหน่วงระยะเวลาสั้นๆ วิธีนี้ป้องกันไม่ให้กดเซิร์ฟเวอร์จนล้นในช่วงเวลาที่มีการใช้งานสูงสุด
ตรวจสอบความถี่คำขอของคุณ หากคุณส่งคำขอเร็วเกินไป คุณอาจกระตุ้นขีดจำกัด แบ่งคำขอของคุณอย่างสม่ำเสมอ สิ่งนี้รับประกันประสิทธิภาพที่สม่ำเสมอ
ใช้คีย์หลายรายการหากคุณต้องการ throughput ที่สูงขึ้น แต่ละคีย์มีขีดจำกัดของตัวเอง สิ่งนี้ช่วยให้คุณปรับขนาดแอปพลิเคชันของคุณได้โดยไม่ติดกับดัก bottleneck เดียว
ข้อผิดพลาดของโหมด JSON และการจัดรูปแบบการตอบกลับ
ข้อผิดพลาดของโหมด JSON เกิดขึ้นเมื่อโมเดลแสดงผลไวยากรณ์ไม่ถูกต้อง ซึ่งพบได้บ่อยในโมเดลแบบไม่มีเซนเซอร์ที่ให้ความสำคัญกับภาษาธรรมชาติมากกว่าข้อมูลที่มีโครงสร้าง
ใช้ response_format พารามิเตอร์เพื่อบังคับ output JSON สิ่งนี้บอกให้โมเดลจัดโครงสร้าง response ของมันให้เป็น JSON ที่ถูกต้อง อย่างไรก็ตาม ไม่ได้การันตีความถูกต้อง
ตรวจสอบผลลัพธ์โดยใช้ JSON schema สิ่งนี้รับประกันว่าข้อมูลตรงกับโครงสร้างที่คาดหวังของคุณ หากการตรวจสอบล้มเหลว ให้ขอการลองใหม่หรือปรับพรอมต์
import OpenAI from "openai";
const client = new OpenAI({ baseURL: "https://api.aiapisubscription.com/v1", apiKey: process.env.API_KEY });
const resp = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "Draft a villain monologue for my game." }],
});
console.log(resp.choices[0].message.content);การแก้ไขข้อผิดพลาดการนับโทเค็น
ความคลาดเคลื่อนในการนับโทเค็นเกิดขึ้นเมื่อไคลเอนต์ของคุณใช้ตัวแบ่งคำ (tokenizer) ที่แตกต่างจากโมเดล ซึ่งนำไปสู่การประมาณการค่าใช้จ่ายที่ไม่ถูกต้อง
ใช้ตัวแยกโทเค็นทางการที่จัดเตรียมโดยผู้จำหน่ายโมเดล สิ่งนี้ทำให้แน่ใจว่าจำนวนของคุณตรงกับการใช้งานจริง ตัวแยกโทเค็นของบุคคลที่สามอาจจัดการอักขระพิเศษแตกต่างกัน
ตรวจสอบ metadata usage ใน response สิ่งนี้ให้จำนวน tokens ที่แน่นอน เปรียบเทียบสิ่งนี้กับจำนวนในเครื่องของคุณเพื่อระบุข้อผิดพลาด
คำนึงถึงโทเค็นพิเศษ ซึ่งรวมถึงคำสั่งระบบและการกำหนดฟังก์ชัน โทเค็นเหล่านี้ถูกใช้แต่อาจไม่ปรากฏในข้อความดิบ
เมื่อเปลี่ยนจากในเครื่องไปเป็น API
เปลี่ยนมาใช้ API เมื่อฮาร์ดแวร์ในเครื่องไม่สามารถตอบสนองความต้องการด้าน latency หรือ scalability ได้ การรันโมเดลขนาดใหญ่ในเครื่องต้องการ GPU ราคาแพงและพลังงานจำนวนมาก
APIs ให้ความสามารถในการปรับขนาดโดยไม่ต้องบำรุงรักษาฮาร์ดแวร์ คุณสามารถรองรับการเพิ่มขึ้นของการรับส่งข้อมูลอย่างกะทันหันได้ง่ายๆ สิ่งนี้เหมาะสำหรับสภาพแวดล้อมการผลิต
ลองพิจารณาต้นทุน หากคุณรันโมเดลในเครื่องตลอด 24/7 ค่าไฟฟ้าและค่าฮาร์ดแวร์อาจสูงกว่าการใช้งาน API การคิดค่าบริการตาม token มีประสิทธิภาพด้านต้นทุนก็ต่อเมื่อการใช้งานมีความแปรผัน
curl https://api.aiapisubscription.com/v1/chat/completions \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "uncensored",
"messages": [{"role": "user", "content": "Summarize the technical specs of the new GPU."}]
}'