AI应用方向与场景实践

from openai import OpenAI

client = OpenAI()

# 文章生成
response = client.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "system", "content": "你是一位专业的内容创作者"},
        {"role": "user", "content": "写一篇关于AI在教育领域应用的文章，800字"}
    ]
)

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

# 代码生成
response = client.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "system", "content": "你是一位Python专家"},
        {"role": "user", "content": "写一个快速排序的Python实现"}
    ]
)

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

from langchain.chat_models import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

# 创建带记忆的对话链
llm = ChatOpenAI(temperature=0.7)
memory = ConversationBufferMemory()

conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)

# 多轮对话
response1 = conversation.predict(input="我想买一台笔记本电脑")
print(response1)

response2 = conversation.predict(input="预算在5000-8000元")
print(response2)

response3 = conversation.predict(input="主要用于编程和轻度游戏")
print(response3)

from langchain.document_loaders import DirectoryLoader, TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

# 1. 加载文档
loader = DirectoryLoader('docs/', glob="**/*.txt", loader_cls=TextLoader)
documents = loader.load()

# 2. 分割文档
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
texts = text_splitter.split_documents(documents)

# 3. 创建向量存储
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(
    documents=texts,
    embedding=embeddings,
    persist_directory="./chroma_db"
)

# 4. 创建检索QA链
qa_chain = RetrievalQA.from_chain_type(
    llm=OpenAI(temperature=0),
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3}),
    return_source_documents=True
)

# 5. 查询
query = "公司的休假政策是什么？"
result = qa_chain({"query": query})

print("答案：", result['result'])
print("\n来源文档：")
for doc in result['source_documents']:
    print(f"- {doc.metadata['source']}")

from transformers import pipeline

# 情感分析
sentiment_analyzer = pipeline('sentiment-analysis')

reviews = [
    "这个产品太棒了！完全超出预期。",
    "质量一般，价格偏贵。",
    "非常失望，完全不推荐。",
    "还可以，基本满足需求。"
]

for review in reviews:
    result = sentiment_analyzer(review)[0]
    print(f"评论: {review}")
    print(f"情感: {result['label']}, 置信度: {result['score']:.2f}\n")

# 零样本分类
classifier = pipeline('zero-shot-classification')

text = "苹果公司发布了新款iPhone，股价上涨5%"
candidate_labels = ["科技", "财经", "娱乐", "体育"]

result = classifier(text, candidate_labels)
print(f"文本: {text}")
print(f"分类: {result['labels'][0]}, 置信度: {result['scores'][0]:.2f}")

import torch
from torchvision import models, transforms
from PIL import Image

# 加载预训练模型
model = models.resnet50(pretrained=True)
model.eval()

# 图像预处理
preprocess = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])

# 加载和预测
image = Image.open('product.jpg')
input_tensor = preprocess(image)
input_batch = input_tensor.unsqueeze(0)

with torch.no_grad():
    output = model(input_batch)

# 获取预测结果
probabilities = torch.nn.functional.softmax(output[0], dim=0)
top5_prob, top5_catid = torch.topk(probabilities, 5)

# 显示结果
for i in range(5):
    print(f"{labels[top5_catid[i]]}: {top5_prob[i].item():.2%}")

import torch
import cv2

# 加载YOLOv5模型
model = torch.hub.load('ultralytics/yolov5', 'yolov5s')

# 图片检测
img = 'street.jpg'
results = model(img)

# 显示结果
results.show()

# 获取检测结果
detections = results.pandas().xyxy[0]
print(detections)

# 视频检测
cap = cv2.VideoCapture('video.mp4')

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    
    # 检测
    results = model(frame)
    
    # 绘制结果
    frame_with_detections = results.render()[0]
    
    # 显示
    cv2.imshow('Detection', frame_with_detections)
    
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

from transformers import SegformerFeatureExtractor, SegformerForSemanticSegmentation
from PIL import Image
import torch

# 加载模型
feature_extractor = SegformerFeatureExtractor.from_pretrained("nvidia/segformer-b0-finetuned-ade-512-512")
model = SegformerForSemanticSegmentation.from_pretrained("nvidia/segformer-b0-finetuned-ade-512-512")

