OpenAI回归开源：gpt-oss-120b和gpt-oss-20b完整指南 原创

pip install --upgrade accelerate transformers

from transformers import AutoTokenizer, AutoModelForCausalLM
tokenizer = AutoTokenizer.from_pretrained("openai/gpt-oss-20b")
model = AutoModelForCausalLM.from_pretrained(
 "openai/gpt-oss-20b", device_map="auto", torch_dtype="auto")

messages = [
 {"role": "system", "content": "You are a helpful assistant."},
 {"role": "user", "content": "Explain why the sky is blue."}
]
inputs = tokenizer.apply_chat_template(
 messages, add_generation_prompt=True, return_tensors="pt"
).to(model.device)
outputs = model.generate(**inputs, max_new_tokens=200)
print(tokenizer.decode(outputs[0]))

pip install vllm

vllm serve openai/gpt-oss-120b --tensor-parallel-size 2

from vllm import LLM
llm = LLM("openai/gpt-oss-120b", tensor_parallel_size=2)
output = llm.generate("San Francisco is a")
print(output)

ollama pull gpt-oss:20b
ollama run gpt-oss:20b

from openai import OpenAI
client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
response = client.chat.completions.create(
 model="gpt-oss:20b",
 messages=[
 {"role": "system", "content": "You are a helpful assistant."},
 {"role": "user", "content": "Explain what MXFP4 quantization is."}
 ]
)
print(response.choices[0].message.content)

# macOS:
brew install llama.cpp
# Start a local HTTP server for inference:

import os
os.environ['HF_TOKEN'] = 'HF_TOKEN'
from openai import OpenAI
client = OpenAI(
 base_url="https://router.huggingface.co/v1",
 api_key=os.environ["HF_TOKEN"],
)
completion = client.chat.completions.create(
 model="openai/GPT-Oss-20b", # openai/GPT-Oss-120b Change to use 120b model
 messages=[
 {
 "role": "user",
 "content": """Select the option that is related to the third term in the same way as the second term is related to the first term.
 IVORY : ZWSPJ :: CREAM : ?
A. NFDQB
B. SNFDB
C. DSFCN
D. BQDZL
"""
 }
 ],
)
# Check if there's content in the main content field
if completion.choices[0].message.content:
 print("Content:", completion.choices[0].message.content)
else:
 # If content is None, check reasoning_content
 print("Reasoning Content:", completion.choices[0].message.reasoning_content)
# For Markdown display in Jupyter
from IPython.display import display, Markdown
# Display the actual content that exists
content_to_display = (completion.choices[0].message.content or
 completion.choices[0].message.reasoning_content or
 "No content available")

Content: **Answer: C. DSFCN**
1
Answer: C. DSFCN
display (Markdown (content_to_display))

display (Markdown (content_to_display))
→ Letters of CREAM: C=3, R=18, E=5, A=1, M=13.
Option A: NFDQB: N=14, F=6, D=4, Q=17, B=2. Differences: +11, -12, -1, +16, -11? Let's compute: 3->14 diff +11.
18->6 diff -12 or +14 mod 26. 5->4 diff -1. 1->17 diff +16. 13->2 diff -11 or +15 mod 26.
Option B: SNFDB: S=19, N=14, F=6, D=4, B=2. Diffs: +16, -4, +1, +3, -11? Actually 1->? Wait 1 is A -> D=4 diff +3. 13->2 diff -11.
Option C: DSFCN: D=4, S=19, F=6, C=3, N=14. Diffs: +1, -4? 18->19 +1? Wait from R=18 to S=19 diff +1. 5->6 +1. 1->3 +2. 13->14 +1. So diff pattern from CREAM: +1, +1, +1, +2, +1? Hmm.
Option D: BQDZL: B=2, Q=17, D=4, Z=26, L=12. Diffs: -1? 3->2-1. 18->17 - 1. 5->4 -1. 1->26 -? 1->26 diff+25 or
1 but need wrap: 1 to 26 is -1 mod 26? Actually 26-1=25; but shift -1? 13->12 -1. So pattern differences:
1,-1,-1,-1,-1. That looks like constant shift -1. Wait check: A-> difference of -1? But from A to Z one position back yields Z. So -1 shift for each letter.
But CREAM to BQDZL: C(3)->B(2) diff -1; R(18)->Q(17) diff -1; E(5)->D(4) diff -1; A(1)->Z(26) diff -1; M(13)-
>L(12) diff -1. Yep exactly each letter minus 1 circularly. So mapping from IVORY to ZWSPJ: Let's check if shift is also -1 for all letters? IVORY: I(9)->Z(26) diff -? 9-1=8 which is H, not Z. So not -1. Let's try shift +? but maybe we mis-evaluated earlier differences incorrectly? Let's compute mapping of letters of IVORY to ZWSPJ if shift is +? compute 9 > 26: difference +17. 22 ->23: +1. 15 ->19: +4. 18->16: -2. 25->10: -15 or +11. So not constant.
But mapping for CREAM to BQDZL is constant -1. Could that be the same rule that applied to IVORY? Let's see if maybe we mis-check: maybe we should shift each letter of IVORY +? to get ZWSPJ. Check if shift is maybe +10?
9+10=19 -> S, not Z. Maybe shift is +? maybe it's variable: first letter shift by +17, second +1, etc. Might correspond to the positions of C and D? Maybe shift pattern equal to letters of "IRIS"? Hard.
But maybe we mis-evaluated mapping: Let's just brute force compute if there's any simple transformation for
IVORY to ZWSPJ that could also apply to CREAM making one of options. Because four options: NFDOB (option
A) etc. Maybe only one will match a pattern that also holds for IVORY->ZWSPJ.
Maybe we need to deduce mapping from the two words: find the key that transforms first to second. Could be a Caesar shift based on some rule like shift each letter by number of letters same as preceding letter's position difference? For example: I shift by something, produce Z. Let's see I->Z: difference 17. Maybe shift equals difference between l's position in alphabet and length of word? 9-5=4? Not 17. difference between number of letters before I? No.
Maybe mapping uses the second word's letters as "reference" like "Z" is the 26th letter which equals sum of I (9) +
V 22) + 0(15) + R18) + Y25) = 9+22+15+18+25=89; 89 mod 26 = 11? not 26.

