from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

# 加载数据集
iris = datasets.load_iris()
X, y = iris.data, iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 训练 SVM 模型
clf = SVC(kernel='rbf', C=1.0, gamma='scale')
clf.fit(X_train, y_train)

# 预测 & 评估
y_pred = clf.predict(X_test)
print("Accuracy:", accuracy_score(y_test, y_pred))

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
from sklearn.metrics import accuracy_score

# 生成数据集
X, y = make_classification(n_samples=1000, n_features=2, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 训练逻辑回归模型
model = LogisticRegression()
model.fit(X_train, y_train)

# 预测
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"模型准确率: {accuracy:.2f}")

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

batch_size = 128
lr = 0.00005  # WGAN采用较小的学习率
noise_dim = 100
epochs = 20
channel_size = 1
critic_iter = 5  # 判别器训练次数
weight_clip = 0.01  # 权重裁剪范围

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
os.makedirs("output_wgan", exist_ok=True)

# 数据预处理
transform = transforms.Compose([
    transforms.Grayscale(num_output_channels=1),  # 修改默认的图像通道数
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

# 使用 ImageFolder 读取数据
dataset = datasets.ImageFolder(root='data/mnist_jpg', transform=transform)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)


class Generator(nn.Module):
    """
    基于卷积层的生成器
    和 DCGAN 相同
    """
    def __init__(self, noise_dim, channel_size):
        super().__init__()
        self.main = nn.Sequential(
            nn.ConvTranspose2d(noise_dim, 128, kernel_size=7, stride=1, padding=0),
            nn.BatchNorm2d(128),
            nn.ReLU(True),

            nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(True),

            nn.ConvTranspose2d(64, channel_size, kernel_size=4, stride=2, padding=1),
            nn.Tanh()
        )

    def forward(self, input):
        return self.main(input)


class Discriminator(nn.Module):
    """
    基于卷积层的判别器
    和 DCGAN 相同
    """
    def __init__(self, channel_size):
        super().__init__()
        self.main = nn.Sequential(
            nn.Conv2d(channel_size, 64, kernel_size=4, stride=2, padding=1),
            nn.LeakyReLU(0.2, inplace=True),

            nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1),
            nn.LeakyReLU(0.2, inplace=True),
        )

        self.flatten = nn.Flatten()
        self.fc = nn.Linear(128 * 7 * 7, 1)

    def forward(self, input):
        x = self.main(input)
        x = self.flatten(x)
        output = self.fc(x)
        return output


# 模型,优化器
netG = Generator(noise_dim, channel_size).to(device)
netD = Discriminator(channel_size).to(device)

# 原论文建议使用 RMSprop 优化器
optimizerD = optim.RMSprop(netD.parameters(), lr=lr)
optimizerG = optim.RMSprop(netG.parameters(), lr=lr)

# 训练过程
for epoch in range(epochs):
    for i, (data, _) in enumerate(dataloader):
        real_imgs = data.to(device)
        batch_size = real_imgs.size(0)

        # 判别器训练
        for _ in range(critic_iter):
            netD.zero_grad()
            noise = torch.randn(batch_size, noise_dim, 1, 1, device=device)
            fake_imgs = netG(noise)

            # 计算 Wasserstein 损失
            lossD = -netD(real_imgs).mean() + netD(fake_imgs.detach()).mean()
            lossD.backward()
            optimizerD.step()

            # 权重裁剪
            for p in netD.parameters():
                p.data.clamp_(-weight_clip, weight_clip)

        # 生成器训练
        netG.zero_grad()
        fake_imgs = netG(noise)

        # 计算 Wasserstein 损失
        lossG = -netD(fake_imgs).mean()
        lossG.backward()
        optimizerG.step()

        if i % 100 == 0:
            print(f"Epoch [{epoch + 1}/{epochs}] Batch {i}/{len(dataloader)} Loss_D: {lossD.item():.4f} Loss_G: {lossG.item():.4f}")

    # 保存生成结果
    with torch.no_grad():
        fixed_noise = torch.randn(16, noise_dim, 1, 1, device=device)
        fake = netG(fixed_noise)
    vutils.save_image(fake, f"output_wgan/fake_samples_epoch_{epoch + 1}.png", normalize=True)

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

batch_size = 128
lr = 0.0002
noise_dim = 100
epochs = 20
channel_size = 1
lambda_gp = 10  # 梯度惩罚系数
critic_iterations = 5  # 判别器训练次数

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
os.makedirs("output_wgan_gp", exist_ok=True)

