<|start|>system<|message|>システム指示<|end|>
<|start|>developer<|message|>開発者指示<|end|>
<|start|>user<|message|>ユーザー入力<|end|>
<|start|>assistant<|channel|>analysis<|message|>推論過程<|end|>
<|start|>assistant<|channel|>final<|message|>最終回答<|return|>

<|start|>system<|message|>You are ChatGPT, a large language model trained by OpenAI.
Knowledge cutoff: 2024-06
Current date: 2025-10-04

Reasoning: medium

# Valid channels: analysis, commentary, final.
<|end|>

{
  "messages": [
    {
      "role": "system",
      "content": "You are ChatGPT..."
    },
    {
      "role": "user",
      "content": "質問内容"
    },
    {
      "role": "assistant",
      "thinking": "推論プロセス（オプション）",
      "content": "回答内容"
    }
  ]
}

from openai_harmony import (
    Conversation,
    Message,
    Role,
    SystemContent,
    DeveloperContent,
    HarmonyEncodingName,
    load_harmony_encoding,
    ReasoningEffort
)

# Harmonyエンコーディングをロード
encoding = load_harmony_encoding(HarmonyEncodingName.HARMONY_GPT_OSS)

# システムメッセージの作成
system_message = (
    SystemContent.new()
    .with_reasoning_effort(ReasoningEffort.MEDIUM)
    .with_conversation_start_date("2025-10-04")
)

# 開発者指示の追加
developer_message = (
    DeveloperContent.new()
    .with_instructions("You are a medical expert. Respond concisely with diagnosis in ≤5 words.")
)

# 会話の構築
conversation = Conversation.from_messages([
    Message.from_role_and_content(Role.SYSTEM, system_message),
    Message.from_role_and_content(Role.DEVELOPER, developer_message),
    Message.from_role_and_content(Role.USER, "What causes chest pain?"),
    Message.from_role_and_content(Role.ASSISTANT, "Coronary artery disease")
])

from datasets import load_dataset

dataset = load_dataset("HuggingFaceH4/Multilingual-Thinking")

import json

# データセット構造
data = [
    {
        "messages": [
            {"role": "system", "content": "You are an expert assistant."},
            {"role": "user", "content": "What is machine learning?"},
            {
                "role": "assistant",
                "thinking": "User asks basic ML definition. Provide clear explanation.",
                "content": "Machine learning is a subset of AI..."
            }
        ]
    }
]

# JSONL形式で保存
with open('training_data.jsonl', 'w') as f:
    for item in data:
        f.write(json.dumps(item) + '\n')

# 仮想環境の作成
conda create -n gpt-oss python=3.10
conda activate gpt-oss

# 必須パッケージ
pip install torch --index-url https://download.pytorch.org/whl/cu128
pip install transformers>=4.55.0
pip install accelerate>=0.30.0
pip install peft>=0.17.0
pip install trl>=0.20.0
pip install bitsandbytes>=0.43.0
pip install triton==3.4

# Harmony関連
pip install openai-harmony
pip install tiktoken

# ユーティリティ
pip install datasets
pip install wandb  # 実験トラッキング（オプション）

# Unslothのインストール
pip uninstall unsloth -y
pip install --upgrade --no-cache-dir --no-deps git+https://github.com/unslothai/unsloth.git

# 追加パッケージ
pip install xformers
pip install triton

# SageMaker Studioで実行
%pip install sagemaker>=2.200.0
%pip install transformers>=4.55.0
%pip install trl>=0.20.0
%pip install accelerate

from huggingface_hub import notebook_login

# ブラウザでログイン
notebook_login()

# または環境変数で設定
import os
os.environ['HF_TOKEN'] = 'your_token_here'

wandb login

# Pythonコード内
import wandb
wandb.init(
    project="gpt-oss-finetuning",
    name="experiment-1"
)

# GPT-OSS 20B (推奨: 実験・開発)
model_id = "openai/gpt-oss-20b"

# GPT-OSS 120B (本番環境向け)
model_id = "openai/gpt-oss-120b"

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
import torch
from transformers import BitsAndBytesConfig

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

# 4bit量子化設定
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True
)