import os
from openai import OpenAI
client = OpenAI(
 base_url="https://router.huggingface.co/v1",
 api_key=os.environ["HF_TOKEN"],
)
completion = client.chat.completions.create(
 model="openai/GPT-Oss-120b", # openai/GPT-Oss-20b change to use 20b model
 messages=[
 {
 "role": "user",
 "content": """Given two sorted arrays nums1 and nums2 of size m and n respectively, return the median of the two sorted arrays.
 The overall run time complexity should be O(log (m+n)) in C++.
 Example 1:
 Input: nums1 = [1,3], nums2 = [2]
 Output: 2.00000
 Explanation: merged array = [1,2,3] and median is 2.
 Example 2:
 Input: nums1 = [1,2], nums2 = [3,4]
 Output: 2.50000
 Explanation: merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5.
 Constraints:
 nums1.length == m
 nums2.length == n
 0 <= m <= 1000
 0 <= n <= 1000
 1 <= m + n <= 2000
 -106 <= nums1[i], nums2[i] <= 106
"""
 }
 ],
)
# Check if there's content in the main content field
if completion.choices[0].message.content:
 print("Content:", completion.choices[0].message.content)
else:
 # If content is None, check reasoning_content
 print("Reasoning Content:", completion.choices[0].message.reasoning_content)
# For Markdown display in Jupyter
from IPython.display import display, Markdown
# Display the actual content that exists
content_to_display = (completion.choices[0].message.content or
 completion.choices[0].message.reasoning_content or
 "No content available")

include <bits/stdc++.h>
using namespace std;
class Solution {
public:
 double findMedianSortedArrays(const vector<int>& nums1,
 const vector<int>& nums2) {
 // Let A be the shorter array.
 const vector<int>* A = &nums1;
 const vector<int>* B = &nums2;
 if (A->size() > B->size()) swap(A, B); // now |A| ≤ |B|
 int m = A->size();
 int n = B->size();
 int total = m + n;
 int half = (total + 1) / 2; // size of left part
 int low = 0, high = m; // we search over number of elements taken from A
 while (low <= high) {
 int i = (low + high) / 2; // elements from A on the left side
 int j = half - i; // must come from B
 // Edge handling: use infinities for out‑of‑range indices
 int a_left = (i == 0 ? INT_MIN : (*A)[i - 1]);
 int a_right = (i == m ? INT_MAX : (*A)[i]);
 int b_left = (j == 0 ? INT_MIN : (*B)[j - 1]);
 int b_right = (j == n ? INT_MAX : (*B)[j]);
 if (a_left > b_right) { // i too large
 high = i - 1;
 } else if (b_left > a_right) { // i too small
 low = i + 1;
 } else { // correct split
 int max_left = max(a_left, b_left);
 if (total % 2 == 1) // odd
 return static_cast<double>(max_left);
 int min_right = min(a_right, b_right);
 return (max_left + min_right) / 2.0;
 }
 }
 // The code never reaches here because the constraints guarantee at least one element.
 return 0.0;
 }
};
/* Example usage
int main() {
 Solution s;
 vector<int> a = {1, 3};
 vector<int> b = {2};
 cout << fixed << setprecision(5) << s.findMedianSortedArrays(a, b) << endl; // 2.00000
 a = {1,2};
 b = {3,4};
 cout << fixed << setprecision(5) << s.findMedianSortedArrays(a, b) << endl; // 2.50000
}

# Reference Implementation (C++17)
include <bits/stdc++.h>
using namespace std;
class Solution {
public:
 double findMedianSortedArrays(vector<int>& nums1,
 vector<int>& nums2) {
 // Ensure nums1 is the shorter array
 if (nums1.size() > nums2.size())
 return findMedianSortedArrays(nums2, nums1);
 int m = nums1.size();
 int n = nums2.size();
 int low = 0, high = m;
 int halfLen = (m + n + 1) / 2; // size of left part
 while (low <= high) {
 int i = (low + high) / 2; // partition in nums1
 int j = halfLen - i; // partition in nums2
 // i too small - must move right
 if (i < m && nums2[j-1] > nums1[i])
 low = i + 1;
 // i too big - must move left
 else if (i > 0 && nums1[i-1] > nums2[j])
 high = i - 1;
 else {
 // correct partition found
 int maxLeft;
 if (i == 0)
 maxLeft = nums2[j-1];
 else if (j == 0)
 maxLeft = nums1[i-1];
 else
 maxLeft = max(nums1[i-1], nums2[j-1]);
 // odd total, median is maxLeft
 if ((m + n) % 2 == 1)
 return static_cast<double>(maxLeft);
 // even total, need minRight as well
 int minRight;
 if (i == m)
 minRight = nums2[j];
 else if (j == n)
 minRight = nums1[i];
 else
 minRight = min(nums1[i], nums2[j]);
 return (maxLeft + minRight) / 2.0;
 }
 }
 // Should never reach here for valid input
 return 0.0;
 }
};
/* Example usage:
int main() {
 Solution s;
 vector<int> a = {1, 3};
 vector<int> b = {2};
 cout << fixed << setprecision(5) << s.findMedianSortedArrays(a, b) << endl; // 2.00000
}