# 用户报告：http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html
# 示例代码中缺少 import
LogisticRegression(random_state=0).fit(X, y)  # NameError: X 和 y 没有定义

# 在 docstring 开头增加 import 和 mock 数据
"""
>>> from sklearn.linear_model import LogisticRegression
>>> from sklearn.datasets import make_classification
>>> X, y = make_classification(n_features=4, random_state=0)
>>> LogisticRegression(random_state=0).fit(X, y)
"""

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

train = pd.read_csv('train.csv')
test  = pd.read_csv('test.csv')

print(train.shape)   # (891, 12)
print(train.columns)

train.isnull().sum()

print(train['Survived'].value_counts(normalize=True))

train.groupby('Sex')['Survived'].mean()

train.groupby('Pclass')['Survived'].mean()

# 儿童幸存率远高于成人
train[train['Age'] < 12]['Survived'].mean()   # ~0.60
train[train['Age'] > 60]['Survived'].mean()   # ~0.27

# 按性别+等级分组，用中位数填充年龄
train['Age'] = train.groupby(['Sex', 'Pclass'])['Age'].transform(
    lambda x: x.fillna(x.median()))

# 分箱：把年龄分成 5 段
train['AgeBin'] = pd.cut(train['Age'],
    bins=[0, 12, 30, 50, 80],
    labels=['Child', 'Young', 'Middle', 'Elderly'])

train['FamilySize'] = train['SibSp'] + train['Parch'] + 1  # +1 是自己

# 单人和超大家庭幸存率低，2-4 人家庭幸存率高
train['IsAlone'] = (train['FamilySize'] == 1).astype(int)

# Mr/Mrs/Miss/Dr/Reverend/...
train['Title'] = train['Name'].str.extract(r'([A-Za-z]+)\.', expand=False)

# 合并稀有称谓
rare_titles = ['Lady', 'Countess','Capt', 'Col','Don', 'Dr',
               'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona']
train['Title'] = train['Title'].replace(rare_titles, 'Rare')
train['Title'] = train['Title'].replace({'Mlle': 'Miss', 'Ms': 'Miss', 'Mme': 'Mrs'})

train['FareBin'] = pd.qcut(train['Fare'], 4,
    labels=['Low', 'Medium', 'High', 'VeryHigh'])

from sklearn.preprocessing import LabelEncoder

for col in ['Sex', 'Title', 'AgeBin', 'FareBin', 'Embarked']:
    train[col] = LabelEncoder().fit_transform(train[col].astype(str))

from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score, StratifiedKFold
from sklearn.metrics import accuracy_score

features = ['Pclass', 'Sex', 'Age', 'Fare', 'Embarked',
            'FamilySize', 'IsAlone', 'Title', 'AgeBin', 'FareBin']
X = train[features]
y = train['Survived']

kfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

models = {
    'Logistic Regression': LogisticRegression(max_iter=1000),
    'Random Forest': RandomForestClassifier(n_estimators=200, random_state=42),
    'Gradient Boosting': GradientBoostingClassifier(n_estimators=200, random_state=42),
}

for name, model in models.items():
    scores = cross_val_score(model, X, y, cv=kfold, scoring='accuracy')
    print(f"{name:25s}: {scores.mean():.4f} (+/- {scores.std():.4f})")

from sklearn.ensemble import VotingClassifier

voting = VotingClassifier([
    ('lr', LogisticRegression(max_iter=1000)),
    ('rf', RandomForestClassifier(n_estimators=200, random_state=42)),
    ('gb', GradientBoostingClassifier(n_estimators=200, random_state=42)),
], voting='soft')

scores = cross_val_score(voting, X, y, cv=kfold, scoring='accuracy')
print(f"Voting Ensemble: {scores.mean():.4f} (+/- {scores.std():.4f})")

from sklearn.ensemble import StackingClassifier

stacking = StackingClassifier([
    ('lr', LogisticRegression(max_iter=1000)),
    ('rf', RandomForestClassifier(n_estimators=200, random_state=42)),
    ('gb', GradientBoostingClassifier(n_estimators=200, random_state=42)),
], final_estimator=LogisticRegression(), cv=5)

scores = cross_val_score(stacking, X, y, cv=kfold, scoring='accuracy')
print(f"Stacking Ensemble: {scores.mean():.4f} (+/- {scores.std():.4f})")

# 对测试集做同样的特征工程
# ...（同训练集的预处理流程，注意用训练集统计量填充）

predictions = voting.predict(test[features])

submission = pd.DataFrame({
    'PassengerId': test['PassengerId'],
    'Survived': predictions
})
submission.to_csv('submission.csv', index=False)
print(submission.head())