# モデルロード
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,
    torch_dtype=torch.bfloat16
)

# トークナイザー
tokenizer = AutoTokenizer.from_pretrained(model_id)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"

# LoRA準備
model = prepare_model_for_kbit_training(model)

# BF16でロード
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    device_map="auto",
    torch_dtype=torch.bfloat16,
    trust_remote_code=True
)

tokenizer = AutoTokenizer.from_pretrained(model_id)
tokenizer.pad_token = tokenizer.eos_token

from peft import LoraConfig, TaskType

# LoRAコンフィグ
lora_config = LoraConfig(
    r=16,                          # LoRAランク
    lora_alpha=32,                 # スケーリングファクター
    target_modules=[
        "q_proj",
        "k_proj", 
        "v_proj",
        "o_proj",
        "gate_proj",
        "up_proj",
        "down_proj"
    ],
    lora_dropout=0.05,
    bias="none",
    task_type=TaskType.CAUSAL_LM
)

# PEFTモデルの作成
model = get_peft_model(model, lora_config)

# 学習可能パラメータの確認
model.print_trainable_parameters()
# 出力例: trainable params: 167,772,160 || all params: 21,234,567,890 || trainable%: 0.79

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="openai/gpt-oss-20b",
    max_seq_length=8192,
    dtype=None,  # 自動選択
    load_in_4bit=True,
)

# LoRA適用
model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=[
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj"
    ],
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    use_gradient_checkpointing="unsloth",
    random_state=3407,
)

from datasets import load_dataset

# データセットロード
dataset = load_dataset("HuggingFaceH4/Multilingual-Thinking", split="train")

# Harmonyフォーマット変換関数
def format_to_harmony(example):
    messages = example["messages"]
    
    # チャットテンプレート適用
    formatted_text = tokenizer.apply_chat_template(
        messages,
        tokenize=False,
        add_generation_prompt=False
    )
    
    return {"text": formatted_text}

# データセット変換
dataset = dataset.map(format_to_harmony, remove_columns=dataset.column_names)

# 確認
print(dataset[0]["text"][:500])

from openai_harmony import (
    Conversation,
    Message,
    Role,
    DeveloperContent,
    load_harmony_encoding,
    HarmonyEncodingName
)

encoding = load_harmony_encoding(HarmonyEncodingName.HARMONY_GPT_OSS)

def create_harmony_example(question, answer, instructions):
    conversation = Conversation.from_messages([
        Message.from_role_and_content(
            Role.DEVELOPER,
            DeveloperContent.new().with_instructions(instructions)
        ),
        Message.from_role_and_content(Role.USER, question),
        Message.from_role_and_content(Role.ASSISTANT, answer)
    ])
    
    # トークン化
    tokens = encoding.render_conversation_for_completion(
        conversation,
        Role.ASSISTANT
    )
    
    return tokenizer.decode(tokens)

# 適用
dataset = dataset.map(
    lambda x: {
        "text": create_harmony_example(
            x["question"],
            x["answer"],
            "You are a helpful assistant."
        )
    }
)

from trl import SFTConfig, SFTTrainer

# 学習ハイパーパラメータ
training_args = SFTConfig(
    # 基本設定
    output_dir="./gpt-oss-20b-finetuned",
    num_train_epochs=1,
    
    # バッチサイズ
    per_device_train_batch_size=1,
    gradient_accumulation_steps=16,  # 実効バッチサイズ=16
    
    # 学習率
    learning_rate=2e-5,
    lr_scheduler_type="cosine",
    warmup_ratio=0.1,
    
    # 最適化
    optim="paged_adamw_8bit",
    weight_decay=0.01,
    max_grad_norm=1.0,
    
    # メモリ効率
    gradient_checkpointing=True,
    bf16=True,  # BF16サポートGPUの場合
    # fp16=True,  # それ以外
    
    # ロギング
    logging_steps=10,
    logging_dir="./logs",
    
    # 保存
    save_strategy="steps",
    save_steps=100,
    save_total_limit=3,
    
    # シーケンス長
    max_seq_length=2048,
    
    # その他
    report_to="wandb",  # Weights & Biases
    seed=42
)

