# 创建独立环境
conda create -n dl-env python=3.11
conda activate dl-env

# 安装PyTorch（GPU版本，CUDA 12.1）
pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

# 验证安装
python -c "import torch; print('PyTorch版本:', torch.__version__); print('GPU可用:', torch.cuda.is_available())"

pip3 install torch torchvision torchaudio

pip install tensorflow
python -c "import tensorflow as tf; print('TensorFlow版本:', tf.__version__)"

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 1. 数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),  # 转换为张量，归一化到[0,1]
    transforms.Normalize((0.1307,), (0.3081,))  # MNIST数据集的均值和标准差
])

# 加载数据集
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)

train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)

# 2. 定义模型
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)  # 输入通道1，输出通道32
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
        self.pool = nn.MaxPool2d(2, 2)  # 2x2最大池化
        self.fc1 = nn.Linear(64 * 7 * 7, 128)  # 全连接层
        self.fc2 = nn.Linear(128, 10)  # 输出10个类别
        self.relu = nn.ReLU()
        self.dropout = nn.Dropout(0.25)  # 防止过拟合

    def forward(self, x):
        x = self.pool(self.relu(self.conv1(x)))  # 卷积->激活->池化
        x = self.pool(self.relu(self.conv2(x)))
        x = x.view(-1, 64 * 7 * 7)  # 展平
        x = self.relu(self.fc1(x))
        x = self.dropout(x)
        x = self.fc2(x)
        return x

# 3. 训练配置
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = CNN().to(device)
criterion = nn.CrossEntropyLoss()  # 交叉熵损失函数
optimizer = optim.Adam(model.parameters(), lr=0.001)  # Adam优化器

# 4. 训练循环
def train(model, device, train_loader, optimizer, epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()  # 梯度清零
        output = model(data)
        loss = criterion(output, target)
        loss.backward()  # 反向传播
        optimizer.step()  # 更新参数
        if batch_idx % 100 == 0:
            print(f'训练轮次: {epoch} [{batch_idx * len(data)}/{len(train_loader.dataset)} '
                  f'({100. * batch_idx / len(train_loader):.0f}%)]\t损失: {loss.item():.6f}')

# 5. 测试函数
def test(model, device, test_loader):
    model.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad():  # 测试时不需要计算梯度
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            test_loss += criterion(output, target).item()
            pred = output.argmax(dim=1, keepdim=True)  # 获取预测结果
            correct += pred.eq(target.view_as(pred)).sum().item()

    test_loss /= len(test_loader.dataset)
    print(f'\n测试集: 平均损失: {test_loss:.4f}, 准确率: {correct}/{len(test_loader.dataset)} '
          f'({100. * correct / len(test_loader.dataset):.2f}%)\n')

# 运行训练
for epoch in range(1, 6):
    train(model, device, train_loader, optimizer, epoch)
    test(model, device, test_loader)

# 保存模型
torch.save(model.state_dict(), "mnist_cnn.pth")

import torchvision.models as models

# 使用预训练的ResNet18模型（迁移学习）
model = models.resnet18(pretrained=True)
# 替换最后一层全连接层，适应10分类任务
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, 10)

# 数据增强（提高模型泛化能力）
train_transform = transforms.Compose([
    transforms.RandomCrop(32, padding=4),  # 随机裁剪
    transforms.RandomHorizontalFlip(),  # 随机水平翻转
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])

import torch
import torch.nn as nn
import numpy as np

# 1. 准备数据
with open("shakespeare.txt", "r", encoding="utf-8") as f:
    text = f.read()

chars = sorted(list(set(text)))
vocab_size = len(chars)
char_to_idx = {ch: i for i, ch in enumerate(chars)}
idx_to_char = {i: ch for i, ch in enumerate(chars)}

# 转换为索引序列
data = [char_to_idx[ch] for ch in text]
seq_length = 100
batch_size = 64

# 2. 定义LSTM模型
class LSTMGenerator(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim, num_layers):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.lstm = nn.LSTM(embed_dim, hidden_dim, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_dim, vocab_size)
        
    def forward(self, x, hidden=None):
        x = self.embedding(x)
        out, hidden = self.lstm(x, hidden)
        out = self.fc(out.reshape(out.size(0)*out.size(1), out.size(2)))
        return out, hidden

