import autogen
# 配置LLM
config_list = [
    {
        "model": "gpt-4o",
        "api_key": "your-api-key",
    }
]
# 創(chuàng)建助手Agent
assistant = autogen.AssistantAgent(
    name="assistant",
    llm_config={"config_list": config_list},
)
# 創(chuàng)建用戶代理
user_proxy = autogen.UserProxyAgent(
    name="user_proxy",
    human_input_mode="TERMINATE",
    code_execution_config={
        "work_dir": "coding",
        "use_docker": False,
    },
)
# 發(fā)起對話
user_proxy.initiate_chat(
    assistant,
    message="請用Python寫一個爬蟲，抓取天氣數(shù)據(jù)并生成可視化圖表",
)

from transformers import pipeline

# 文本情感分析
classifier = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")
result = classifier("Python is the best language for AI development!")
print(result)
# [{'label': 'POSITIVE', 'score': 0.9998}]

# 自動語音識別
transcriber = pipeline("automatic-speech-recognition", model="openai/whisper-large-v3")
text = transcriber("meeting_recording.mp3")
print(text["text"])

# 圖像分類
image_classifier = pipeline("image-classification", model="google/vit-base-patch16-224")
result = image_classifier("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonkie.jpeg")
print(result)

from fastapi import FastAPI, File, UploadFile
from pydantic import BaseModel
import uvicorn

app = FastAPI(title="AI Model Serving API")

class TextRequest(BaseModel):
    text: str
    max_length: int = 512

class PredictionResponse(BaseModel):
    label: str
    confidence: float

@app.post("/predict", response_model=PredictionResponse)
async def predict(request: TextRequest):
    """文本分類預(yù)測接口"""
    # 這里接入你的模型推理邏輯
    result = your_model.predict(request.text)
    return PredictionResponse(
        label=result.label,
        confidence=result.score,
    )

@app.post("/predict/image")
async def predict_image(file: UploadFile = File(...)):
    """圖像分類預(yù)測接口"""
    contents = await file.read()
    result = your_vision_model.predict(contents)
    return {"label": result.label, "confidence": result.score}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

import spacy

# 加載中文模型
nlp = spacy.load("zh_core_web_trf")

text = "蘋果公司在2026年發(fā)布了全新的M5芯片，性能提升了50%"

doc = nlp(text)

# 命名實體識別
for ent in doc.ents:
    print(f"實體: {ent.text:<15} 標(biāo)簽: {ent.label_}")
# 實體: 蘋果公司          標(biāo)簽: ORG
# 實體: 2026年            標(biāo)簽: DATE
# 實體: M5芯片            標(biāo)簽: PRODUCT
# 實體: 50%               標(biāo)簽: PERCENT

# 依存句法分析
for token in doc:
    print(f"{token.text:<8} {token.pos_:<10} {token.dep_:<12} {token.head.text}")

from crewai import Agent, Task, Crew, Process
from crewai.llm import LLM

llm = LLM(model="gpt-4o", api_key="your-api-key")

# 定義研究員Agent
researcher = Agent(
    role="高級市場研究員",
    goal="深入分析AI行業(yè)趨勢，發(fā)現(xiàn)投資機(jī)會",
    backstory="你是一位擁有10年經(jīng)驗的科技行業(yè)分析師",
    llm=llm,
    verbose=True,
)

# 定義撰稿人Agent
writer = Agent(
    role="技術(shù)撰稿人",
    goal="將研究結(jié)果轉(zhuǎn)化為易懂的分析報告",
    backstory="你擅長將復(fù)雜技術(shù)概念轉(zhuǎn)化為商業(yè)語言",
    llm=llm,
    verbose=True,
)

# 定義任務(wù)
research_task = Task(
    description="分析2026年AI行業(yè)最熱門的5個投資方向",
    expected_output="一份詳細(xì)的行業(yè)分析報告，包含數(shù)據(jù)支撐",
    agent=researcher,
)

write_task = Task(
    description="基于研究結(jié)果撰寫一篇面向投資人的分析簡報",
    expected_output="結(jié)構(gòu)清晰的HTML格式報告",
    agent=writer,
)

# 組建團(tuán)隊并執(zhí)行
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, write_task],
    process=Process.sequential,
)

result = crew.kickoff()
print(result)

import torch
import torch.nn as nn
from torch.compile import compile

# 定義一個簡單的Transformer模型
class SimpleTransformer(nn.Module):
    def __init__(self, vocab_size, d_model=256, nhead=8, num_layers=4):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, d_model)
        encoder_layer = nn.TransformerEncoderLayer(
            d_model=d_model, nhead=nhead, batch_first=True,
        )
        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers)
        self.fc = nn.Linear(d_model, vocab_size)

    def forward(self, x):
        x = self.embedding(x)
        x = self.transformer(x)
        return self.fc(x)

