打造專屬ChatGPT：利用LLM進行結構化輸出(Structured Outputs)

from openai import OpenAI
import json

client = OpenAI()

completion = client.chat.completions.create(
    model="gpt-4o-2024-08-06",
    messages=[
        {"role": "system", "content": "Extract the event information."},
        {
            "role": "user",
            "content": "Alice and Bob are going to a science fair on Friday.",
        },
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "CalendarEvent",
            "description": "取得活動名稱、時間、參與者",
            "schema": {
                "properties": {
                    "name": {"title": "Name", "type": "string"},
                    "date": {"title": "Date", "type": "string"},
                    "participants": {
                        "items": {"type": "string"},
                        "title": "Participants",
                        "type": "array",
                    },
                },
                "required": ["name", "date", "participants"],
                "title": "CalendarEvent",
                "type": "object",
                "additionalProperties": False,
            },
            "strict": True,
        },
    },
)

event = json.loads(completion.choices[0].message.content)
print(event["name"], event["date"], event["participants"])

{
    "type" :"json_schema",
    "json_schema" {
        "name": Required，a-zA-Z0-9_-，最大長度64
        "description": 協助模型了解該如何使用這個結構
        "schema": *****JSON Schema寫在這裡*****
        "strict": boolean or null，是否嚴格遵循定義。設為True時，只支持部分JSON Schema。預設為False
    }
}

from pydantic import BaseModel

from openai import OpenAI

client = OpenAI()


class CalendarEvent(BaseModel):
    name: str
    date: str
    participants: list[str]

    class Config:
        extra = "forbid"


completion = client.beta.chat.completions.parse(
    model="gpt-4o-2024-08-06",
    messages=[
        {"role": "system", "content": "Extract the event information."},
        {
            "role": "user",
            "content": "Alice and Bob are going to a science fair on Friday.",
        },
    ],
    response_format=CalendarEvent,
)

event = completion.choices[0].message.parsed
print(event.name, event.date, event.participants)

from openai import (
    OpenAI,
    APIConnectionError,
    APIResponseValidationError,
    APIStatusError,
    LengthFinishReasonError,
    ContentFilterFinishReasonError,
)

from pydantic import BaseModel, ValidationError
from typing import List


class CalendarEvent(BaseModel):
    name: str
    date: str
    participants: List[str]

    class Config:
        extra = "forbid"


client = OpenAI()

try:
    completion = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": "Extract the event information."},
            {
                "role": "user",
                "content": "Alice and Bob are going to a science fair on Friday.",
            },
        ],
        response_format={
            "type": "json_schema",
            "json_schema": {
                "name": "CalendarEvent",
                "description": "取得活動名稱、時間、參與者",
                "schema": CalendarEvent.model_json_schema(),
                "strict": True,
            },
        },
    )
    print(completion.choices[0].message.content)

    if completion.choices[0].message.refusal:
        # 使用json_schema時，OpenAI可能會拒絕用戶的請求，從refusal欄位取出拒絕原因
        print(completion.choices[0].message.refusal)
    else:
        event: CalendarEvent = CalendarEvent.model_validate_json(
            completion.choices[0].message.content
        )
        print(event.name, event.date, event.participants)
except APIConnectionError as e:
    # Connection error or Request timed out.
    print(e.message)
except APIResponseValidationError as e:
    # OpenAI回傳資料無法驗證，Data returned by API invalid for expected schema.
    print(e.code, e.type, e.message)
    print(e.status_code)
except APIStatusError as e:
    # 4xx及5xx相關錯誤
    print(e.code, e.type, e.message)
    print(e.status_code)
    print(e.request_id)
except LengthFinishReasonError as e:
    # Could not parse response content as the length limit was reached.
    print(e)
except ContentFilterFinishReasonError as e:
    # Could not parse response content as the request was rejected by the content filter.
    print(e)
except ValidationError as e:
    # pydantic模組驗證模型輸出
    print(e.json())

from pydantic import BaseModel
from openai import OpenAI

class Step(BaseModel):
    explanation: str
    output: str

    class Config:
        extra = "forbid"


class MathReasoning(BaseModel):
    steps: list[Step]
    final_answer: str

    class Config:
        extra = "forbid"

client = OpenAI()
completion = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {
            "role": "system",
            "content": "You are a helpful math tutor. Guide the user through the solution step by step.",
        },
        {"role": "user", "content": "how can I solve 8x + 7 = -23"},
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "MathReasoning",
            "description": "數學計算",
            "schema": MathReasoning.model_json_schema(),
            "strict": True,
        },
    },
)

math_reasoning: MathReasoning = MathReasoning.model_validate_json(
    completion.choices[0].message.content
)
for _ in math_reasoning.steps:
    print(_.explanation)
    print(_.output)

from pydantic import BaseModel
from openai import OpenAI


class ResearchPaperExtraction(BaseModel):
    title: str
    authors: list[str]
    abstract: str
    keywords: list[str]

    class Config:
        extra = "forbid"


client = OpenAI()
completion = client.chat.completions.create(
    model="gpt-4o-2024-08-06",
    messages=[
        {
            "role": "system",
            "content": "You are an expert at structured data extraction. You will be given unstructured text from a research paper and should convert it into the given structure.",
        },
        {"role": "user", "content": "..."},
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "ResearchPaperExtraction",
            "schema": ResearchPaperExtraction.model_json_schema(),
            "strict": True,
        },
    },
)

research_paper = ResearchPaperExtraction.model_validate_json(
    completion.choices[0].message.content
)
print(research_paper)

from enum import Enum
from typing import List
from pydantic import BaseModel
from openai import OpenAI


class UIType(str, Enum):
    div = "div"
    button = "button"
    header = "header"
    section = "section"
    field = "field"
    form = "form"


class Attribute(BaseModel):
    name: str
    value: str

    class Config:
        extra = "forbid"


class UI(BaseModel):
    type: UIType
    label: str
    children: List["UI"]
    attributes: List[Attribute]

    class Config:
        extra = "forbid"


UI.model_rebuild()  # This is required to enable recursive types


class Response(BaseModel):
    ui: UI

    class Config:
        extra = "forbid"


client = OpenAI()
completion = client.beta.chat.completions.parse(
    model="gpt-4o-2024-08-06",
    messages=[
        {
            "role": "system",
            "content": "You are a UI generator AI. Convert the user input into a UI.",
        },
        {"role": "user", "content": "Make a User Profile Form"},
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "Response",
            "description": "生成UI",
            "schema": Response.model_json_schema(),
            "strict": True,
        },
    },
)

ui = Response.model_validate_json(completion.choices[0].message.content)
print(ui)

from enum import Enum
from typing import Optional
from pydantic import BaseModel
from openai import OpenAI


class Category(str, Enum):
    violence = "violence"
    sexual = "sexual"
    self_harm = "self_harm"


class ContentCompliance(BaseModel):
    is_violating: bool
    category: Optional[Category]
    explanation_if_violating: Optional[str]

    class Config:
        extra = "forbid"


client = OpenAI()
completion = client.chat.completions.create(
    model="gpt-4o-2024-08-06",
    messages=[
        {
            "role": "system",
            "content": "Determine if the user input violates specific guidelines and explain if they do.",
        },
        {"role": "user", "content": "How do I prepare for a job interview?"},
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "ContentCompliance",
            "description": "Content Compliance",
            "schema": ContentCompliance.model_json_schema(),
            "strict": True,
        },
    },
)

compliance = ContentCompliance.model_validate_json(
    completion.choices[0].message.content
)
print(compliance)