# 3. 生成文本函数
def generate_text(model, start_text, length=500, temperature=0.8):
    model.eval()
    hidden = None
    input = torch.tensor([char_to_idx[c] for c in start_text], dtype=torch.long).unsqueeze(0)
    
    generated = start_text
    for _ in range(length):
        output, hidden = model(input, hidden)
        # 按概率采样，提高多样性
        output = output[-1] / temperature
        probs = torch.softmax(output, dim=0)
        next_char_idx = torch.multinomial(probs, num_samples=1).item()
        generated += idx_to_char[next_char_idx]
        input = torch.tensor([[next_char_idx]], dtype=torch.long)
    
    return generated

from facenet_pytorch import MTCNN, InceptionResnetV1
from PIL import Image

# 加载预训练模型
mtcnn = MTCNN(keep_all=True)  # 检测所有人脸
resnet = InceptionResnetV1(pretrained='vggface2').eval()  # 特征提取模型

# 检测人脸
img = Image.open('face.jpg')
boxes, probs = mtcnn.detect(img)
print(f'检测到{len(boxes)}张人脸，置信度：{probs}')

# 提取特征
aligned = mtcnn(img)
embeddings = resnet(aligned).detach().numpy()

# 比对两个人脸的相似度
def cosine_similarity(emb1, emb2):
    return np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))

similarity = cosine_similarity(embeddings[0], embeddings[1])
print(f'人脸相似度：{similarity:.4f}，阈值0.7以上可判定为同一人')

from transformers import BertTokenizer, BertForSequenceClassification
import torch

# 加载预训练的中文BERT模型和分词器
model_name = "hfl/chinese-bert-wwm-ext"
tokenizer = BertTokenizer.from_pretrained(model_name)
model = BertForSequenceClassification.from_pretrained(model_name, num_labels=2)  # 二分类：正面/负面

# 数据预处理
def preprocess(text):
    encoding = tokenizer(text, truncation=True, padding=True, max_length=128, return_tensors="pt")
    return encoding

# 预测函数
def predict_sentiment(text):
    model.eval()
    with torch.no_grad():
        inputs = preprocess(text)
        outputs = model(**inputs)
        logits = outputs.logits
        probabilities = torch.softmax(logits, dim=1)
        label = torch.argmax(probabilities, dim=1).item()
        confidence = probabilities[0][label].item()
    
    sentiment = "正面" if label == 1 else "负面"
    return f"情感：{sentiment}，置信度：{confidence:.4f}"

# 测试
print(predict_sentiment("这款手机拍照效果非常好，电池也很耐用"))
print(predict_sentiment("买了一周就坏了，客服态度还很差"))

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

# 1. 加载并预处理数据
df = pd.read_csv('stock_data.csv')
data = df['close'].values.reshape(-1, 1)  # 取收盘价数据

scaler = MinMaxScaler(feature_range=(-1, 1))
scaled_data = scaler.fit_transform(data)

# 创建时间序列数据集
def create_dataset(data, seq_length):
    X, y = [], []
    for i in range(len(data) - seq_length):
        X.append(data[i:i+seq_length, 0])
        y.append(data[i+seq_length, 0])
    return np.array(X), np.array(y)

seq_length = 60  # 使用前60天数据预测下一天
X, y = create_dataset(scaled_data, seq_length)
X = torch.from_numpy(X).float().unsqueeze(2)  # 添加特征维度
y = torch.from_numpy(y).float()

# 2. 定义LSTM模型
class StockLSTM(nn.Module):
    def __init__(self, input_size=1, hidden_size=50, num_layers=2, output_size=1):
        super().__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        out, _ = self.lstm(x)
        out = self.fc(out[:, -1, :])  # 取最后一个时间步的输出
        return out

# 3. 预测未来价格
def predict_future(model, last_sequence, days=7):
    model.eval()
    predictions = []
    current_seq = last_sequence
    
    for _ in range(days):
        with torch.no_grad():
            pred = model(current_seq.unsqueeze(0))
        predictions.append(pred.item())
        # 更新序列，加入新预测值
        current_seq = torch.cat([current_seq[1:], pred])
    
    # 反归一化
    predictions = scaler.inverse_transform(np.array(predictions).reshape(-1, 1))
    return predictions.flatten()

from diffusers import StableDiffusionPipeline
import torch

# 加载Stable Diffusion v2.1模型
model_id = "stabilityai/stable-diffusion-2-1"
pipe = StableDiffusionPipeline.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    use_safetensors=True
).to("cuda")

# 生成图像
prompt = "一幅赛博朋克风格的城市夜景，高楼大厦，霓虹灯光，下雨的街道，未来科技感"
image = pipe(
    prompt,
    height=768,
    width=768,
    num_inference_steps=50,
    guidance_scale=7.5
).images[0]

# 保存图像
image.save("cyberpunk_city.png")