วิธีใช้ LLM ใน Python ผ่าน API แบบโฮสต์
สำหรับโปรเจกต์ส่วนใหญ่ การใช้งาน LLM ใน Python คือการเรียกใช้โมเดลที่โฮสต์ไว้ผ่าน HTTP ไม่ใช่การเทรนหรือให้บริการโมเดลเอง ด้วย API ที่เข้ากันได้กับ OpenAI ใช้เพียงประมาณสิบบรรทัด และโค้ดเดียวกันนี้สามารถขยายไปสู่การสตรีมมิง, JSON mode และการเรียกใช้ฟังก์ชันได้
อัปเดต

ประเด็นสำคัญ
- ติดตั้งแพ็กเกจ openai ตั้งค่า base URL และคีย์ แล้วใช้โมเดล ID uncensored
- รองรับสตรีมมิง โหมด JSON และการเรียกใช้ฟังก์ชันผ่านอาร์กิวเมนต์ SDK มาตรฐาน
- เก็บประวัติแชทในลิสต์และระวังหน้าต่างบริบท 100,000 โทเคน
- จัดการ HTTP 429 ด้วยการลองใหม่แบบสั้น; คำขอที่ล้มเหลวหรือถูกปฏิเสธจะไม่ถูกเรียกเก็บเงิน
API ที่โฮสต์ไว้หรือโมเดลของคุณเอง
มีสองวิธีในการนำโมเดลภาษาไปใช้ในโปรแกรม Python คุณสามารถรันน้ำหนักโมเดลเอง ซึ่งหมายถึงการใช้ GPU, ชุดการให้บริการ, การเลือกการควอนไทเซชัน และการรอโหลดข้อมูลนาน หรือคุณสามารถส่งคำขอไปยังโมเดลที่ผู้อื่นรันไว้แล้ว วิธีแรกมีเหตุผลสำหรับการวิจัย, การแยกข้อมูลอย่างเข้มงวด หรือปริมาณงานสูงต่อเนื่อง วิธีที่สองเหมาะกับงานเกือบทุกอย่าง: สคริปต์, บอท, ฟีเจอร์ผลิตภัณฑ์ หรือโปรโตไทป์ที่คุณต้องการให้ทำงานเสร็จก่อนเวลาอาหารกลางวัน
คู่มือนี้ใช้วิธีที่สอง บริการที่นี่คือ API ข้อความที่เข้ากันได้กับ OpenAI แบบโฮสต์ มีโมเดลแบบเปิดน้ำหนักหนึ่งโมเดล โดยผู้ให้บริการอิสระและปรับแต่งให้ตอบโดยไม่มีการปฏิเสธเนื้อหาสำหรับการใช้งานผู้ใหญ่ที่ถูกต้องตามกฎหมาย ไม่ใช่ API ทางการของผู้จัดจำหน่ายโมเดลใดๆ เนื่องจากใช้รูปแบบคำขอของ OpenAI แพ็คเกจ openai มาตรฐานจึงใช้งานได้ และหากต้องการไม่ต้องพึ่งพาไลบรารีอื่นก็สามารถใช้ requests ธรรมดาได้
ขั้นตอนที่ 1: ติดตั้งและทำการเรียกครั้งแรก, สตรีมมิง, ประวัติแชท, โหมด JSON, การเรียกใช้เครื่องมือ, การลองใหม่ และการคำนวณต้นทุน
ติดตั้ง SDK และเก็บคีย์ของคุณในตัวแปรสภาพแวดล้อม เพื่อไม่ให้คีย์ปรากฏในซอร์สโค้ดของคุณ
pip install openai
export API_KEY="your-key-here"
จากนั้นสร้างไคลเอนต์ด้วย Base URL ของบริการ สิ่งเดียวที่คุณต้องเปลี่ยนเมื่อเทียบกับการตั้งค่าสไตล์ OpenAI อื่นๆ คือ URL คีย์ และชื่อโมเดล
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.fluxapikey.com/v1",
api_key=os.environ["API_KEY"],
)
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "Explain list comprehensions in two sentences."},
],
)
print(resp.choices[0].message.content)
print(resp.usage)
นี่คือโปรแกรมที่ทำงานได้สมบูรณ์ เอนด์พอยต์เบื้องหลังคือ POST /v1/chat/completions ซึ่งตรวจสอบสิทธิ์ด้วย Authorization: Bearer <key> และ GET /v1/models แสดงรายการโมเดล ID คุณสามารถรับคีย์และเครดิตทดลองใช้เล็กน้อยได้ที่ หน้าคีย์
ขั้นตอนที่ 2: สตรีมคำตอบ
การรอหลายวินาทีเพื่อรับคำตอบเต็มรูปแบบรู้สึกช้าในเทอร์มินัลหรือหน้าเว็บ ตั้งค่า stream=True และพิมพ์โทเคนเมื่อข้อมูลมาถึงผ่าน server-sent events
# client from step 1: base_url https://api.fluxapikey.com/v1
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a short story opening about a lighthouse keeper."}],
stream=True,
)
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
print()
ตัวเลขการใช้งานมาตอนท้ายสตรีม ทำให้ chunk สุดท้ายอาจไม่มี choices ดังนั้นจึงต้องตรวจสอบ chunk.choices ก่อน สิ่งที่ต้องจำ: คำขอแบบสตรีมจะคง slot การทำงานพร้อมกันไว้จนกว่าสตรีมจะจบ ดังนั้นต้องอ่านจนจบหรือปิด
ขั้นตอนที่ 3: รักษาการสนทนา
โมเดลไม่มีหน่วยความจำระหว่างการเรียกใช้งาน การสนทนาจึงเป็นเพียงรายการข้อความที่เติบโตขึ้นซึ่งคุณส่งใหม่ทุกครั้ง คลาสขนาดเล็กก็เพียงพอแล้ว:
# client from step 1: base_url https://api.fluxapikey.com/v1
class Chat:
def __init__(self, system):
self.messages = [{"role": "system", "content": system}]
def say(self, text):
self.messages.append({"role": "user", "content": text})
r = client.chat.completions.create(model="uncensored", messages=self.messages)
answer = r.choices[0].message.content
self.messages.append({"role": "assistant", "content": answer})
return answer
bot = Chat("You are a patient Python tutor.")
print(bot.say("What is a generator?"))
print(bot.say("Show me one with yield."))
หน้าต่างบริบทมีขนาด 100,000 โทเคน ซึ่งแบ่งใช้ระหว่างพรอมต์และการสร้างข้อความ พื้นที่นี้กว้างขวาง แต่การสนทนาที่ยาวนานจะเติบโตขึ้นในทุกๆ รอบการสนทนา และคุณต้องจ่ายสำหรับประวัติทั้งหมดในทุกคำขอ เมื่อประวัติมีขนาดใหญ่ขึ้น ให้ตัดรอบการสนทนาที่เก่าที่สุดออกหรือแทนที่ด้วยสรุปสั้นๆ ที่คุณให้โมเดลเขียน
ขั้นตอนที่ 4: รับข้อมูลที่มีโครงสร้าง
โปรแกรมต้องการข้อมูล ไม่ใช่ย่อหน้า โหมด JSON ทำให้คำตอบเป็น JSON ที่ถูกต้อง ระบุในพรอมต์ว่าคุณคาดหวังคีย์ใด
# client from step 1: base_url https://api.fluxapikey.com/v1
import json
r = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": 'Return JSON like {"title": str, "tags": [str]}.'},
{"role": "user", "content": "Summarise: a tutorial on async IO in Python."},
],
)
data = json.loads(r.choices[0].message.content)
print(data["title"], data["tags"])
JSON ที่ถูกต้องไม่รับประกันคีย์ของคุณ ตรวจสอบคีย์ในโค้ดและลองใหม่หนึ่งครั้งหากคีย์หายไป
ขั้นตอนที่ 5: ให้โมเดลเรียกใช้ฟังก์ชันของคุณ
การเรียกใช้เครื่องมือช่วยให้โมเดลขอให้โปรแกรมของคุณรันฟังก์ชัน จากนั้นดำเนินการต่อด้วยผลลัพธ์ คุณอธิบายเครื่องมือ ตรวจสอบว่าคำตอบมีการเรียกใช้งาน รันฟังก์ชันและส่งผลลัพธ์กลับด้วย role tool
# client from step 1: base_url https://api.fluxapikey.com/v1
import json
tools = [{
"type": "function",
"function": {
"name": "get_word_count",
"description": "Count the words in a text.",
"parameters": {
"type": "object",
"properties": {"text": {"type": "string"}},
"required": ["text"],
},
},
}]
messages = [{"role": "user", "content": "How many words are in: the quick brown fox?"}]
r = client.chat.completions.create(model="uncensored", messages=messages, tools=tools, tool_choice="auto")
msg = r.choices[0].message
if msg.tool_calls:
messages.append(msg)
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
result = len(args["text"].split())
messages.append({"role": "tool", "tool_call_id": call.id, "content": str(result)})
final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)
ตรวจสอบอาร์กิวเมนต์ทุกครั้งก่อนดำเนินการ เพราะโมเดลสามารถสร้างการเรียกใช้งานที่คุณไม่คาดคิดได้ การเรียกใช้เครื่องมือก็สตรีมได้เช่นกัน โดยเป็น delta ของ tool_calls หากต้องการดูรายละเอียดเพิ่มเติม เอกสารประกอบระบุทุกฟิลด์
ขั้นตอนที่ 6: จัดการขีดจำกัดอัตราและข้อผิดพลาด
คีย์แบบเต็มอนุญาตให้ส่งคำขอพร้อมกันได้ 8 คำขอและ 300 คำขอต่อนาที; คีย์ทดลองใช้อนุญาตให้ส่งคำขอพร้อมกันได้ 2 คำขอและ 60 คำขอต่อนาที หากเกินขีดจำกัด API จะตอบกลับด้วย HTTP 429 รหัสข้อผิดพลาดคือ rate_limited สำหรับคำขอเกินต่อนาที และ concurrency สำหรับคำขอพร้อมกันเกินจำนวนที่กำหนด เมื่อเกิดโอเวอร์โหลดชั่วคราวคุณยังได้รับ 429 พร้อม header Retry-After: 5 ตัวห่อการเรียกใหม่แบบง่ายๆ ครอบคลุมทั้งสามกรณีนี้:
# client from step 1: base_url https://api.fluxapikey.com/v1
import time
from openai import RateLimitError
def ask(messages, tries=4):
for i in range(tries):
try:
return client.chat.completions.create(model="uncensored", messages=messages)
except RateLimitError:
time.sleep(5 * (i + 1))
raise RuntimeError("still limited after retries")
หากคุณรันงานในเธรด ให้จำกัดจำนวนไว้ที่ 8 ด้วย ThreadPoolExecutor(max_workers=8) เพื่อไม่ให้ชนขีดจำกัดคำขอพร้อมกันบ่อยนัก แต่ละการตอบกลับมี X-Request-Id ซึ่งเป็นสิ่งที่ควรอ้างถึงเมื่อติดต่อ ฝ่ายสนับสนุน และ X-Balance-USD แสดงเครดิตคงเหลือของคุณ ขนาดสูงสุดของ body คือ 8 MB
การตั้งค่าที่เปลี่ยนผลลัพธ์
การปรับแต่งการใช้งานประจำวันส่วนใหญ่เกิดขึ้นที่พารามิเตอร์ไม่กี่ตัว ซึ่งส่งต่อไปยังโมเดลทั้งหมด
temperatureควบคุมความสุ่ม ใช้ 0.2 หรือน้อยกว่าสำหรับการสกัดข้อมูลและการจัดประเภท ใช้ประมาณ 0.7 สำหรับการแชท และ 1.0 หรือมากกว่าสำหรับการระดมสมองและงานเขียนนิยายtop_pตัดตัวเลือกคำที่มีความน่าจะเป็นต่ำออก เปลี่ยนค่านี้หรือ temperature อย่างใดอย่างหนึ่ง อย่าเปลี่ยนทั้งคู่พร้อมกัน เพื่อให้ทราบได้ว่าค่าใดเป็นสาเหตุseedทำให้การรันซ้ำเปรียบเทียบกันได้ง่ายขึ้น มีประโยชน์ในการทดสอบที่คุณต้องการเห็นผลกระทบจากการเปลี่ยนแปลงพรอมต์ ไม่ใช่สัญญาณรบกวนstopจบการสร้างที่สตริงที่คุณเลือก ซึ่งสะดวกสำหรับการตัดโมเดลที่เพิ่มคอมเมนต์ต่อไปเรื่อยๆmax_tokensเป็นตัวเลือก หากไม่มีค่านี้ การสร้างผลลัพธ์อาจใช้พื้นที่ที่เหลือของหน้าต่าง 100,000 โทเคน ตั้งค่าเมื่อคุณต้องการจำกัดความยาวและต้นทุนอย่างชัดเจน- ค่าปรับความถี่ (frequency) และค่าปรับการปรากฏซ้ำ (presence) ช่วยลดการทำซ้ำ ซึ่งช่วยกับงานเขียนเชิงสร้างสรรค์ที่ยาวและเริ่มมีการวนซ้ำ
บันทึกการตั้งค่าที่คุณใช้ไว้ข้างเคียงกับผลลัพธ์ที่คุณสนใจ หลังจากผ่านไปหลายเดือน คำถามว่า "ทำไมมันตอบต่างกัน" มักเกิดจากการเปลี่ยนพารามิเตอร์หรือข้อความระบบ
การส่งคำขอจำนวนมากพร้อมกัน
ลูปที่ส่งคำขอทีละคำขอทำให้โควตาของคุณส่วนใหญ่ไปอย่างเปล่าประโยชน์ ด้วยคีย์เต็มคุณสามารถมีคำขอได้ 8 คำขอพร้อมกัน ดังนั้นการใช้ thread pool จะลดเวลาการทำงานแบบแบตช์ลงเหลือประมาณหนึ่งในแปดของเวลาจริง
from concurrent.futures import ThreadPoolExecutor
from openai import OpenAI
client = OpenAI(base_url="https://api.fluxapikey.com/v1", api_key="YOUR_KEY")
def summarise(text):
r = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Summarise in one line: " + text}],
max_tokens=60,
)
return r.choices[0].message.content
texts = ["first document", "second document", "third document"]
with ThreadPoolExecutor(max_workers=8) as pool:
for line in pool.map(summarise, texts):
print(line)
รักษาจำนวน worker ไว้ที่ 8 หรือน้อยกว่า หรือที่ 2 บนคีย์ทดลอง หากคุณยังเห็นการตอบกลับ 429 ด้วยโค้ด concurrency ให้ลดจำนวนลงหนึ่งหรือสองตัว ขีดจำกัด 300 ต่อนาทีมีความสำคัญสำหรับคำขอที่เร็วและสั้น ดังนั้นแบตช์ของคำขอขนาดเล็กอาจชนขีดจำกัดนี้ก่อนขีดจำกัดการทำงานพร้อมกัน
ปัญหาที่พบบ่อยและการแก้ไข
ข้อผิดพลาดส่วนใหญ่ในวันแรกมาจากสาเหตุไม่กี่อย่าง
- 401 หรือข้อผิดพลาดการตรวจสอบสิทธิ์ คีย์หายไป พิมพ์ผิด หรือส่งไปยังโฮสต์ผิด พิมพ์ base URL ที่ไคลเอนต์ของคุณใช้จริงและตรวจสอบให้แน่ใจว่าลงท้ายด้วย
/v1 - ไม่พบโมเดล โมเดล ID ต้องเป็น
uncensoredเรียกใช้GET /v1/modelsหากต้องการยืนยันว่าเซิร์ฟเวอร์แสดงรายการโมเดลใด - การตอบกลับว่างหรือถูกตัด ค่า
max_tokensต่ำเกินไปทำให้คำตอบหยุดกลางประโยค เพิ่มค่านี้หรือลบออก ตรวจสอบfinish_reasonในตัวเลือก:lengthหมายถึงถึงขีดจำกัดแล้ว - JSON ที่ parse ไม่ได้ อาจเป็นเพราะการตอบถูกตัดออก หรือพรอมต์ไม่ได้ระบุโครงสร้าง แก้ไขพรอมต์ก่อนแล้วห่อการ parse ด้วย try block
- โทเคนแรกช้า พรอมต์ที่ยาวมากใช้เวลานานในการประมวลผล ตัดประวัติหรือส่งบริบทให้น้อยลง
- คำขอใหญ่เกินไป ขอบเขตของ body คือ 8 MB และหน้าต่างโทเคนคือ 100,000 แยกเอกสารขนาดใหญ่เป็นชิ้นส่วนและสรุปแต่ละชิ้น
เมื่อมีบางอย่างยังดูผิดปกติ ให้บันทึกส่วนหัว X-Request-Id พร้อมอินพุตที่ล้มเหลว มันทำให้ ฝ่ายสนับสนุน สามารถหาคำขอที่แน่นอนได้
ต้นทุน
คุณจ่าย $0.15 ต่อ 1M input tokens และ $0.50 ต่อ 1M output tokens จากเครดิตแบบเติมเงินล่วงหน้า การเรียกใช้งานทั่วไปที่มี 2,000 tokens เข้าและ 500 tokens ออก มีค่าใช้จ่าย 0.002 x $0.15 = $0.0003 สำหรับ input บวก 0.0005 x $0.50 = $0.00025 สำหรับ output รวมเป็น $0.00055 การเรียกใช้งาน 10,000 แบบนี้มีค่าใช้จ่าย $5.50 คำขอที่ล้มเหลวหรือถูกปฏิเสธจะไม่คิดเงิน และเครดิตจะไม่หมดอายุ การเติมเงินเริ่มต้นที่ $20 ถึง $500; ดู ราคา สำหรับระดับโบนัส พรอมต์ไม่ถูกใช้ในการเทรน
output tokens มีต้นทุนสูงกว่า input tokens ดังนั้นนิสัยที่ประหยัดที่สุดคือการขอคำตอบสั้นๆ: บอกสองประโยค หรือ JSON เท่านั้น และตั้งค่า max_tokens เป็นเพดานที่เหมาะสม อ่าน resp.usage ระหว่างการพัฒนาเพื่อดูจำนวนโทเคนจริงสำหรับพรอมต์ของคุณ และคูณด้วยอัตราข้างต้นก่อนที่คุณจะขยายงานขนาดใหญ่ header X-Balance-USD แสดงยอดคงเหลือหลังจากแต่ละการเรียก
คู่มือเพิ่มเติม
ถาม-ตอบ
ฉันต้องการ GPU เพื่อใช้งาน LLM ใน Python หรือไม่?
ไม่ต้องใช้ API แบบโฮสต์ โค้ด Python ของคุณส่งเพียง HTTP requests ดังนั้นแล็ปท็อปเครื่องใดก็ได้ก็ใช้งานได้
ฉันสามารถใช้ แพ็กเกจ openai ทางการได้หรือไม่?
ได้ ตั้ง base_url เป็น URL ของบริการ และ api_key เป็นคีย์ของคุณ และใช้โมเดล ID uncensored
รองรับโค้ดแบบ async หรือไม่
ไคลเอนต์ AsyncOpenAI ของ SDK ทำงานกับ Base URL และคีย์เดียวกันได้ รักษาจำนวนคำขอพร้อมกันไว้ที่ 8 คำขอหรือน้อยกว่า
จะลองใช้โดยไม่ต้องจ่ายเงินได้อย่างไร
สมัครสมาชิกและรับเครดิตทดลองใช้ $0.50 บนหน้าคีย์ มันใช้ได้เป็นเวลา 7 วัน และไม่จำเป็นต้องใช้บัตร
คีย์ของคุณอยู่ห่างแค่แบบฟอร์มเดียว
สร้างบัญชี คัดลอกคีย์ และเปลี่ยน base URL นั่นคือการตั้งค่าทั้งหมด