# 使用 torch.compile 加速（PyTorch 3.0核心特性）
model = SimpleTransformer(vocab_size=50000)
compiled_model = torch.compile(model)

# 模擬訓(xùn)練
optimizer = torch.optim.AdamW(compiled_model.parameters(), lr=3e-4)
loss_fn = nn.CrossEntropyLoss()

for step in range(100):
    inputs = torch.randint(0, 50000, (32, 128))   # batch=32, seq_len=128
    targets = torch.randint(0, 50000, (32, 128))

    outputs = compiled_model(inputs)
    loss = loss_fn(outputs.view(-1, 50000), targets.view(-1))

    loss.backward()
    optimizer.step()
    optimizer.zero_grad()

    if step % 20 == 0:
        print(f"Step {step}: Loss = {loss.item():.4f}")

from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.pipeline import Pipeline
from sklearn.metrics import mean_squared_error, r2_score
import numpy as np

# 加載數(shù)據(jù)
X, y = fetch_california_housing(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42,
)

# 構(gòu)建Pipeline
pipeline = Pipeline([
    ("scaler", StandardScaler()),
    ("model", GradientBoostingRegressor(
        n_estimators=300,
        max_depth=6,
        learning_rate=0.05,
        random_state=42,
    )),
])

# 訓(xùn)練與評估
pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)

rmse = np.sqrt(mean_squared_error(y_test, y_pred))
r2 = r2_score(y_test, y_pred)
print(f"RMSE: {rmse:.4f}")
print(f"R2 Score: {r2:.4f}")

from vllm import LLM, SamplingParams

# 加載模型
llm = LLM(
    model="Qwen/Qwen2.5-72B-Instruct",
    tensor_parallel_size=4,      # 4卡并行
    gpu_memory_utilization=0.90,  # GPU顯存利用率
    max_model_len=8192,
)

# 配置采樣參數(shù)
sampling_params = SamplingParams(
    temperature=0.7,
    top_p=0.9,
    max_tokens=2048,
)

# 批量推理（vLLM的核心優(yōu)勢）
prompts = [
    "請用Python實現(xiàn)一個高效的LRU緩存",
    "解釋Transformer中多頭注意力機(jī)制的工作原理",
    "對比RAG和微調(diào)兩種方案，給出選擇建議",
]

outputs = llm.generate(prompts, sampling_params)

for output in outputs:
    prompt = output.prompt
    generated = output.outputs[0].text
    print(f"Prompt: {prompt[:30]}...")
    print(f"Response: {generated[:200]}...\n")

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_community.tools import DuckDuckGoSearchRun
from langchain_core.runnables import RunnablePassthrough

# 初始化模型和工具
llm = ChatOpenAI(model="gpt-4o", temperature=0)
search = DuckDuckGoSearchRun()

# 使用LCEL構(gòu)建鏈
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一個專業(yè)的技術(shù)顧問，基于搜索結(jié)果回答問題。"),
    ("human", "{query}\n\n搜索結(jié)果：{search_result}"),
])

chain = (
    {
        "query": RunnablePassthrough(),
        "search_result": lambda x: search.invoke(x),
    }
    | prompt
    | llm
    | StrOutputParser()
)

# 執(zhí)行鏈
answer = chain.invoke("2026年P(guān)ython有哪些新的AI框架值得學(xué)習(xí)？")
print(answer)

import numpy as np

# NumPy 3.0: 無需修改代碼即可GPU加速
a = np.array([1.0, 2.0, 3.0, 4.0] * 1_000_000, device="cuda")
b = np.array([5.0, 6.0, 7.0, 8.0] * 1_000_000, device="cuda")

# 自動在GPU上執(zhí)行
c = np.dot(a.reshape(-1, 4), b.reshape(4, -1))
print(f"Device: {c.device}")  # cuda:0

import numpy as np

# NumPy 3.0: 內(nèi)置自動微分
def loss_fn(w, x, y):
    pred = np.dot(x, w)
    return np.mean((pred - y) ** 2)

# 前向傳播
x = np.random.randn(100, 10)
y = np.random.randn(100)
w = np.zeros(10)

# 自動求導(dǎo)
grad = np.grad(loss_fn)(w, x, y)
w -= 0.01 * grad

import numpy as np

# NumPy 3.0: 直接轉(zhuǎn)換為PyTorch Tensor / JAX Array（零拷貝）
arr = np.ones((3, 3))

import torch
tensor = torch.from_numpy(arr)   # 零拷貝共享內(nèi)存

# 支持新的dtype: bfloat16, float8
bf16_array = np.array([1.0, 2.0], dtype=np.bfloat16)
fp8_array = np.array([1.0, 2.0], dtype=np.float8_e4m3fn)