用GAN网络生成彩票号码

1. 前言

生成对抗网络(GAN,Generative Adversarial Network)是由Ian Goodfellow等人在2014年提出的一种深度学习模型,用于学习和生成与真实数据分布相似的数据。GAN由生成器(Generator)和判别器(Discriminator)两个部分组成,通过相互对抗的方式进行训练。生成器接受随机噪声并生成假数据,试图欺骗判别器;判别器则试图区分真实数据和生成数据,通过不断竞争,两个网络共同提升各自的性能。
在CP预测的娱乐项目中,GAN用于学习历史CP数据的分布,并生成类似的号码。需要强调的是,这种应用仅限于技术学习和娱乐,不具备实际预测能力。通过训练,生成器生成与历史数据分布相似的号码,判别器提升其区分真假数据的能力。最终,GAN展示了其在数据分布学习中的强大能力。

2. 准据准备

大lott 由7个号码组成,前区5个不重复数字【1-35】,后区2个不重复数字【1-12】。先搜集2500左右历史样本

接下来进行数据处理,用于训练

python 复制代码
def lotto_data_loader(file_path, val_n=50, seed=24, batch_size=32):
    # 读取文件
    data = pd.read_excel(file_path)

    # 数据预处理:拆分前区和后区号码并合并为一个数据集,然后进行归一化处理
    front_area_numbers = data['前区'].str.split(' ', expand=True).astype(int)
    back_area_numbers = data['后区'].str.split(' ', expand=True).astype(int)

    # 归一化处理
    front_area_numbers = (front_area_numbers - 1) / 34.0  # 前区号码范围1-35,归一化到0-1
    back_area_numbers = (back_area_numbers - 1) / 11.0   # 后区号码范围1-12,归一化到0-1

    # 合并前区和后区的号码
    all_numbers = pd.concat([front_area_numbers, back_area_numbers], axis=1).values
    all_numbers = torch.tensor(all_numbers, dtype=torch.float32)
    print(f"All numbers shape: {all_numbers.shape}")

    # Create TensorDataset
    dataset = TensorDataset(all_numbers)

    # 划分数据集
    data_size = len(all_numbers) - val_n
    train_dataset, val_dataset = random_split(dataset, 
                                              [data_size, val_n],
                                              generator=torch.Generator().manual_seed(seed))
    train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
    val_loader = DataLoader(val_dataset, batch_size=1, shuffle=False)

    return train_loader, val_loader

CP中数字分布如下,是一个均匀分布

3. 定义GAN网络

GAN的大致原理如图

【1】判别器对正负样本进行打分,同时根据二者误差信号优化自身

【2】生成器只生成逼真的负样本,同时根据判别器的负样本打分优化自身

3.1 定义生成器

定义一个简单的全连接网络预测CP号码

模型输入:随机噪声 【正态分布】

模型输出:7位CP号码[0, 1] 预测打分,继而预测CP序列:Y[0:5] * 35 + Y[5:7] *12