# 加载图片
image = Image.open("street.jpg")

# 预处理
inputs = feature_extractor(images=image, return_tensors="pt")

# 预测
with torch.no_grad():
    outputs = model(**inputs)

# 后处理
logits = outputs.logits
upsampled_logits = torch.nn.functional.interpolate(
    logits,
    size=image.size[::-1],
    mode="bilinear",
    align_corners=False
)

# 获取分割结果
pred_seg = upsampled_logits.argmax(dim=1)[0]

# 可视化
import matplotlib.pyplot as plt
plt.imshow(pred_seg)
plt.show()

from diffusers import StableDiffusionPipeline
import torch

# 加载模型
model_id = "runwayml/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16)
pipe = pipe.to("cuda")

# 生成图片
prompt = "a beautiful landscape with mountains and a lake, sunset, photorealistic"
image = pipe(prompt).images[0]

# 保存
image.save("generated_landscape.png")

# 图像编辑（Inpainting）
from diffusers import StableDiffusionInpaintPipeline

pipe = StableDiffusionInpaintPipeline.from_pretrained(
    "runwayml/stable-diffusion-inpainting",
    torch_dtype=torch.float16
)
pipe = pipe.to("cuda")

# 加载原图和蒙版
init_image = Image.open("photo.jpg")
mask_image = Image.open("mask.jpg")

# 修复/编辑
prompt = "a cat sitting on the couch"
image = pipe(prompt=prompt, image=init_image, mask_image=mask_image).images[0]
image.save("edited_photo.png")

import pandas as pd
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

# 协同过滤推荐
class CollaborativeFiltering:
    def __init__(self, ratings_df):
        # ratings_df: user_id, item_id, rating
        self.ratings = ratings_df
        self.user_item_matrix = ratings_df.pivot(
            index='user_id',
            columns='item_id',
            values='rating'
        ).fillna(0)
    
    def user_similarity(self):
        # 计算用户相似度
        return cosine_similarity(self.user_item_matrix)
    
    def item_similarity(self):
        # 计算物品相似度
        return cosine_similarity(self.user_item_matrix.T)
    
    def recommend_items(self, user_id, n=10):
        # 基于用户的协同过滤
        user_sim = self.user_similarity()
        user_idx = list(self.user_item_matrix.index).index(user_id)
        
        # 找到相似用户
        similar_users = user_sim[user_idx].argsort()[::-1][1:11]
        
        # 获取相似用户喜欢的物品
        recommendations = {}
        for sim_user_idx in similar_users:
            sim_user_id = self.user_item_matrix.index[sim_user_idx]
            sim_score = user_sim[user_idx][sim_user_idx]
            
            # 该用户评分过的物品
            rated_items = self.user_item_matrix.loc[sim_user_id]
            rated_items = rated_items[rated_items > 0]
            
            for item_id, rating in rated_items.items():
                if item_id not in recommendations:
                    recommendations[item_id] = 0
                recommendations[item_id] += rating * sim_score
        
        # 排序并返回top N
        recommendations = sorted(recommendations.items(), key=lambda x: x[1], reverse=True)
        return recommendations[:n]

# 使用示例
ratings = pd.DataFrame({
    'user_id': [1, 1, 1, 2, 2, 3, 3, 3],
    'item_id': ['A', 'B', 'C', 'A', 'C', 'B', 'C', 'D'],
    'rating': [5, 4, 3, 4, 5, 5, 4, 5]
})

cf = CollaborativeFiltering(ratings)
recommendations = cf.recommend_items(user_id=1, n=5)
print("推荐物品:", recommendations)

import torch
import torch.nn as nn