# 如果 5 折 CV 的方差 > 0.03，说明特征不稳定
# 解决办法：检查是否有泄漏特征或数据分布不一致

# Fare 有一个 512 的极端值
train['Fare'] = train['Fare'].clip(upper=200)

train['Deck'] = train['Cabin'].str[0]
# A/B/C/D/E 是高等级甲板 → 幸存率更高

import xgboost as xgb

xgb_model = xgb.XGBClassifier(
    n_estimators=500,
    max_depth=4,
    learning_rate=0.05,
    subsample=0.8,
    colsample_bytree=0.8,
    random_state=42
)

"""titanic.py - Kaggle Titanic 生存预测"""
import pandas as pd
import numpy as np
from sklearn.ensemble import VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.preprocessing import LabelEncoder

# 1. 加载
train = pd.read_csv('train.csv')
test  = pd.read_csv('test.csv')
ids = test['PassengerId']

# 2. 合并预处理（统一处理 train + test）
all_data = pd.concat([train, test], keys=['train', 'test'], names=['source']).reset_index(level='source')

# 3. 特征工程
all_data['Age'] = all_data.groupby(['Sex', 'Pclass'])['Age'].transform(lambda x: x.fillna(x.median()))
all_data['Embarked'] = all_data['Embarked'].fillna('S')
all_data['Fare'] = all_data['Fare'].fillna(all_data['Fare'].median())
all_data['FamilySize'] = all_data['SibSp'] + all_data['Parch'] + 1
all_data['IsAlone'] = (all_data['FamilySize'] == 1).astype(int)
all_data['Title'] = all_data['Name'].str.extract(r'([A-Za-z]+)\.', expand=False)
rare = ['Lady', 'Countess','Capt', 'Col','Don', 'Dr','Major', 'Rev', 'Sir', 'Jonkheer', 'Dona']
all_data['Title'] = all_data['Title'].replace(rare, 'Rare')
all_data['Title'] = all_data['Title'].replace({'Mlle':'Miss', 'Ms':'Miss', 'Mme':'Mrs'})
all_data['AgeBin'] = pd.cut(all_data['Age'], bins=[0,12,30,50,80], labels=['Child','Young','Middle','Elderly'])
all_data['FareBin'] = pd.qcut(all_data['Fare'], 4, labels=['Low','Medium','High','VeryHigh'])

# 4. 编码
for col in ['Sex', 'Title', 'AgeBin', 'FareBin', 'Embarked']:
    all_data[col] = LabelEncoder().fit_transform(all_data[col].astype(str))

# 5. 拆分
features = ['Pclass','Sex','Age','Fare','Embarked','FamilySize','IsAlone','Title','AgeBin','FareBin']
X_train = all_data[all_data['source']=='train'][features]
y_train = train['Survived']
X_test  = all_data[all_data['source']=='test'][features]

# 6. 模型
model = VotingClassifier([
    ('lr', LogisticRegression(max_iter=1000)),
    ('rf', RandomForestClassifier(n_estimators=200, random_state=42)),
    ('gb', GradientBoostingClassifier(n_estimators=200, random_state=42)),
], voting='soft')
model.fit(X_train, y_train)

# 7. 预测 & 提交
preds = model.predict(X_test)
pd.DataFrame({'PassengerId': ids, 'Survived': preds}).to_csv('submission.csv', index=False)
print("submission.csv created ✅")

import ultralytics
ultralytics.checks()

from ultralytics import YOLO

# 下载预训练模型并推理
model = YOLO('yolov8n.pt')  # 自动下载，6.2MB
results = model('https://ultralytics.com/images/bus.jpg')

# 显示结果
results[0].show()

# Roboflow 一键下载（需要 API key）
from roboflow import Roboflow
rf = Roboflow(api_key="YOUR_KEY")
project = rf.workspace("roboflow-58fyf").project("face-mask-detection")
dataset = project.version(1).download("yolov8")

from ultralytics import YOLO

model = YOLO('yolov8s.pt')  # 从 COCO 预训练权重开始

results = model.train(
    data='datasets/face-mask-detection-1/data.yaml',
    epochs=50,
    imgsz=640,
    batch=16,
    patience=10,            # 10 轮没有提升自动停止
    lr0=0.01,               # 初始学习率
    augment=True,           # 启用数据增强
    cache=True,             # 缓存图片到 RAM 加速
)

metrics = model.val()
print(f"mAP@50: {metrics.box.map50:.3f}")     # 平均精度
print(f"mAP@50-95: {metrics.box.map:.3f}")    # 严格版 mAP
print(f"Precision: {metrics.box.mp:.3f}")      # 精确率
print(f"Recall: {metrics.box.mr:.3f}")          # 召回率

