OpenAI GPT-OSS: Cara Menjalankannya Secara Tempatan atau hos sendiri pada Awan, Keperluan Perkakasan

GPT-OSS direka bentuk dengan baik untuk kebolehaksesan: the gpt-oss-20B varian direka untuk dijalankan pada GPU pengguna tunggal (~16 GB VRAM) atau komputer riba mewah terkini menggunakan binaan GGUF terkuantiti, manakala gpt-oss-120B—walaupun jumlah parameternya 117B—disampaikan dengan muslihat MoE/parameter aktif dan kuantiti MXFP4 yang membolehkannya dijalankan pada GPU kelas H100 tunggal (≈80 GB) atau pada persediaan berbilang GPU. Menggunakan model gaya GPT sumber terbuka (sering dipanggil "GPT OSS") — sama ada model 6–7B padat untuk apl tempatan atau model 70B+ untuk perkhidmatan pengeluaran — menimbulkan persoalan teras yang sama: Cara Menjalankan GPT-OSS Secara Tempatan atau hos sendiri pada Awan, Keperluan Perkakasan

Apakah model GPT-OSS dan apakah keperluan perkakasan mereka?

Apakah GPT-OSS?

GPT-OSS ialah keluarga model bahasa besar OpenAI yang dikeluarkan baru-baru ini (dua varian tajuk pada masa keluaran: ~20B dan ~120B versi parameter). Mereka dihantar dengan pilihan yang dioptimumkan (campuran pakar, pengkuantitian asli MXFP4 dalam pengedaran OpenAI, inovasi yang jarang/padat) yang membolehkan kiraan parameter yang agak besar ini dijalankan pada memori yang jauh lebih sedikit daripada salinan FP32/FP16 naif yang diperlukan. Keluaran ini secara eksplisit bertujuan untuk menjadikan model berkuasa lebih boleh dijalankan secara meluas dan disesuaikan di luar hanya hyperscalers.

Fakta produk utama (menanggung beban):

gpt-oss-20B bertujuan untuk dijalankan pada GPU pengguna tunggal dengan ~16 GB VRAM (dan boleh digunakan pada desktop/komputer riba dengan pengkuantitian GGUF).
gpt-oss-120B (≈117B parameter, ~5.1B aktif parameter dalam reka bentuk MoE OpenAI) direka bentuk supaya model boleh dimuatkan dalam satu 80 GB H100 / A100 apabila menggunakan MXFP4 dan sokongan masa jalan tertentu, atau pada persediaan berbilang GPU.

Faktor perkakasan yang menentukan keperluan

Saiz model dan seni bina – MoE dan lapisan jarang/padat boleh menukar pengaktifan dan memori kerja. (GPT-OSS menggunakan komponen gaya campuran pakar.)
Ketepatan & kuantisasi – FP32, FP16, BF16, 8-bit, 4-bit (GPTQ/AWQ/MXFP4). Ketepatan yang lebih rendah mengurangkan ingatan tetapi boleh menjejaskan kependaman dan kesetiaan berangka. OpenAI menyediakan pemberat terkuantiti MXFP4 untuk GPT-OSS.
Panjang konteks (panjang jujukan) – konteks yang lebih panjang meningkatkan penggunaan cache pengaktifan secara berkadar; GPT-OSS menyokong konteks yang sangat panjang (sehingga tetingkap token yang sangat besar dalam reka bentuk mereka), yang melipatgandakan keperluan memori.
Saiz batch & konkurensi – melayani berbilang pengguna serentak menggandakan memori untuk pengaktifan dan cache. Rangka kerja seperti vLLM, DeepSpeed dan Triton cuba mengumpul dan berkongsi pengaktifan dengan cekap merentas permintaan.
Overhed rangka kerja – pelayan inferens berbeza (vLLM, text-generation-inference, llama.cpp, ONNX Runtime) menambah overhed dan pengoptimuman yang berbeza.