class NeuralCollaborativeFiltering(nn.Module):
    def __init__(self, num_users, num_items, embedding_dim=50):
        super().__init__()
        
        # 用户和物品嵌入
        self.user_embedding = nn.Embedding(num_users, embedding_dim)
        self.item_embedding = nn.Embedding(num_items, embedding_dim)
        
        # MLP层
        self.fc_layers = nn.Sequential(
            nn.Linear(embedding_dim * 2, 128),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(64, 32),
            nn.ReLU(),
            nn.Linear(32, 1)
        )
    
    def forward(self, user_ids, item_ids):
        user_embedded = self.user_embedding(user_ids)
        item_embedded = self.item_embedding(item_ids)
        
        # 拼接
        x = torch.cat([user_embedded, item_embedded], dim=-1)
        
        # 通过MLP
        output = self.fc_layers(x)
        
        return output.squeeze()

# 训练和使用
model = NeuralCollaborativeFiltering(num_users=1000, num_items=5000)
# ... 训练代码 ...

# 推荐
user_id = torch.tensor([123])
all_item_ids = torch.arange(5000)
scores = model(user_id.repeat(5000), all_item_ids)
top_items = scores.argsort(descending=True)[:10]

import whisper

# 加载模型
model = whisper.load_model("base")

# 转录音频
result = model.transcribe("audio.mp3", language="zh")

print("转录结果:", result["text"])

# 获取详细信息（包含时间戳）
for segment in result["segments"]:
    print(f"[{segment['start']:.2f}s - {segment['end']:.2f}s] {segment['text']}")

# 实时转录
import pyaudio
import numpy as np

def real_time_transcribe():
    audio = pyaudio.PyAudio()
    stream = audio.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=16000,
        input=True,
        frames_per_buffer=1024
    )
    
    print("开始录音...")
    
    while True:
        # 读取音频数据
        data = stream.read(4096)
        audio_array = np.frombuffer(data, dtype=np.int16).astype(np.float32) / 32768.0
        
        # 转录
        result = model.transcribe(audio_array)
        print(result["text"])

from TTS.api import TTS

# 加载模型
tts = TTS(model_name="tts_models/zh-CN/baker/tacotron2-DDC-GST")

# 生成语音
text = "你好，欢迎使用AI语音合成系统。"
tts.tts_to_file(text=text, file_path="output.wav")

# 多语言支持
tts_multilingual = TTS(model_name="tts_models/multilingual/multi-dataset/your_tts")

# 中文
tts_multilingual.tts_to_file(
    text="这是中文语音",
    file_path="chinese.wav",
    language="zh-cn"
)

# 英文
tts_multilingual.tts_to_file(
    text="This is English speech",
    file_path="english.wav",
    language="en"
)

import torch
from torchvision import models, transforms
from PIL import Image

class MedicalImageClassifier:
    def __init__(self, model_path, num_classes=2):
        # 加载预训练模型
        self.model = models.resnet50(pretrained=False)
        self.model.fc = torch.nn.Linear(self.model.fc.in_features, num_classes)
        self.model.load_state_dict(torch.load(model_path))
        self.model.eval()
        
        # 图像预处理
        self.transform = transforms.Compose([
            transforms.Resize((224, 224)),
            transforms.ToTensor(),
            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
        ])
    
    def predict(self, image_path):
        # 加载图像
        image = Image.open(image_path).convert('RGB')
        image_tensor = self.transform(image).unsqueeze(0)
        
        # 预测
        with torch.no_grad():
            output = self.model(image_tensor)
            probabilities = torch.nn.functional.softmax(output[0], dim=0)
        
        # 返回结果
        pred_class = probabilities.argmax().item()
        confidence = probabilities[pred_class].item()
        
        return {
            'class': 'abnormal' if pred_class == 1 else 'normal',
            'confidence': confidence,
            'probabilities': {
                'normal': probabilities[0].item(),
                'abnormal': probabilities[1].item()
            }
        }

# 使用
classifier = MedicalImageClassifier('lung_ct_model.pth')
result = classifier.predict('ct_scan.jpg')
print(f"诊断结果: {result['class']}, 置信度: {result['confidence']:.2%}")

from rdkit import Chem
from rdkit.Chem import Descriptors
import torch
import torch.nn as nn

