TH ▾
รับคีย์ API

วิธีใช้ LLM ใน Python ผ่าน API แบบโฮสต์

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

อัปเดต

เทอร์มินัลส่งลำแสงไปยังเซิร์ฟเวอร์คลาวด์และรับข้อมูลแบบคิวบ์ แสดงถึงการเรียกใช้ Python กับ LLM ที่โฮสต์ไว้

ประเด็นสำคัญ

  • ติดตั้งแพ็กเกจ 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 นั่นคือการตั้งค่าทั้งหมด

รับคีย์ API