Apa yang "sesuai" di mana: peraturan memori kasar

Dua konsep penting untuk perancangan perkakasan:

Jumlah kiraan parameter — sempadan atas pada saiz model (117B lwn 21B).
Set diaktifkan/berfungsi — dalam MoE atau tetapan ketepatan tertentu memori aktif yang diperlukan pada inferens boleh menjadi jauh lebih kecil daripada bait parameter mentah.

Peraturan praktikal:

GPU kelas 16 GB/komputer riba edge → mungkin untuk gpt-oss-20b jika anda menggunakan konfigurasi cekap memori yang disediakan model (atau kuantiti secara agresif kepada 4-bit/NF4/AWQ).
80 GB H100 / A100 80GB → pengehosan GPU tunggal untuk gpt-oss-120b dalam persediaan yang disyorkan mereka. Untuk pengeluaran pengeluaran, anda mungkin masih mahukan berbilang GPU untuk kumpulan, redundansi atau kependaman yang lebih rendah di bawah konkurensi.
Persediaan berbilang GPU yang besar (kelompok A100/H100) → diperlukan jika anda ingin menjalankan banyak pengguna serentak pada kependaman rendah atau melakukan penalaan halus/latihan yang berat. DeepSpeed/ZeRO dan selari tensor automatik membolehkan anda membahagikan model besar merentas GPU.

Pengambilan ringkas: untuk percubaan dan penggunaan tempatan yang ringan, rancang pada GPU 16–24 GB (atau CPU + pengkuantitian berat). Untuk pengeluaran inferens GPU tunggal bagi model gpt-oss besar, anda akan menyasarkan 80 GB H100, jika tidak gunakan pembahagian berbilang GPU.

Berapakah kuasa pengkomputeran yang diperlukan untuk penggunaan GPT-OSS dalam amalan?

Inferens vs latihan: belanjawan yang sangat berbeza

Inferensi: kos yang mendominasi ialah memori GPU (VRAM) dan kernel yang dioptimumkan. Dengan masa jalan yang dioptimumkan (vLLM, TensorRT, DeepSpeed-Inference) dan pengkuantitian, inferens pada gpt-oss-20b boleh dilaksanakan pada GPU pengguna 16 GB; model 120B MoE direka bentuk agar sesuai dengan 80 GB H100.
Latihan penalaan halus / skala penuh: susunan magnitud yang lebih besar — anda memerlukan banyak GPU, atau contoh latihan khusus (kluster H100/A100 berbilang nod, belanjawan DFLOP dan I/O storan). Artikel ini memberi tumpuan terutamanya pada inferens/penghosan sendiri dan resipi penalaan halus (QLoRA / LoRA), bukan pralatihan berbilang minggu.

CPU lwn GPU lwn pemecut khusus

CPU sahaja: mungkin dengan GGUF/llama.cpp dan binaan terkuantiti kecil, kependaman dagangan untuk kos yang lebih rendah. Menjalankan 20B pada CPU tanpa pengkuantitian adalah tidak praktikal. Gunakan CPU apabila privasi atau operasi luar talian setempat adalah penting dan keperluan daya pengeluaran anda adalah rendah.
GPU: diutamakan untuk kependaman dan pemprosesan. GPU ML moden (A100/H100/4090/4080) berbeza secara meluas mengikut HBM/VRAM dan fabrik antara GPU. Dokumen gpt-oss mengesyorkan kelas H100 untuk varian 120B.
TPU / AMD MI300X: disokong oleh beberapa runtimes (vLLM/ROCm binaan) dan boleh menjimatkan kos dalam awan tertentu — semak dokumen pembekal apabila memilih perkakasan.

Bagaimana untuk menjalankan GPT-OSS secara tempatan pada belanjawan terhad? (kod + langkah demi langkah)