class DrugPropertyPredictor(nn.Module):
    def __init__(self, input_dim=200):
        super().__init__()
        
        self.network = nn.Sequential(
            nn.Linear(input_dim, 256),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Linear(64, 1)
        )
    
    def forward(self, x):
        return self.network(x)

def smiles_to_features(smiles):
    """将SMILES字符串转换为分子特征"""
    mol = Chem.MolFromSmiles(smiles)
    
    features = [
        Descriptors.MolWt(mol),
        Descriptors.MolLogP(mol),
        Descriptors.NumHDonors(mol),
        Descriptors.NumHAcceptors(mol),
        Descriptors.TPSA(mol),
        # ... 更多特征
    ]
    
    return torch.tensor(features, dtype=torch.float32)

# 预测药物溶解度
model = DrugPropertyPredictor()
# ... 加载训练好的模型 ...

smiles = "CC(=O)OC1=CC=CC=C1C(=O)O"  # 阿司匹林
features = smiles_to_features(smiles)
solubility = model(features)
print(f"预测溶解度: {solubility.item():.2f}")

from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.chains import LLMChain

class MedicalConsultationBot:
    def __init__(self):
        self.llm = ChatOpenAI(temperature=0.3, model="gpt-4")
        
        self.system_prompt = """你是一位专业的医疗咨询助手。
        请根据患者的症状描述，提供初步的分析和建议。
        注意：
        1. 不要做出确诊，建议患者就医
        2. 提供可能的疾病方向
        3. 给出生活建议和注意事项
        4. 如果是紧急情况，立即建议就医
        """
    
    def consult(self, symptoms):
        prompt = ChatPromptTemplate.from_messages([
            ("system", self.system_prompt),
            ("human", "患者症状：{symptoms}\n请提供咨询建议。")
        ])
        
        chain = LLMChain(llm=self.llm, prompt=prompt)
        response = chain.run(symptoms=symptoms)
        
        return response

# 使用
bot = MedicalConsultationBot()
symptoms = "持续咳嗽3天，伴有发热38.5度，喉咙痛"
advice = bot.consult(symptoms)
print(advice)

import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score, classification_report

class CreditScoreModel:
    def __init__(self):
        self.model = GradientBoostingClassifier(
            n_estimators=100,
            learning_rate=0.1,
            max_depth=5,
            random_state=42
        )
    
    def preprocess_features(self, df):
        """特征工程"""
        features = df.copy()
        
        # 收入负债比
        features['debt_to_income'] = features['debt'] / features['income']
        
        # 信用历史长度
        features['credit_history_months'] = (
            pd.to_datetime('today') - pd.to_datetime(features['first_credit_date'])
        ).dt.days / 30
        
        # 信用利用率
        features['credit_utilization'] = features['credit_used'] / features['credit_limit']
        
        # 逾期次数
        features['total_delinquencies'] = (
            features['delinquencies_2y'] + 
            features['delinquencies_1y'] * 2  # 近期逾期权重更高
        )
        
        return features
    
    def train(self, X_train, y_train):
        """训练模型"""
        self.model.fit(X_train, y_train)
    
    def predict_proba(self, X):
        """预测违约概率"""
        return self.model.predict_proba(X)[:, 1]
    
    def get_credit_score(self, default_prob):
        """将违约概率转换为信用分数（300-850）"""
        # 违约概率越低，信用分数越高
        score = 850 - (default_prob * 550)
        return np.clip(score, 300, 850)
    
    def evaluate(self, X_test, y_test):
        """评估模型"""
        y_pred_proba = self.predict_proba(X_test)
        auc = roc_auc_score(y_test, y_pred_proba)
        
        y_pred = (y_pred_proba > 0.5).astype(int)
        report = classification_report(y_test, y_pred)
        
        return {
            'auc': auc,
            'classification_report': report
        }

# 使用示例
# 加载数据
df = pd.read_csv('credit_data.csv')

# 特征工程
model = CreditScoreModel()
features = model.preprocess_features(df)

# 选择特征
feature_cols = ['income', 'debt_to_income', 'credit_history_months', 
                'credit_utilization', 'total_delinquencies']
X = features[feature_cols]
y = features['default']