# 数据预处理
transform = transforms.Compose([
    transforms.Grayscale(num_output_channels=1),
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

dataset = datasets.ImageFolder(root='data/mnist_jpg', transform=transform)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)


class Generator(nn.Module):
    """
    基于卷积层的生成器
    和 DCGAN 相同
    """
    def __init__(self, noise_dim, channel_size):
        super().__init__()
        self.main = nn.Sequential(
            nn.ConvTranspose2d(noise_dim, 128, kernel_size=7, stride=1, padding=0),
            nn.BatchNorm2d(128),
            nn.ReLU(True),
            nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(True),
            nn.ConvTranspose2d(64, channel_size, kernel_size=4, stride=2, padding=1),
            nn.Tanh()
        )

    def forward(self, input):
        return self.main(input)


class Critic(nn.Module):
    """
    基于卷积层的判别器
    和 DCGAN 相同
    """
    def __init__(self, channel_size):
        super().__init__()
        self.main = nn.Sequential(
            nn.Conv2d(channel_size, 64, kernel_size=4, stride=2, padding=1),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1),
            nn.BatchNorm2d(128),
            nn.LeakyReLU(0.2, inplace=True)
        )
        self.flatten = nn.Flatten()
        self.fc = nn.Linear(128 * 7 * 7, 1)

    def forward(self, input):
        x = self.main(input)
        x = self.flatten(x)
        return self.fc(x)


def compute_gradient_penalty(critic, real_samples, fake_samples):
    """
    计算梯度惩罚
    """
    # 随机数 alpha作为插值的权重, interpolates 是在真实样本和假样本之间的插值数据
    alpha = torch.rand(real_samples.size(0), 1, 1, 1, device=device)
    interpolates = (alpha * real_samples + (1 - alpha) * fake_samples).requires_grad_(True)

    # 得到判别器的结果
    critic_interpolates = critic(interpolates)

    # torch.autograd.grad用于计算导数，将梯度计算的结果存储在 gradients 变量中
    gradients = torch.autograd.grad(outputs=critic_interpolates, inputs=interpolates,
                                    grad_outputs=torch.ones_like(critic_interpolates),
                                    create_graph=True, retain_graph=True, only_inputs=True)[0]

    # 将梯度展平 (Batch, channels, height, width) -> (Batch, channels * height * width)
    gradients = gradients.view(gradients.size(0), -1)

    # 计算梯度惩罚, 公式为((梯度的L2范数 - 1) ^ 2)的均值
        # 理想情况下，Lipschitz常数应该为1，因此梯度的L2范数（gradients.norm(2, dim=1)）应该接近1。
        # 如果它大于1或小于1，都会给模型带来惩罚，以倒逼判别器的梯度符合要求。
    gradient_penalty = ((gradients.norm(2, dim=1) - 1) ** 2).mean()
    return gradient_penalty


# 模型,优化器
netG = Generator(noise_dim, channel_size).to(device)
netC = Critic(channel_size).to(device)

optimizerC = optim.Adam(netC.parameters(), lr=lr, betas=(0.5, 0.999))
optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(0.5, 0.999))

# 训练过程
for epoch in range(epochs):
    for i, (data, _) in enumerate(dataloader):
        real_imgs = data.to(device)
        batch_size = real_imgs.size(0)

        # 训练判别器
        for _ in range(critic_iterations):
            netC.zero_grad()
            noise = torch.randn(batch_size, noise_dim, 1, 1, device=device)
            fake_imgs = netG(noise)

            # 计算 Wasserstein 损失
            lossC_real = -netC(real_imgs).mean() + netC(fake_imgs.detach()).mean()
            # 计算梯度惩罚
            gradient_penalty = compute_gradient_penalty(netC, real_imgs, fake_imgs.detach())
            lossC = lossC_real + lambda_gp * gradient_penalty # 增加梯度惩罚

            lossC.backward()
            optimizerC.step()

        # 训练生成器
        netG.zero_grad()
        fake_imgs = netG(noise)

        # 计算 Wasserstein 损失
        lossG = -netC(fake_imgs).mean()
        lossG.backward()
        optimizerG.step()

        if i % 100 == 0:
            print(f"Epoch [{epoch + 1}/{epochs}] Batch {i}/{len(dataloader)} Loss_C: {lossC.item():.4f} Loss_G: {lossG.item():.4f}")

    # 保存每个 epoch 的生成结果
    with torch.no_grad():
        fixed_noise = torch.randn(16, noise_dim, 1, 1, device=device)
        fake = netG(fixed_noise)
    vutils.save_image(fake, f"output_wgan_gp/fake_samples_epoch_{epoch + 1}.png", normalize=True)

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

batch_size = 128
lr = 0.0002
noise_dim = 100
epochs = 20
channel_size = 1
num_classes = 10  # 数据集类别数

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
os.makedirs("output_acgan", exist_ok=True)