Di bawah adalah dua pendekatan praktikal: (A) Komputer riba/desktop GPU dengan ~16–24 GB VRAM menggunakan kuantiti 4-bit, dan (B) CPU/GPU rendah (luar talian) menggunakan llama.cpp (GGUF) atau binaan terkuantisasi kecil. Kedua-duanya digunakan secara meluas oleh pengamal apabila wang dan kuasa terhad.

Nota: arahan ini menganggap anda mempunyai persekitaran Python yang berfungsi (Linux disyorkan untuk sokongan CUDA terbaik). Untuk Windows, gunakan WSL2 untuk keserasian terbaik dengan rantai alat GPU.

A. Laluan GPU (disyorkan untuk kependaman terbaik pada belanjawan) — kuantiti + muat dengan bitsandbait (4-bit)

Laluan ini bertujuan untuk berlari openai/gpt-oss-20b pada GPU pengguna tunggal (cth, 24 GB 4090 atau 16 GB 4080). Ia menggunakan kuantiti 4-bit bitsandbytes dan Muka Memeluk transformers peta peranti/percepatan.

Langkah 1 — Pasang asas

# Linux + CUDA (example); pick the correct torch CUDA wheel for your driver

python -m pip install -U pip
pip install torch --index-url https://download.pytorch.org/whl/cu121  # pick your CUDA version

pip install -U transformers accelerate bitsandbytes safetensors

(Jika anda menggunakan conda, buat env dan pasang roda obor yang serasi dengan CUDA untuk platform anda.)

Langkah 2 — (Pilihan) Log masuk Memeluk Wajah untuk memuat turun fail besar

huggingface-cli login

Langkah 3 — Contoh Python (muat model 4-bit terkuantiti)

# save as run_gptoss_4bit.py

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig

model_id = "openai/gpt-oss-20b"

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4"   # or "fp4"/"nf4" depending on support

)

tokenizer = AutoTokenizer.from_pretrained(model_id, use_fast=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    device_map="auto",                 # let transformers pick GPU + CPU offload if needed

    quantization_config=bnb_config,
    torch_dtype=torch.float16,
    trust_remote_code=True
)

prompt = "Write a concise summary of quantization for LLMs."
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
out = model.generate(**inputs, max_new_tokens=200)
print(tokenizer.decode(out, skip_special_tokens=True))

Nota & petua

Penggunaan device_map="auto" so transformers menggunakan CPU/GPU offload secara automatik. Jika anda mempunyai satu GPU, device_map="auto" biasanya akan meletakkan segala-galanya pada GPU dan memunggah apa yang mesti ada pada CPU.
Jika anda kehabisan VRAM, tambah --offload_folder ./offload (atau set offload_folder in from_pretrained) untuk memunggah tensor ke NVMe.
Pendekatan Memeluk Wajah + bitsandbytes didokumenkan secara meluas; lihat panduan transformer 4-bit untuk butiran.

B. CPU / laluan belanjawan kecil (llama.cpp / GGUF)

Jika anda tidak mempunyai GPU atau GPU yang sangat kecil, llama.cpp Binaan / GGUF (dan fail terkuantiti AWQ/GPTQ) membolehkan anda menjalankan model pada CPU dengan kependaman yang boleh diterima untuk pengguna tunggal.

Langkah 1 — Pasang llama.cpp / pengikatan Python

# Download and build (Linux)

git clone --recursive https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
make
# Python bindings (optional)

pip install llama-cpp-python

Langkah 2 — Tukar safetensors → GGUF (jika skrip penukaran tersedia untuk gpt-oss)
OpenAI/Hugging Face menyediakan pelindung; penukar komuniti (atau skrip dalam llama.cpp) tukar kepada GGUF. Perintah yang tepat bergantung pada semasa llama.cpp alat; semak repo README untuk convert.py/convert-safetensors-to-gguf. (Urut komuniti membincangkan penukaran untuk model baharu.)

Langkah 3 — Jalankan model dengan llama.cpp

# basic inference (example)

./main -m ./gpt-oss-20b.gguf -p "Explain GGUF and quantization in one paragraph." -n 256