# 训练
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
model.train(X_train, y_train)

# 评估
results = model.evaluate(X_test, y_test)
print(f"AUC: {results['auc']:.4f}")

# 预测新客户
new_customer = pd.DataFrame({
    'income': [50000],
    'debt_to_income': [0.3],
    'credit_history_months': [60],
    'credit_utilization': [0.4],
    'total_delinquencies': [0]
})

default_prob = model.predict_proba(new_customer)[0]
credit_score = model.get_credit_score(default_prob)

print(f"违约概率: {default_prob:.2%}")
print(f"信用分数: {credit_score:.0f}")

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
import torch
import torch.nn as nn

class PortfolioOptimizer:
    def __init__(self, risk_tolerance='moderate'):
        self.risk_tolerance = risk_tolerance
        self.risk_levels = {
            'conservative': 0.3,
            'moderate': 0.5,
            'aggressive': 0.7
        }
    
    def calculate_optimal_portfolio(self, returns, cov_matrix):
        """计算最优投资组合（马科维茨模型）"""
        n_assets = len(returns)
        
        # 目标风险水平
        target_risk = self.risk_levels[self.risk_tolerance]
        
        # 使用优化算法求解
        from scipy.optimize import minimize
        
        def portfolio_variance(weights):
            return np.dot(weights.T, np.dot(cov_matrix, weights))
        
        def portfolio_return(weights):
            return np.dot(weights, returns)
        
        # 约束条件
        constraints = [
            {'type': 'eq', 'fun': lambda x: np.sum(x) - 1},  # 权重和为1
            {'type': 'ineq', 'fun': lambda x: target_risk - portfolio_variance(x)}  # 风险约束
        ]
        
        # 边界条件（每个资产0-40%）
        bounds = tuple((0, 0.4) for _ in range(n_assets))
        
        # 初始权重
        init_weights = np.array([1/n_assets] * n_assets)
        
        # 优化
        result = minimize(
            lambda w: -portfolio_return(w),  # 最大化收益
            init_weights,
            method='SLSQP',
            bounds=bounds,
            constraints=constraints
        )
        
        return result.x
    
    def generate_recommendation(self, user_profile, market_data):
        """生成投资建议"""
        # 计算各资产的预期收益和协方差
        returns = market_data.mean()
        cov_matrix = market_data.cov()
        
        # 计算最优配置
        optimal_weights = self.calculate_optimal_portfolio(returns, cov_matrix)
        
        # 生成建议
        recommendations = []
        for asset, weight in zip(market_data.columns, optimal_weights):
            if weight > 0.01:  # 只推荐权重>1%的资产
                recommendations.append({
                    'asset': asset,
                    'allocation': f"{weight*100:.1f}%",
                    'amount': user_profile['investment_amount'] * weight
                })
        
        return recommendations

# 使用示例
# 加载市场数据
market_data = pd.read_csv('market_returns.csv', index_col='date', parse_dates=True)

# 用户画像
user_profile = {
    'age': 35,
    'investment_amount': 100000,
    'risk_tolerance': 'moderate',
    'investment_horizon': 5  # 年
}

# 生成建议
optimizer = PortfolioOptimizer(risk_tolerance=user_profile['risk_tolerance'])
recommendations = optimizer.generate_recommendation(user_profile, market_data)

print("投资建议：")
for rec in recommendations:
    print(f"{rec['asset']}: {rec['allocation']} (¥{rec['amount']:.2f})")

import pandas as pd
import numpy as np
import torch
import torch.nn as nn

class TradingStrategy(nn.Module):
    def __init__(self, input_dim, hidden_dim=128):
        super().__init__()
        
        self.lstm = nn.LSTM(input_dim, hidden_dim, num_layers=2, batch_first=True)
        self.fc = nn.Sequential(
            nn.Linear(hidden_dim, 64),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(64, 3)  # 买入、持有、卖出
        )
    
    def forward(self, x):
        lstm_out, _ = self.lstm(x)
        last_output = lstm_out[:, -1, :]
        action_probs = self.fc(last_output)
        return torch.softmax(action_probs, dim=1)