# トレーナー初期化
trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    args=training_args,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    packing=False  # Harmonyフォーマットでは無効化
)

# 学習開始
trainer.train()

# 最終モデル保存
trainer.save_model("./gpt-oss-20b-final")
tokenizer.save_pretrained("./gpt-oss-20b-final")

import argparse
from transformers import AutoModelForCausalLM, AutoTokenizer
from trl import SFTConfig, SFTTrainer
from datasets import load_dataset

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--model_id", type=str, default="openai/gpt-oss-20b")
    parser.add_argument("--dataset_path", type=str)
    parser.add_argument("--output_path", type=str, default="/opt/ml/model")
    args = parser.parse_args()
    
    # データロード
    dataset = load_dataset("json", data_files=args.dataset_path)
    
    # モデル・トークナイザー
    model = AutoModelForCausalLM.from_pretrained(
        args.model_id,
        torch_dtype="auto",
        device_map="auto"
    )
    tokenizer = AutoTokenizer.from_pretrained(args.model_id)
    
    # 学習設定
    training_args = SFTConfig(
        output_dir=args.output_path,
        num_train_epochs=1,
        per_device_train_batch_size=1,
        gradient_accumulation_steps=16,
        learning_rate=2e-5,
        bf16=True,
        logging_steps=10,
        save_strategy="epoch"
    )
    
    # トレーナー
    trainer = SFTTrainer(
        model=model,
        tokenizer=tokenizer,
        args=training_args,
        train_dataset=dataset["train"]
    )
    
    trainer.train()
    trainer.save_model(args.output_path)

if __name__ == "__main__":
    main()

import sagemaker
from sagemaker.huggingface import HuggingFace

# SageMakerセッション
sess = sagemaker.Session()
role = sagemaker.get_execution_role()

# Hugging Face Estimator
huggingface_estimator = HuggingFace(
    entry_point='train.py',
    source_dir='./scripts',
    instance_type='ml.p4d.24xlarge',  # A100×8
    instance_count=1,
    role=role,
    transformers_version='4.55.0',
    pytorch_version='2.5.0',
    py_version='py310',
    hyperparameters={
        'model_id': 'openai/gpt-oss-20b',
        'dataset_path': '/opt/ml/input/data/training',
        'output_path': '/opt/ml/model'
    }
)

# 学習実行
huggingface_estimator.fit({
    'training': 's3://your-bucket/dataset/training_data.jsonl'
})

from transformers import pipeline

# パイプライン作成
generator = pipeline(
    "text-generation",
    model="./gpt-oss-20b-final",
    tokenizer=tokenizer,
    device_map="auto"
)

# テストプロンプト
messages = [
    {"role": "system", "content": "You are a helpful assistant.\n\nReasoning: medium"},
    {"role": "user", "content": "Explain quantum computing in simple terms."}
]

# 生成
result = generator(
    messages,
    max_new_tokens=200,
    temperature=0.7,
    do_sample=True
)

print(result[0]["generated_text"])

from openai_harmony import StreamableParser, Role, HarmonyEncodingName

encoding = load_harmony_encoding(HarmonyEncodingName.HARMONY_GPT_OSS)

# ストリーミングパーサー
parser = StreamableParser(encoding, role=Role.ASSISTANT)

# トークンごとに処理
for token_id in generated_tokens:
    parser.process(token_id)
    
    # チャネル確認
    if parser.current_channel == "analysis":
        print(f"[推論] {parser.last_content_delta}")
    elif parser.current_channel == "final":
        print(f"[回答] {parser.last_content_delta}")

from datasets import load_dataset

# 評価データセット
eval_dataset = load_dataset("openai/gsm8k", split="test")

# 評価ループ
correct = 0
total = len(eval_dataset)

for example in eval_dataset:
    prompt = example["question"]
    true_answer = example["answer"]
    
    # 推論
    generated = generator(
        [{"role": "user", "content": prompt}],
        max_new_tokens=512
    )[0]["generated_text"]
    
    # 回答抽出と正解チェック
    if check_answer(generated, true_answer):
        correct += 1

accuracy = correct / total
print(f"Accuracy: {accuracy:.2%}")