Nota & tukar ganti

Proses CPU jauh lebih perlahan. Gunakan laluan ini untuk ujian, privasi atau ejen tempatan yang berkonkurensi sangat rendah.
Menjana output yang panjang atau melayani ramai pengguna serentak pada CPU adalah tidak praktikal; beralih ke GPU untuk pengeluaran.

Binaan terkuantisasi pada cakera (GPTQ/AWQ)

Jika anda perlu memasukkan model besar ke dalam GPU kecil (cth, 8–12 GB), hasil daripada komuniti menunjukkan kuantiti gaya GPTQ/AWQ boleh menjadikan beberapa model 20B dijalankan pada GPU VRAM rendah — tetapi penukaran sering memerlukan lebih RAM CPU dan satu GPU perantaraan semasa penukaran. Alatan: GPTQ-for-LLaMa, AutoGPTQ (diarkibkan), AWQ, dan QLLM.

Petua praktikal untuk bajet terhad

Lebih suka pusat pemeriksaan terkuantisasi 4-bit (GPTQ/AWQ/MXFP4) — selalunya perbezaan antara "berjalan dalam 12 GB" dan "memerlukan 80 GB".
Hadkan panjang konteks untuk inferens belanjawan: konteks panjang meletupkan cache pengaktifan. Jika anda mesti menyimpan konteks yang panjang, pertimbangkan strategi pemuatan.
Gunakan memori bersatu / nvmem offload dengan berhati-hati — rangka kerja mungkin menawarkan pemuatan CPU/NVMe (DeepSpeed ZeRO-Offload / ZeRO-Infinity), tetapi ini meningkatkan kependaman.

Bagaimana untuk menjadi hos sendiri GPT-OSS pada pembekal awan (panduan praktikal & petunjuk kos)?

Perkakasan awan yang manakah untuk dipilih?

GPU Tunggal 80 GB H100: bagus untuk mengehos gpt-oss-120b untuk trafik kecil hingga sederhana. Dalam istilah AWS, kejadian P5 menyediakan perkakasan H100; varian GPU tunggal (diumumkan pada 2025) menjadikannya lebih murah kepada saiz yang betul untuk inferens. Gunakan keluarga P5 / ND H100 bergantung pada pembekal.
Berbilang GPU (8× H100): untuk pemprosesan tinggi dan lebihan, gunakan p5.48x, p5dn atau kluster yang setanding. NVidia NVLink/NVSwitch dalam contoh yang sama mengurangkan overhed komunikasi antara GPU.
Awan alternatif: CoreWeave, Lambda Labs, Paperspace, Runpod — selalunya sewa GPU spot/ondemand yang lebih murah untuk inferens pecah. Gunakannya untuk pembangun sebelum melakukan infra jangka panjang.
Pengeluaran canggih / berat: AWS p5 (H100) (8 × H100 80GB setiap contoh) — untuk pemprosesan tertinggi bagi setiap nod dan keperluan GPU tunggal 80+ GB, atau untuk 120B+ dengan kurang pemisahan. P5 menyediakan storan tempatan H100 dan NVMe yang besar.

bekas, teks-generasi-inferens (TGI)/NVIDIA TGI, atau sediakan inferens DeepSpeed.

Menyediakan NVMe tempatan yang pantas jika anda bercadang untuk memuatkan keadaan pengaktifan yang besar (ZeRO-Infinity). Nod P4/P5 selalunya mempunyai NVMe tempatan dan lebar jalur rangkaian yang sangat tinggi. ()
Keselamatan & rangkaian — letakkan titik akhir inferens di belakang pengimbang beban, gunakan kumpulan penskalaan automatik untuk bahagian hadapan dan kebimbangan berasingan (penyajian model vs penghalaan permintaan).
Pemantauan & SLO — jejak penggunaan GPU, memori, token/saat, kependaman p95 dan ralat; gunakan Prometheus + Grafana untuk metrik.