class BacktestEngine:
    def __init__(self, initial_capital=100000):
        self.initial_capital = initial_capital
        self.capital = initial_capital
        self.position = 0
        self.trades = []
    
    def execute_trade(self, action, price, date):
        """执行交易"""
        if action == 'buy' and self.capital > price:
            # 买入
            shares = int(self.capital * 0.95 / price)  # 保留5%现金
            cost = shares * price
            self.capital -= cost
            self.position += shares
            self.trades.append({
                'date': date,
                'action': 'buy',
                'price': price,
                'shares': shares,
                'cost': cost
            })
        
        elif action == 'sell' and self.position > 0:
            # 卖出
            revenue = self.position * price
            self.capital += revenue
            self.trades.append({
                'date': date,
                'action': 'sell',
                'price': price,
                'shares': self.position,
                'revenue': revenue
            })
            self.position = 0
    
    def get_portfolio_value(self, current_price):
        """计算当前组合价值"""
        return self.capital + self.position * current_price
    
    def calculate_metrics(self, prices):
        """计算回测指标"""
        final_value = self.get_portfolio_value(prices.iloc[-1])
        total_return = (final_value - self.initial_capital) / self.initial_capital
        
        # 计算夏普比率
        returns = pd.Series([t.get('revenue', 0) - t.get('cost', 0) 
                            for t in self.trades])
        sharpe_ratio = returns.mean() / returns.std() * np.sqrt(252) if len(returns) > 0 else 0
        
        return {
            'final_value': final_value,
            'total_return': total_return,
            'sharpe_ratio': sharpe_ratio,
            'num_trades': len(self.trades)
        }

# 使用示例
# 加载数据
data = pd.read_csv('stock_data.csv', index_col='date', parse_dates=True)

# 准备特征
features = ['open', 'high', 'low', 'close', 'volume']
X = data[features].values

# 加载训练好的模型
model = TradingStrategy(input_dim=len(features))
# model.load_state_dict(torch.load('trading_model.pth'))
model.eval()

# 回测
backtest = BacktestEngine(initial_capital=100000)

for i in range(30, len(data)):
    # 准备输入（过去30天）
    input_data = torch.FloatTensor(X[i-30:i]).unsqueeze(0)
    
    # 预测
    with torch.no_grad():
        action_probs = model(input_data)
        action_idx = action_probs.argmax().item()
    
    # 执行交易
    actions = ['buy', 'hold', 'sell']
    action = actions[action_idx]
    
    if action != 'hold':
        backtest.execute_trade(action, data['close'].iloc[i], data.index[i])

# 计算结果
metrics = backtest.calculate_metrics(data['close'])
print(f"最终价值: ¥{metrics['final_value']:.2f}")
print(f"总收益率: {metrics['total_return']:.2%}")
print(f"夏普比率: {metrics['sharpe_ratio']:.2f}")
print(f"交易次数: {metrics['num_trades']}")

from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.chains import LLMChain