# PEFTアダプターのみ保存
model.save_pretrained("./lora-adapters")
tokenizer.save_pretrained("./lora-adapters")

from peft import PeftModel

# ベースモデルロード
base_model = AutoModelForCausalLM.from_pretrained(
    "openai/gpt-oss-20b",
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

# アダプターマージ
model = PeftModel.from_pretrained(base_model, "./lora-adapters")
merged_model = model.merge_and_unload()

# 保存
merged_model.save_pretrained("./gpt-oss-20b-merged")
tokenizer.save_pretrained("./gpt-oss-20b-merged")

# BF16形式でマージ・エクスポート
model.save_pretrained_merged(
    "./gpt-oss-20b-merged-bf16",
    tokenizer,
    save_method="merged_16bit"
)

# Hugging Face Hubへプッシュ
model.push_to_hub_merged(
    "your-username/gpt-oss-20b-finetuned",
    tokenizer,
    save_method="merged_16bit",
    token="your_hf_token"
)

# GGUF形式でエクスポート（llama.cpp用）
model.save_pretrained_gguf(
    "./gpt-oss-20b-gguf",
    tokenizer,
    quantization_method="q4_k_m"
)

from huggingface_hub import HfApi

api = HfApi()

# リポジトリ作成
api.create_repo(
    repo_id="your-username/gpt-oss-20b-finetuned",
    private=False
)

# モデルアップロード
api.upload_folder(
    folder_path="./gpt-oss-20b-merged",
    repo_id="your-username/gpt-oss-20b-finetuned",
    repo_type="model"
)

# vLLMインストール
pip install vllm>=0.10.1

# サーバー起動
python -m vllm.entrypoints.openai.api_server \
    --model ./gpt-oss-20b-merged \
    --dtype bfloat16 \
    --max-model-len 8192 \
    --port 8000

import openai

client = openai.OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="dummy"
)

response = client.chat.completions.create(
    model="./gpt-oss-20b-merged",
    messages=[
        {"role": "user", "content": "What is AI?"}
    ]
)

print(response.choices[0].message.content)

import sagemaker
from sagemaker.huggingface import HuggingFaceModel

role = sagemaker.get_execution_role()

# Hugging Faceモデル
huggingface_model = HuggingFaceModel(
    model_data=f"s3://{bucket}/gpt-oss-20b-merged/model.tar.gz",
    role=role,
    transformers_version="4.55.0",
    pytorch_version="2.5.0",
    py_version="py310",
    env={
        'HF_MODEL_ID': 'your-username/gpt-oss-20b-finetuned',
        'HF_TASK': 'text-generation'
    }
)

# デプロイ
predictor = huggingface_model.deploy(
    initial_instance_count=1,
    instance_type="ml.g5.12xlarge"  # A10G×4
)

# リクエスト
response = predictor.predict({
    "inputs": "What is machine learning?",
    "parameters": {
        "max_new_tokens": 200,
        "temperature": 0.7
    }
})

print(response[0]["generated_text"])

# GGUF形式に変換（上記参照）

# Ollamaにインポート
ollama create gpt-oss-custom -f ./Modelfile

# 実行
ollama run gpt-oss-custom "Explain AI"

FROM ./gpt-oss-20b-gguf/model.gguf

TEMPLATE """<|start|>user<|message|>{{ .Prompt }}<|end|><|start|>assistant<|channel|>final<|message|>"""

PARAMETER temperature 0.7
PARAMETER top_p 0.9

# チャットテンプレート使用
tokenizer.apply_chat_template(messages, tokenize=False)

# またはHarmonyライブラリ使用
from openai_harmony import load_harmony_encoding
encoding = load_harmony_encoding(HarmonyEncodingName.HARMONY_GPT_OSS)

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    attn_implementation="flash_attention_2"
)

# IAMロールに適切なS3権限を付与
{
    "Effect": "Allow",
    "Action": ["s3:GetObject", "s3:PutObject"],
    "Resource": "arn:aws:s3:::your-bucket/*"
}

predictor = huggingface_model.deploy(
    model_data_download_timeout=1800,  # 30分
    container_startup_health_check_timeout=600  # 10分
)