Contoh aliran kerja pengehosan kendiri awan (AWS P4/P5)

Pilih contoh (p4d/p5) berdasarkan keperluan memori model. Untuk gpt-oss-20B, satu contoh 16–32 GB adalah baik; untuk gpt-oss-120B pilih contoh HBM 80GB atau berbilang GPU.
Sediakan AMI / imej — gunakan AMI vendor yang menggabungkan CUDA, cuDNN dan PyTorch yang dioptimumkan (atau imej vendor dengan pemacu NVIDIA).
Pasang timbunan hidangan: vLLM, transformer, bekas teks-generasi-inferens (TGI)/NVIDIA TGI, atau sediakan inferens DeepSpeed.
Menyediakan NVMe tempatan yang pantas jika anda bercadang untuk memuatkan keadaan pengaktifan yang besar (ZeRO-Infinity). Nod P4/P5 selalunya mempunyai NVMe tempatan dan lebar jalur rangkaian yang sangat tinggi.
Keselamatan & rangkaian — letakkan titik akhir inferens di belakang pengimbang beban, gunakan kumpulan penskalaan automatik untuk bahagian hadapan dan kebimbangan berasingan (penyajian model vs penghalaan permintaan).
Pemantauan & SLO — jejak penggunaan GPU, memori, token/saat, kependaman p95 dan ralat; gunakan Prometheus + Grafana untuk metrik.

Contoh pelan hos kendiri (gpt-oss-20b, pengeluaran skala kecil)

Matlamat: berkhidmat ~20 pengguna serentak, sasaran tindak balas 1–2s, sensitif kos.

Contohnya: 1× GPU A10G / 1× 24 GB (cth, G5 / A10G / RTX 6000) untuk model + 1× pelayan bootstrap CPU kecil.
Runtime: vLLM sebagai pelayan model (pengumpulan berterusan) + get laluan CometAPI.
Skala automatik: gunakan kumpulan autoscaling dengan GPU AMI dan ALB + autoscaling mendatar oleh metrik CPU/GPU.
Pada Suhu Ambien: NVMe tempatan untuk caching model; stor objek (S3) untuk penyimpanan model sejuk.
Pemantauan: Prometheus + Grafana, jejak penggunaan GPU, kependaman, panjang baris gilir.
Keselamatan: VPC, subnet peribadi, peranan IAM untuk storan model, sijil TLS.

Contoh pelan hos kendiri (gpt-oss-120b, pengeluaran)

Matlamat: kependaman rendah untuk banyak pengguna / perusahaan serentak.

Contohnya: 1× H100 80 GB (GPU tunggal) untuk garis dasar; skala secara mendatar atau gunakan tika berbilang GPU p5 untuk pemprosesan. Untuk daya pemprosesan yang tinggi, sama ada replikasi perkhidmatan GPU tunggal (data selari) atau pecahkan model merentas GPU menggunakan DeepSpeed (tensor/talian paip).
Runtime: DeepSpeed-Inference dengan TP automatik atau NVIDIA TensorRT (jika ada). Sokongan vLLM untuk MoE/Multi-GPU dan kernel yang ditala mungkin juga berguna.
Kubernetes: gunakan K8 dengan pemalam peranti dan NVMe tempatan; gunakan ujian huru-hara untuk ketersediaan.
Pengoptimuman kos: keadaan terpelihara untuk beban yang boleh diramal; contoh spot untuk beban kerja kelompok.

Contoh: mulakan bekas hidangan vLLM untuk gpt-oss-20b

# assume vllm is installed and CUDA is set up

vllm serve --model openai/gpt-oss-20b --port 8000 --num-gpus 1

Kemudian halakan bahagian hadapan anda ke http://<host>:8000/v1/chat/completions (vLLM menyokong API serasi OpenAI).

Petua pengoptimuman kos