from ultralytics import YOLO

model = YOLO('runs/detect/train/weights/best.pt')

# 调用摄像头
results = model.predict(source=0, show=True, conf=0.5)

results = model.predict(
    source='test_video.mp4',
    save=True,              # 保存标注后的视频
    conf=0.5,               # 置信度阈值
    iou=0.5,                # NMS IoU 阈值（重叠度高时保留哪个框）
    line_width=2,
    show_labels=True,
)

model = YOLO('runs/detect/train/weights/best.pt')

model.export(format='onnx')           # ONNX：通用格式，可部署到任何推理框架
model.export(format='tflite')         # TFLite：Android / 树莓派
model.export(format='ncnn')           # NCNN：手机端（骁龙/联发科NPU加速）
model.export(format='tensorrt')       # TensorRT：NVIDIA GPU 加速（3-5倍提速）
model.export(format='openvino')       # OpenVINO：Intel CPU / 神经计算棒

model.train(imgsz=1280, ...)  # 更大的输入尺寸 → 小目标特征更明显

model.train(
    cls_pw=1.0,          # 类别权重，>1 增加少样本类别的 loss
    ...
)

"""yolo_train.py - YOLOv8 目标检测训练"""
from ultralytics import YOLO

# 1. 加载预训练模型
model = YOLO('yolov8s.pt')

# 2. 训练
results = model.train(
    data='datasets/face-mask-detection-1/data.yaml',
    epochs=50,
    imgsz=640,
    batch=16,
    patience=10,
    lr0=0.01,
    augment=True,
    cache=True,
)

# 3. 验证
metrics = model.val()
print(f"Precision: {metrics.box.mp:.3f}")
print(f"Recall: {metrics.box.mr:.3f}")
print(f"mAP@50: {metrics.box.map50:.3f}")

# 4. 导出
model.export(format='onnx')

# 5. 测试推理
results = model.predict(
    source='test_images/',
    save=True,
    conf=0.5,
    iou=0.5,
)

from torch.utils.data import Dataset, DataLoader
import torch
from torch import nn
import re
from collections import Counter
import numpy as np

# 用 torchtext 加载
from torchtext.datasets import IMDB

train_iter, test_iter = IMDB(split=('train', 'test'))

# 看一眼数据
for i, (label, text) in enumerate(train_iter):
    print(f"标签: {'正面' if label == 2 else '负面'}")
    print(f"文本: {text[:200]}...")
    if i == 0: break

def tokenize(text):
    """简单分词：转小写，去标点"""
    text = text.lower()
    text = re.sub(r'[^a-z\s]', '', text)
    return text.split()

# 统计词频，保留最常见的 10,000 个词
counter = Counter()
for label, text in train_iter:
    counter.update(tokenize(text))

vocab = ['<PAD>', '<UNK>'] + [word for word, _ in counter.most_common(10000)]
word2idx = {word: i for i, word in enumerate(vocab)}

def bow_vectorize(text, vocab_size):
    vec = np.zeros(vocab_size, dtype=np.float32)
    for word in tokenize(text):
        idx = word2idx.get(word, 1)  # 1 = <UNK>
        vec[idx] += 1
    return vec

class BOWClassifier(nn.Module):
    def __init__(self, vocab_size, hidden=128):
        super().__init__()
        self.fc1 = nn.Linear(vocab_size, hidden)
        self.fc2 = nn.Linear(hidden, 2)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        return self.fc2(x)

class IMDBDataset(Dataset):
    def __init__(self, data_iter, word2idx, max_len=200):
        self.data = []
        for label, text in data_iter:
            tokens = tokenize(text)
            indices = [word2idx.get(w, 1) for w in tokens[:max_len]]
            if len(indices) < max_len:
                indices += [0] * (max_len - len(indices))
            self.data.append((torch.tensor(indices, dtype=torch.long),
                              torch.tensor(1 if label == 2 else 0, dtype=torch.long)))
    def __len__(self): return len(self.data)
    def __getitem__(self, i): return self.data[i]

train_dataset = IMDBDataset(train_iter, word2idx)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

class LSTMClassifier(nn.Module):
    def __init__(self, vocab_size, embed_dim=100, hidden_dim=128, num_layers=2):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
        self.lstm = nn.LSTM(embed_dim, hidden_dim, num_layers,
                           batch_first=True, dropout=0.3, bidirectional=True)
        self.fc = nn.Linear(hidden_dim * 2, 2)  # *2 因为双向
        self.dropout = nn.Dropout(0.3)

    def forward(self, x):
        x = self.embedding(x)
        _, (hidden, _) = self.lstm(x)
        h = torch.cat((hidden[-2], hidden[-1]), dim=1)
        h = self.dropout(torch.relu(h))
        return self.fc(h)

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = LSTMClassifier(len(vocab)).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