# 数据预处理和加载
transform = transforms.Compose([
    transforms.Grayscale(num_output_channels=1),
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

dataset = datasets.ImageFolder(root='data/mnist_jpg', transform=transform)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)


class Generator(nn.Module):
    def __init__(self, noise_dim, num_classes, channel_size):
        """
        基于卷积层的生成器
        卷积层的部分和DCGAN完全相同，只是增加了类别嵌入，以学习到类别信息
        """
        super().__init__()

        # 将离散类别标签映射到连续向量空间
        self.label_emb = nn.Embedding(num_classes, noise_dim)

        self.main = nn.Sequential(
            nn.ConvTranspose2d(noise_dim * 2, 128, kernel_size=7, stride=1, padding=0),
            nn.BatchNorm2d(128),
            nn.ReLU(True),

            nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(True),

            nn.ConvTranspose2d(64, channel_size, kernel_size=4, stride=2, padding=1),
            nn.Tanh()
        )

    def forward(self, noise, labels):
        # 将类别嵌入
        label_embedding = self.label_emb(labels).unsqueeze(2).unsqueeze(3) # 变形以匹配噪声维度
        input = torch.cat([noise, label_embedding], dim=1)
        return self.main(input)


class Discriminator(nn.Module):
    def __init__(self, channel_size, num_classes):
        """
        基于卷积层的判别器
        卷积层的部分和DCGAN完全相同
        新增加类别分类头
        """
        super().__init__()

        self.main = nn.Sequential(
            nn.Conv2d(channel_size, 64, kernel_size=4, stride=2, padding=1),
            nn.LeakyReLU(0.2, inplace=True),

            nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1),
            nn.BatchNorm2d(128),
            nn.LeakyReLU(0.2, inplace=True),
        )

        self.flatten = nn.Flatten()
        self.fc_real_fake = nn.Linear(128 * 7 * 7, 1)  # 真假分类
        self.fc_class = nn.Linear(128 * 7 * 7, num_classes)  # 分类

    def forward(self, input):
        x = self.main(input)
        x = self.flatten(x)

        real_fake = torch.sigmoid(self.fc_real_fake(x)) # 需要添加 softmax，因为 BCELoss 需要输入概率值
        class_output = self.fc_class(x)  # 分类输出（不加 softmax，交叉熵损失自带sigmoid）
        return real_fake, class_output

# 模型,优化器,损失函数
netG = Generator(noise_dim, num_classes, channel_size).to(device)
netD = Discriminator(channel_size, num_classes).to(device)

criterion_gan = nn.BCELoss()
criterion_class = nn.CrossEntropyLoss()

optimizerD = optim.Adam(netD.parameters(), lr=lr, betas=(0.5, 0.999))
optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(0.5, 0.999))

# 训练过程
for epoch in range(epochs):
    for i, (data, labels) in enumerate(dataloader):
        batch_size = data.size(0)
        real_imgs, labels = data.to(device), labels.to(device)

        real_labels = torch.ones(batch_size, 1, device=device)
        fake_labels = torch.zeros(batch_size, 1, device=device)

        # 训练判别器
        netD.zero_grad()
            # 真实数据损失
        real_out, real_class = netD(real_imgs)
        lossD_real = criterion_gan(real_out, real_labels)
        lossD_real_class = criterion_class(real_class, labels)
            # 计算虚假数据损失
                # 生成假样本
        noise = torch.randn(batch_size, noise_dim, 1, 1, device=device)
        fake_labels_input = torch.randint(0, num_classes, (batch_size,), device=device)
        fake_imgs = netG(noise, fake_labels_input)
                # 假样本损失
        fake_out, fake_class = netD(fake_imgs.detach())
        lossD_fake = criterion_gan(fake_out, fake_labels)
        lossD_fake_class = criterion_class(fake_class, fake_labels_input)
            # 总判别器损失
        lossD = lossD_real + lossD_fake + lossD_real_class + lossD_fake_class
        lossD.backward()
        optimizerD.step()

        # 训练生成器
        netG.zero_grad()
        fake_out, fake_class = netD(fake_imgs)
            # 生成器希望判别器把假样本判为真实
        lossG_fake = criterion_gan(fake_out, real_labels)
        lossG_classification = criterion_class(fake_class, fake_labels_input)
            # 总生成器损失
        lossG = lossG_fake + lossG_classification
        lossG.backward()
        optimizerG.step()

        if i % 100 == 0:
            print(f"Epoch [{epoch + 1}/{epochs}] Batch {i}/{len(dataloader)} "
                  f"Loss_D: {lossD.item():.4f} Loss_G: {lossG.item():.4f}")

    # 保存生成结果
    with torch.no_grad():
        fixed_noise = torch.randn(16, noise_dim, 1, 1, device=device)
        fixed_labels = torch.randint(0, num_classes, (16,), device=device)
        fake = netG(fixed_noise, fixed_labels)
    vutils.save_image(fake, f"output_acgan/fake_samples_epoch_{epoch + 1}.png", normalize=True)