VM Spot/Preemptible adalah 50–80% lebih murah tetapi memerlukan pemeriksaan atau strategi pembiakan semula yang cepat.
Kuantiti model mengurangkan keperluan jenis contoh (cth, 120B terkuantisasi mungkin disediakan pada GPU yang lebih sedikit jika enjin menyokong penyahkuantan segera).
Gunakan keluarga contoh yang dioptimumkan inferens sahaja (P5/P4/A2 Ultra) dengan NVLink/NVSwitch tinggi apabila melakukan selari model berbilang GPU; lebar jalur rangkaian penting untuk sharding antara GPU.

Cara mengimbangi kos, kependaman dan kualiti model

Kuantiti: kelajuan vs kualiti

Pengkuantitian agresif (2-4 bit, AWQ/GPTQ) → penjimatan memori yang besar dan selalunya kehilangan kualiti yang sederhana untuk banyak tugas. Gunakan AWQ/GPTQ untuk pengeluaran jika anda menanda aras beban kerja tertentu. Penukaran mungkin memerlukan memori CPU yang besar semasa kuantisasi.

Ketepatan campuran & pengoptimuman kernel

Penggunaan fp16, bf16 di mana disokong; bergabung dengan inti CUDA khusus (FasterTransformer, TensorRT) untuk pemprosesan maksimum. Nvidia/TensorRT menawarkan penyahkodan spekulatif dan kernel yang dioptimumkan untuk banyak transformer (NVIDIA menyediakan penyesuai GPT-OSS yang dioptimumkan).

Keselamatan & kebolehmerhatian

Model berat terbuka bermakna anda bertanggungjawab untuk memantau penyalahgunaan, kebocoran data dan hanyut. Laksanakan pengelogan permintaan, penapis kandungan, pengehadan kadar dan penyederhanaan manusia dalam gelung. Nota keluaran dan kad model OpenAI menekankan ujian dalaman dan penilaian luaran mereka — tetapi pengehosan sendiri mengalihkan perimeter keselamatan kepada anda.

Akhir fikiran

GPT-OSS menggerakkan jarum: model yang sebelum ini memerlukan infra dipesan lebih dahulu kini lebih mudah didekati berkat pilihan seni bina yang teliti dan pengedaran terkuantiti. Tetapi penempatan tetap satu disiplin: saiz perkakasan mesti mempertimbangkan ketepatan model, panjang konteks dan profil konkurensi apl anda. Gunakan katil ujian kecil (dikuantiti 20B) untuk mengukur token/saat dan kependaman p95, dan kemudian darab untuk menganggarkan pengiraan awan dan kos untuk pengeluaran.

Cara Mengakses API GPT-OSS

CometAPI ialah platform API bersatu yang mengagregatkan lebih 500 model AI daripada pembekal terkemuka—seperti siri GPT OpenAI, Google Gemini, Anthropic's Claude, Midjourney, Suno dan banyak lagi—menjadi satu antara muka mesra pembangun. Dengan menawarkan pengesahan yang konsisten, pemformatan permintaan dan pengendalian respons, CometAPI secara dramatik memudahkan penyepaduan keupayaan AI ke dalam aplikasi anda. Sama ada anda sedang membina chatbots, penjana imej, komposer muzik atau saluran paip analitik terdorong data, CometAPI membolehkan anda mengulangi dengan lebih pantas, mengawal kos dan kekal sebagai vendor-agnostik—semuanya sambil memanfaatkan penemuan terkini merentas ekosistem AI.

Pembangun boleh mengakses GPT-OSS-20B and GPT-OSS-120B melalui CometAPI, versi model terkini yang disenaraikan adalah pada tarikh penerbitan artikel. Untuk memulakan, terokai keupayaan model dalam Taman Permainan dan berunding dengan Panduan API untuk arahan terperinci. Sebelum mengakses, sila pastikan anda telah log masuk ke CometAPI dan memperoleh kunci API. CometAPI menawarkan harga yang jauh lebih rendah daripada harga rasmi untuk membantu anda menyepadukan.