class AITutor:
    def __init__(self, subject='数学'):
        self.subject = subject
        self.llm = ChatOpenAI(temperature=0.7, model="gpt-4")
        self.conversation_history = []
    
    def explain_concept(self, concept, student_level='middle_school'):
        """解释知识点"""
        prompt = ChatPromptTemplate.from_messages([
            ("system", f"""你是一位{self.subject}老师，擅长用简单易懂的方式讲解概念。
            学生水平：{student_level}
            请用通俗的语言、生动的例子来解释概念。"""),
            ("human", "请解释：{concept}")
        ])
        
        chain = LLMChain(llm=self.llm, prompt=prompt)
        explanation = chain.run(concept=concept)
        
        return explanation
    
    def check_homework(self, question, student_answer, correct_answer):
        """批改作业"""
        prompt = ChatPromptTemplate.from_messages([
            ("system", "你是一位{subject}老师，正在批改学生作业。"),
            ("human", """题目：{question}
            学生答案：{student_answer}
            正确答案：{correct_answer}
            
            请：
            1. 判断学生答案是否正确
            2. 如果错误，指出错在哪里
            3. 给出详细的解题步骤
            4. 提供类似的练习题""")
        ])
        
        chain = LLMChain(llm=self.llm, prompt=prompt)
        feedback = chain.run(
            subject=self.subject,
            question=question,
            student_answer=student_answer,
            correct_answer=correct_answer
        )
        
        return feedback
    
    def generate_practice_problems(self, topic, difficulty, num_problems=5):
        """生成练习题"""
        prompt = ChatPromptTemplate.from_messages([
            ("system", "你是一位{subject}老师，正在出练习题。"),
            ("human", """主题：{topic}
            难度：{difficulty}
            数量：{num_problems}
            
            请生成练习题，包括：
            1. 题目
            2. 答案
            3. 解题步骤""")
        ])
        
        chain = LLMChain(llm=self.llm, prompt=prompt)
        problems = chain.run(
            subject=self.subject,
            topic=topic,
            difficulty=difficulty,
            num_problems=num_problems
        )
        
        return problems
    
    def adaptive_learning_path(self, student_profile, test_results):
        """生成个性化学习路径"""
        # 分析学生薄弱环节
        weak_points = self._analyze_weak_points(test_results)
        
        # 生成学习计划
        prompt = ChatPromptTemplate.from_messages([
            ("system", "你是一位教育专家，擅长制定个性化学习计划。"),
            ("human", """学生情况：
            年级：{grade}
            当前水平：{level}
            薄弱环节：{weak_points}
            学习目标：{goal}
            可用时间：每天{daily_hours}小时
            
            请制定一个月的学习计划，包括：
            1. 每周学习重点
            2. 具体学习内容
            3. 练习建议
            4. 检测方式""")
        ])
        
        chain = LLMChain(llm=self.llm, prompt=prompt)
        learning_path = chain.run(
            grade=student_profile['grade'],
            level=student_profile['level'],
            weak_points=', '.join(weak_points),
            goal=student_profile['goal'],
            daily_hours=student_profile['daily_hours']
        )
        
        return learning_path
    
    def _analyze_weak_points(self, test_results):
        """分析薄弱环节"""
        weak_points = []
        for topic, score in test_results.items():
            if score < 60:
                weak_points.append(topic)
        return weak_points

# 使用示例
tutor = AITutor(subject='数学')

# 1. 解释概念
explanation = tutor.explain_concept('二次函数', student_level='middle_school')
print("知识点讲解：")
print(explanation)

# 2. 批改作业
feedback = tutor.check_homework(
    question="解方程：x² - 5x + 6 = 0",
    student_answer="x = 2",
    correct_answer="x = 2 或 x = 3"
)
print("\n作业批改：")
print(feedback)

# 3. 生成练习题
problems = tutor.generate_practice_problems(
    topic='一元二次方程',
    difficulty='中等',
    num_problems=3
)
print("\n练习题：")
print(problems)

# 4. 个性化学习路径
student_profile = {
    'grade': '初三',
    'level': '中等',
    'goal': '中考数学110分以上',
    'daily_hours': 2
}

test_results = {
    '代数': 75,
    '几何': 55,
    '函数': 60,
    '概率统计': 80
}

learning_path = tutor.adaptive_learning_path(student_profile, test_results)
print("\n学习计划：")
print(learning_path)

from transformers import pipeline
import torch