python 复制代码
class Generator(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(Generator, self).__init__()

        self.model = nn.Sequential(
            nn.Linear(input_dim, 256),  # 输入层,输入维度为 input_dim,输出维度为256
            nn.LeakyReLU(0.2),  # LeakyReLU 激活函数
            nn.BatchNorm1d(256),  # 批量归一化
            nn.Linear(256, 512),  # 隐藏层,输入维度256,输出维度512
            nn.LeakyReLU(0.2),  # LeakyReLU 激活函数
            nn.BatchNorm1d(512),  # 批量归一化
            nn.Linear(512, 1024),  # 隐藏层,输入维度512,输出维度1024
            nn.LeakyReLU(0.2),  # LeakyReLU 激活函数
            nn.BatchNorm1d(1024),  # 批量归一化
            nn.Linear(1024, output_dim),  # 输出层,输入维度1024,输出维度 output_dim
            nn.Sigmoid()  # Sigmoid 激活函数,输出值在0到1之间
        )
    
    def forward(self, x):
        """前向传播函数"""
        return self.model(x)  # 将数据传入模型,得到输出,形状为 N x output_dim

3.2 定义判别器

判别器也采用简单全连接网络,输出采用sigmoid 对正负样本进行打分[0,1]

0:False, 1:True

python 复制代码
class Discriminator(nn.Module):
    def __init__(self, input_dim):
        super(Discriminator, self).__init__()
        # 定义模型的全连接层和激活函数
        self.model = nn.Sequential(
            nn.Linear(input_dim, 512),  # 输入层,输入维度为 input_dim,输出维度为512
            nn.LeakyReLU(0.2),  # LeakyReLU 激活函数
            nn.Linear(512, 256),  # 隐藏层,输入维度512,输出维度256
            nn.LeakyReLU(0.2),  # LeakyReLU 激活函数
            nn.Linear(256, 1),  # 输出层,输入维度256,输出维度1
            nn.Sigmoid()  # Sigmoid 激活函数,输出值在0到1之间
        )
    
    def forward(self, x):
        return self.model(x)  # 前向传播函数,返回模型的输出

4. 定义损失函数

4.1 判别器损失函数

判别器用于鉴别真实样本和生成样本,前期鉴别的越准则生成器的仿真能力逐步越强【道高一尺魔高一丈】,我们考虑以下优化目标:

【1】使用经典的交叉熵来判别正负样本分布距离

【2】CP序列中前区和后区中每个数字唯一不重复,构建重复惩罚

【3】CP号段中前区号段5个号码不超过35,后区号段2个号码不超过12,构建溢出惩罚

python 复制代码
def discriminator_loss(y_true, y_pred, generated_numbers):
    bce_loss = nn.BCELoss()(y_pred, y_true)

    # 获取生成的号码
    front_numbers = generated_numbers[:, :5] * 34.0 + 1.0  # 反归一化到1-35
    back_numbers = generated_numbers[:, 5:] * 11.0 + 1.0   # 反归一化到1-12

    # 前区和后区号码范围约束(仅最大值约束)
    front_range_loss = torch.sum(torch.clamp(front_numbers - 35.0, min=0.0))
    back_range_loss = torch.sum(torch.clamp(back_numbers - 12.0, min=0.0))

    # 使用torch.clamp确保前区和后区号码在适当范围内
    front_numbers = torch.clamp(front_numbers, 1, 35)
    back_numbers = torch.clamp(back_numbers, 1, 12)

    # 前区和后区号码不重复约束
    front_unique_loss = torch.sum((torch.nn.functional.one_hot(front_numbers.to(torch.int64) - 1, num_classes=35).sum(dim=1) > 1.0).float())
    back_unique_loss = torch.sum((torch.nn.functional.one_hot(back_numbers.to(torch.int64) - 1, num_classes=12).sum(dim=1) > 1.0).float())

    # 组合损失
    total_loss = bce_loss + 0.1 * (front_range_loss + back_range_loss + front_unique_loss + back_unique_loss)
    return total_loss

对正负样本的鉴别的联合损失

python 复制代码
	# Labels for real and fake data
     valid = torch.ones(batch_size, 1)
     fake = torch.zeros(batch_size, 1)

     # Generate fake lottery numbers from random noise
     noise = torch.randn(batch_size, input_dim)
     fake_numbers = generator(noise)
     
     # Train the discriminator
     real_loss = discriminator_loss(valid, discriminator(real_numbers), real_numbers)
     fake_loss = discriminator_loss(fake, discriminator(fake_numbers.detach()), fake_numbers.detach())
     d_loss = 0.5 * (real_loss + fake_loss)
     d_loss.backward()

4.2 生成器损失

生成器的优化目标之和负样本有关,即构建逼真的伪样本

python 复制代码
	g_loss = discriminator_loss(valid, discriminator(fake_numbers), fake_numbers)
    g_loss.backward()

5. G/D 联合训练

这里对生成器(G)/判别器(D)联合训练,在每个epoch里对判别器多训练优先培养鉴别能力

【训练停止条件】:(1)整体loss下降切收敛(2)判别器的识别率下降即无法分辨

python 复制代码
for epoch in range(epochs):
    for real_numbers_batch in train_loader:
        real_numbers = real_numbers_batch[0]
        batch_size = real_numbers.size(0)
        # print(real_numbers.shape)
        
        # 更新判别器n_critic次
        for _ in range(n_critic):
            # 为真实和生成的数据设置标签
            valid = torch.ones(batch_size, 1)
            fake = torch.zeros(batch_size, 1)

            # 从随机噪声生成假的彩票号码
            noise = torch.randn(batch_size, input_dim)
            fake_numbers = generator(noise)
            
            # 训练判别器
            optimizer_D.zero_grad()
            real_loss = discriminator_loss(valid, discriminator(real_numbers), real_numbers)
            fake_loss = discriminator_loss(fake, discriminator(fake_numbers.detach()), fake_numbers.detach())
            d_loss = 0.5 * (real_loss + fake_loss)
            d_loss.backward()
            optimizer_D.step()
            
            # 计算判别器准确率
            real_acc = (discriminator(real_numbers) > 0.5).float().mean()
            fake_acc = (discriminator(fake_numbers.detach()) < 0.5).float().mean()
            d_acc = 0.5 * (real_acc + fake_acc)
        
        # 训练生成器
        optimizer_G.zero_grad()
        g_loss = discriminator_loss(valid, discriminator(fake_numbers), fake_numbers)
        g_loss.backward()
        optimizer_G.step()

    # 使用验证数据进行评估
    val_g_loss, val_d_loss, val_d_acc = evaluate(generator, discriminator, val_loader)

训练的日志如下

可以看到【1】生成器损失下降切收敛【2】判别器识别率下降,难以区分仿真样本


6. 生成CP号码

训练好生成器,开始预测CP号码啦

python 复制代码
import torch
import numpy as np
from generator import Generator

# 定义生成器输入(噪声)的维度和生成器输出(彩票号码)的维度
input_dim = 100
output_dim = 7

# 实例化生成器模型
generator = Generator(input_dim, output_dim)

# 加载训练好的生成器模型权重
generator.load_state_dict(torch.load('generator_model.pth'))
generator.eval()  # 设置生成器为评估模式

# 生成新的噪声数据
batch_size = 10  # 生成10组彩票号码
noise = torch.randn(batch_size, input_dim)

# 通过生成器生成彩票号码
with torch.no_grad():  # 禁用梯度计算
    generated_numbers = generator(noise).numpy()

# 对生成的彩票号码进行后处理(反归一化)
# 假设前区号码范围1-35,后区号码范围1-12
front_area_numbers = generated_numbers[:, :5] * 34 + 1
back_area_numbers = generated_numbers[:, 5:] * 11 + 1

# 将彩票号码转换为整数
front_area_numbers = front_area_numbers.astype(int)
back_area_numbers = back_area_numbers.astype(int)

# 打印生成的彩票号码
print("Generated Lottery Numbers:")
for i in range(batch_size):
    print(f"Front Area: {front_area_numbers[i]}, Back Area: {back_area_numbers[i]}")

# 保存生成的彩票号码到文件
np.savetxt('generated_lottery_numbers.txt', np.hstack((front_area_numbers, back_area_numbers)), fmt='%d', delimiter=',')

运行完毕后,生成器给出10组建议号码


7. 总结

本文采用GAN网络范式来尝试拟合CP序列分布,内容仅为技术学习,含娱乐成分,不构成任何TZ建议

相关推荐
成富1 小时前
文本转SQL(Text-to-SQL),场景介绍与 Spring AI 实现
数据库·人工智能·sql·spring·oracle
CSDN云计算1 小时前
如何以开源加速AI企业落地,红帽带来新解法
人工智能·开源·openshift·红帽·instructlab
艾派森1 小时前
大数据分析案例-基于随机森林算法的智能手机价格预测模型
人工智能·python·随机森林·机器学习·数据挖掘
hairenjing11231 小时前
在 Android 手机上从SD 卡恢复数据的 6 个有效应用程序
android·人工智能·windows·macos·智能手机
小蜗子1 小时前
Multi‐modal knowledge graph inference via media convergenceand logic rule
人工智能·知识图谱
SpikeKing2 小时前
LLM - 使用 LLaMA-Factory 微调大模型 环境配置与训练推理 教程 (1)
人工智能·llm·大语言模型·llama·环境配置·llamafactory·训练框架
黄焖鸡能干四碗2 小时前
信息化运维方案,实施方案,开发方案,信息中心安全运维资料(软件资料word)
大数据·人工智能·软件需求·设计规范·规格说明书
2 小时前
开源竞争-数据驱动成长-11/05-大专生的思考
人工智能·笔记·学习·算法·机器学习
ctrey_2 小时前
2024-11-4 学习人工智能的Day21 openCV(3)
人工智能·opencv·学习
攻城狮_Dream2 小时前
“探索未来医疗:生成式人工智能在医疗领域的革命性应用“
人工智能·设计·医疗·毕业