for epoch in range(1, 6):
    model.train()
    total_loss = 0
    for inputs, labels in train_loader:
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    print(f"Epoch {epoch}: loss={total_loss/len(train_loader):.4f}")

from transformers import BertTokenizer, BertForSequenceClassification

model_name = 'bert-base-uncased'
tokenizer = BertTokenizer.from_pretrained(model_name)
model = BertForSequenceClassification.from_pretrained(model_name, num_labels=2)

class BERTDataset(Dataset):
    def __init__(self, data_iter, tokenizer, max_len=256):
        self.input_ids = []
        self.attention_masks = []
        self.labels = []
        for label, text in data_iter:
            encoded = tokenizer(
                text,
                truncation=True,
                padding='max_length',
                max_length=max_len,
                return_tensors='pt'
            )
            self.input_ids.append(encoded['input_ids'][0])
            self.attention_masks.append(encoded['attention_mask'][0])
            self.labels.append(1 if label == 2 else 0)
    def __len__(self): return len(self.input_ids)
    def __getitem__(self, i):
        return {
            'input_ids': self.input_ids[i],
            'attention_mask': self.attention_masks[i],
            'labels': torch.tensor(self.labels[i], dtype=torch.long)
        }

train_dataset = BERTDataset(train_iter, tokenizer)
train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)

from transformers import AdamW

device = torch.device('cuda')
model.to(device)
optimizer = AdamW(model.parameters(), lr=2e-5)  # 必须用很小的学习率

for epoch in range(1, 4):  # BERT 微调 3 轮就能收敛
    model.train()
    total_loss = 0
    for batch in train_loader:
        batch = {k: v.to(device) for k, v in batch.items()}
        optimizer.zero_grad()
        outputs = model(**batch)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    print(f"Epoch {epoch}: loss={total_loss/len(train_loader):.4f}")

"""sentiment_lstm.py - LSTM 情感分析"""
import torch, re
from torch import nn
from torch.utils.data import Dataset, DataLoader
from torchtext.datasets import IMDB
from collections import Counter

def tokenize(text):
    text = text.lower()
    text = re.sub(r'[^a-z\s]', '', text)
    return text.split()

counter = Counter()
for label, text in IMDB(split='train'):
    counter.update(tokenize(text))
vocab = ['<PAD>', '<UNK>'] + [w for w, _ in counter.most_common(10000)]
word2idx = {w: i for i, w in enumerate(vocab)}

class IMDBDataset(Dataset):
    def __init__(self, split, word2idx, max_len=200):
        self.data = []
        for label, text in IMDB(split=split):
            indices = [word2idx.get(w, 1) for w in tokenize(text)[:max_len]]
            if len(indices) < max_len:
                indices += [0] * (max_len - len(indices))
            self.data.append((torch.tensor(indices, dtype=torch.long),
                              torch.tensor(1 if label == 2 else 0, dtype=torch.long)))
    def __len__(self): return len(self.data)
    def __getitem__(self, i): return self.data[i]

train_loader = DataLoader(IMDBDataset('train', word2idx), batch_size=64, shuffle=True)
test_loader  = DataLoader(IMDBDataset('test', word2idx), batch_size=256, shuffle=False)

class LSTMClassifier(nn.Module):
    def __init__(self, vocab_size, embed=100, hidden=128, num_layers=2):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed, padding_idx=0)
        self.lstm = nn.LSTM(embed, hidden, num_layers, batch_first=True,
                           dropout=0.3, bidirectional=True)
        self.fc = nn.Linear(hidden*2, 2)
        self.dropout = nn.Dropout(0.3)

    def forward(self, x):
        x = self.embedding(x)
        _, (h, _) = self.lstm(x)
        h = torch.cat((h[-2], h[-1]), dim=1)
        return self.fc(self.dropout(torch.relu(h)))

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = LSTMClassifier(len(vocab)).to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()

for epoch in range(1, 6):
    model.train()
    total = 0
    for inputs, labels in train_loader:
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        criterion(model(inputs), labels).backward()
        optimizer.step()
        total += criterion(model(inputs), labels).item()

    model.eval()
    correct = sum((model(x.to(device)).argmax(1) == y.to(device)).sum().item()
                  for x, y in test_loader)
    print(f"Epoch {epoch}: acc={correct/25000:.4f}")