class EssayGrader:
    def __init__(self):
        # 加载模型
        self.sentiment_analyzer = pipeline('sentiment-analysis')
        self.grammar_checker = pipeline('text-classification', 
                                        model='textattack/roberta-base-CoLA')
    
    def grade_essay(self, essay):
        """批改作文"""
        # 1. 基础分析
        word_count = len(essay.split())
        sentence_count = essay.count('.') + essay.count('!') + essay.count('?')
        
        # 2. 语法检查
        sentences = essay.split('.')
        grammar_scores = []
        grammar_errors = []
        
        for i, sentence in enumerate(sentences):
            if sentence.strip():
                result = self.grammar_checker(sentence)[0]
                grammar_scores.append(result['score'])
                if result['label'] == 'unacceptable':
                    grammar_errors.append({
                        'sentence_num': i + 1,
                        'sentence': sentence,
                        'score': result['score']
                    })
        
        # 3. 内容分析
        content_score = self._analyze_content(essay)
        
        # 4. 结构分析
        structure_score = self._analyze_structure(essay)
        
        # 5. 综合评分
        grammar_score = sum(grammar_scores) / len(grammar_scores) * 100 if grammar_scores else 0
        
        total_score = (
            content_score * 0.4 +
            structure_score * 0.3 +
            grammar_score * 0.3
        )
        
        # 6. 生成反馈
        feedback = self._generate_feedback(
            total_score,
            content_score,
            structure_score,
            grammar_score,
            grammar_errors,
            word_count
        )
        
        return {
            'total_score': total_score,
            'content_score': content_score,
            'structure_score': structure_score,
            'grammar_score': grammar_score,
            'word_count': word_count,
            'sentence_count': sentence_count,
            'grammar_errors': grammar_errors,
            'feedback': feedback
        }
    
    def _analyze_content(self, essay):
        """分析内容质量"""
        # 简化版：基于长度和多样性
        words = essay.split()
        unique_words = len(set(words))
        diversity = unique_words / len(words) if words else 0
        
        # 长度分数（500-800字为最佳）
        word_count = len(words)
        if 500 <= word_count <= 800:
            length_score = 100
        elif word_count < 500:
            length_score = (word_count / 500) * 100
        else:
            length_score = max(60, 100 - (word_count - 800) / 10)
        
        # 多样性分数
        diversity_score = min(diversity * 200, 100)
        
        return (length_score + diversity_score) / 2
    
    def _analyze_structure(self, essay):
        """分析文章结构"""
        paragraphs = essay.split('\n\n')
        num_paragraphs = len([p for p in paragraphs if p.strip()])
        
        # 理想段落数：3-5段
        if 3 <= num_paragraphs <= 5:
            return 100
        elif num_paragraphs < 3:
            return num_paragraphs / 3 * 100
        else:
            return max(60, 100 - (num_paragraphs - 5) * 10)
    
    def _generate_feedback(self, total_score, content_score, structure_score, 
                          grammar_score, grammar_errors, word_count):
        """生成反馈"""
        feedback = []
        
        # 总体评价
        if total_score >= 90:
            feedback.append("优秀！文章整体质量很高。")
        elif total_score >= 80:
            feedback.append("良好，还有提升空间。")
        elif total_score >= 70:
            feedback.append("中等水平，需要加强练习。")
        else:
            feedback.append("需要大幅改进。")
        
        # 内容反馈
        if content_score < 70:
            feedback.append(f"内容需要丰富，当前字数{word_count}，建议500-800字。")
        
        # 结构反馈
        if structure_score < 70:
            feedback.append("文章结构需要优化，建议分3-5段。")
        
        # 语法反馈
        if grammar_errors:
            feedback.append(f"发现{len(grammar_errors)}处语法问题：")
            for error in grammar_errors[:3]:  # 只显示前3个
                feedback.append(f"  - 第{error['sentence_num']}句：{error['sentence'][:50]}...")
        
        return '\n'.join(feedback)

# 使用示例
grader = EssayGrader()

essay = """
人工智能正在改变我们的生活。从智能手机到自动驾驶汽车，AI技术无处不在。

在医疗领域，AI帮助医生诊断疾病，提高了诊断准确率。在教育领域，AI提供个性化学习方案。

然而，AI也带来了一些挑战，如隐私问题和就业影响。我们需要在发展AI的同时，关注这些问题。

总之，AI是一把双刃剑，我们应该合理利用它，让它更好地服务人类。
"""

result = grader.grade_essay(essay)
print(f"总分: {result['total_score']:.1f}")
print(f"内容: {result['content_score']:.1f}")
print(f"结构: {result['structure_score']:.1f}")
print(f"语法: {result['grammar_score']:.1f}")
print(f"\n反馈:\n{result['feedback']}")