【昇思25天学习打卡营打卡指南-第二十二天】GAN图像生成

GAN图像生成

模型简介

生成式对抗网络(Generative Adversarial Networks，GAN)是一种生成式机器学习模型，是近年来复杂分布上无监督学习最具前景的方法之一。

最初，GAN由Ian J. Goodfellow于2014年发明，并在论文Generative Adversarial Nets中首次进行了描述，其主要由两个不同的模型共同组成——生成器(Generative Model)和判别器(Discriminative Model)：

  • 生成器的任务是生成看起来像训练图像的“假”图像；
  • 判别器需要判断从生成器输出的图像是真实的训练图像还是虚假的图像。

GAN通过设计生成模型和判别模型这两个模块，使其互相博弈学习产生了相当好的输出。

GAN模型的核心在于提出了通过对抗过程来估计生成模型这一全新框架。在这个框架中，将会同时训练两个模型——捕捉数据分布的生成模型 G G G 和估计样本是否来自训练数据的判别模型 D D D 。

在训练过程中，生成器会不断尝试通过生成更好的假图像来骗过判别器，而判别器在这过程中也会逐步提升判别能力。这种博弈的平衡点是，当生成器生成的假图像和训练数据图像的分布完全一致时，判别器拥有50%的真假判断置信度。

用 x x x 代表图像数据，用 D ( x ) D(x) D(x)表示判别器网络给出图像判定为真实图像的概率。在判别过程中， D ( x ) D(x) D(x) 需要处理作为二进制文件的大小为 1 × 28 × 28 1\times 28\times 28 1×28×28 的图像数据。当 x x x 来自训练数据时， D ( x ) D(x) D(x) 数值应该趋近于 1 1 1 ；而当 x x x 来自生成器时， D ( x ) D(x) D(x) 数值应该趋近于 0 0 0 。因此 D ( x ) D(x) D(x) 也可以被认为是传统的二分类器。

用 z z z 代表标准正态分布中提取出的隐码(隐向量)，用 G ( z ) G(z) G(z)：表示将隐码(隐向量) z z z 映射到数据空间的生成器函数。函数 G ( z ) G(z) G(z) 的目标是将服从高斯分布的随机噪声 z z z 通过生成网络变换为近似于真实分布 p d a t a ( x ) p_{data}(x) pdata​(x) 的数据分布，我们希望找到 θ θ θ 使得 p G ( x ; θ ) p_{G}(x;\theta) pG​(x;θ) 和 p d a t a ( x ) p_{data}(x) pdata​(x) 尽可能的接近，其中 θ \theta θ 代表网络参数。

D ( G ( z ) ) D(G(z)) D(G(z)) 表示生成器 G G G 生成的假图像被判定为真实图像的概率，如Generative Adversarial Nets中所述， D D D 和 G G G 在进行一场博弈， D D D 想要最大程度的正确分类真图像与假图像，也就是参数 log ⁡ D ( x ) \log D(x) logD(x)；而 G G G 试图欺骗 D D D 来最小化假图像被识别到的概率，也就是参数 log ⁡ ( 1 − D ( G ( z ) ) ) \log(1−D(G(z))) log(1−D(G(z)))。因此GAN的损失函数为：

min ⁡ G max ⁡ D V ( D , G ) = E x ∼ p d a t a     ( x ) [ log ⁡ D ( x ) ] + E z ∼ p z   ( z ) [ log ⁡ ( 1 − D ( G ( z ) ) ) ] \min\limits_{G}\max\limits_{D} V(D,G)=E_{x\sim p_{data}\;\,(x)}[\log D(x)]+E_{z\sim p_{z}\,(z)}[\log (1-D(G(z)))] Gmin​Dmax​V(D,G)=Ex∼pdata​(x)​[logD(x)]+Ez∼pz​(z)​[log(1−D(G(z)))]

从理论上讲，此博弈游戏的平衡点是 p G ( x ; θ ) = p d a t a ( x ) p_{G}(x;\theta) = p_{data}(x) pG​(x;θ)=pdata​(x)，此时判别器会随机猜测输入是真图像还是假图像。下面我们简要说明生成器和判别器的博弈过程：

  1. 在训练刚开始的时候，生成器和判别器的质量都比较差，生成器会随机生成一个数据分布。
  2. 判别器通过求取梯度和损失函数对网络进行优化，将靠近真实数据分布的数据判定为1，将靠近生成器生成出来数据分布的数据判定为0。
  3. 生成器通过优化，生成出更加贴近真实数据分布的数据。
  4. 生成器所生成的数据和真实数据达到相同的分布，此时判别器的输出为1/2。

image.png

在上图中，蓝色虚线表示判别器，黑色虚线表示真实数据分布，绿色实线表示生成器生成的虚假数据分布， z z z 表示隐码， x x x 表示生成的虚假图像 G ( z ) G(z) G(z)。该图片来源于Generative Adversarial Nets。详细的训练方法介绍见原论文。

数据集

数据集简介

MNIST手写数字数据集是NIST数据集的子集，共有70000张手写数字图片，包含60000张训练样本和10000张测试样本，数字图片为二进制文件，图片大小为28*28，单通道。图片已经预先进行了尺寸归一化和中心化处理。

本案例将使用MNIST手写数字数据集来训练一个生成式对抗网络，使用该网络模拟生成手写数字图片。

数据集下载

使用download接口下载数据集，并将下载后的数据集自动解压到当前目录下。数据下载之前需要使用pip install download安装download包。

下载解压后的数据集目录结构如下：

./MNIST_Data/
├─ train
│ ├─ train-images-idx3-ubyte
│ └─ train-labels-idx1-ubyte
└─ test
   ├─ t10k-images-idx3-ubyte
   └─ t10k-labels-idx1-ubyte

数据下载的代码如下：

# 数据下载
from download import download

url = "https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/MNIST_Data.zip"
download(url, ".", kind="zip", replace=True)

数据加载

使用MindSpore自己的MnistDatase接口，读取和解析MNIST数据集的源文件构建数据集。然后对数据进行一些前处理。

import numpy as np
import mindspore.dataset as ds

batch_size = 64
latent_size = 100  # 隐码的长度

train_dataset = ds.MnistDataset(dataset_dir='./MNIST_Data/train')
test_dataset = ds.MnistDataset(dataset_dir='./MNIST_Data/test')

def data_load(dataset):
    dataset1 = ds.GeneratorDataset(dataset, ["image", "label"], shuffle=True, python_multiprocessing=False,num_samples=10000)
    # 数据增强
    mnist_ds = dataset1.map(
        operations=lambda x: (x.astype("float32"), np.random.normal(size=latent_size).astype("float32")),
        output_columns=["image", "latent_code"])
    mnist_ds = mnist_ds.project(["image", "latent_code"])

    # 批量操作
    mnist_ds = mnist_ds.batch(batch_size, True)

    return mnist_ds

mnist_ds = data_load(train_dataset)

iter_size = mnist_ds.get_dataset_size()
print('Iter size: %d' % iter_size)

数据集可视化

通过create_dict_iterator函数将数据转换成字典迭代器，然后使用matplotlib模块可视化部分训练数据。

import matplotlib.pyplot as plt

data_iter = next(mnist_ds.create_dict_iterator(output_numpy=True))
figure = plt.figure(figsize=(3, 3))
cols, rows = 5, 5
for idx in range(1, cols * rows + 1):
    image = data_iter['image'][idx]
    figure.add_subplot(rows, cols, idx)
    plt.axis("off")
    plt.imshow(image.squeeze(), cmap="gray")
plt.show()

image.png

隐码构造

为了跟踪生成器的学习进度，我们在训练的过程中的每轮迭代结束后，将一组固定的遵循高斯分布的隐码test_noise输入到生成器中，通过固定隐码所生成的图像效果来评估生成器的好坏。

import random
import numpy as np
from mindspore import Tensor
from mindspore.common import dtype

# 利用随机种子创建一批隐码
np.random.seed(2323)
test_noise = Tensor(np.random.normal(size=(25, 100)), dtype.float32)
random.shuffle(test_noise)

模型构建

本案例实现中所搭建的 GAN 模型结构与原论文中提出的 GAN 结构大致相同，但由于所用数据集 MNIST 为单通道小尺寸图片，可识别参数少，便于训练，我们在判别器和生成器中采用全连接网络架构和 ReLU 激活函数即可达到令人满意的效果，且省略了原论文中用于减少参数的 Dropout 策略和可学习激活函数 Maxout。

生成器

生成器 Generator 的功能是将隐码映射到数据空间。由于数据是图像，这一过程也会创建与真实图像大小相同的灰度图像(或 RGB 彩色图像)。在本案例演示中，该功能通过五层 Dense 全连接层来完成的，每层都与 BatchNorm1d 批归一化层和 ReLU 激活层配对，输出数据会经过 Tanh 函数，使其返回 [-1,1] 的数据范围内。注意实例化生成器之后需要修改参数的名称，不然静态图模式下会报错。

from mindspore import nn
import mindspore.ops as ops

img_size = 28  # 训练图像长（宽）

class Generator(nn.Cell):
    def __init__(self, latent_size, auto_prefix=True):
        super(Generator, self).__init__(auto_prefix=auto_prefix)
        self.model = nn.SequentialCell()
        # [N, 100] -> [N, 128]
        # 输入一个100维的0～1之间的高斯分布，然后通过第一层线性变换将其映射到256维
        self.model.append(nn.Dense(latent_size, 128))
        self.model.append(nn.ReLU())
        # [N, 128] -> [N, 256]
        self.model.append(nn.Dense(128, 256))
        self.model.append(nn.BatchNorm1d(256))
        self.model.append(nn.ReLU())
        # [N, 256] -> [N, 512]
        self.model.append(nn.Dense(256, 512))
        self.model.append(nn.BatchNorm1d(512))
        self.model.append(nn.ReLU())
        # [N, 512] -> [N, 1024]
        self.model.append(nn.Dense(512, 1024))
        self.model.append(nn.BatchNorm1d(1024))
        self.model.append(nn.ReLU())
        # [N, 1024] -> [N, 784]
        # 经过线性变换将其变成784维
        self.model.append(nn.Dense(1024, img_size * img_size))
        # 经过Tanh激活函数是希望生成的假的图片数据分布能够在-1～1之间
        self.model.append(nn.Tanh())

    def construct(self, x):
        img = self.model(x)
        return ops.reshape(img, (-1, 1, 28, 28))

net_g = Generator(latent_size)
net_g.update_parameters_name('generator')

判别器

如前所述，判别器 Discriminator 是一个二分类网络模型，输出判定该图像为真实图的概率。主要通过一系列的 Dense 层和 LeakyReLU 层对其进行处理，最后通过 Sigmoid 激活函数，使其返回 [0, 1] 的数据范围内，得到最终概率。注意实例化判别器之后需要修改参数的名称，不然静态图模式下会报错。

 # 判别器
class Discriminator(nn.Cell):
    def __init__(self, auto_prefix=True):
        super().__init__(auto_prefix=auto_prefix)
        self.model = nn.SequentialCell()
        # [N, 784] -> [N, 512]
        self.model.append(nn.Dense(img_size * img_size, 512))  # 输入特征数为784，输出为512
        self.model.append(nn.LeakyReLU())  # 默认斜率为0.2的非线性映射激活函数
        # [N, 512] -> [N, 256]
        self.model.append(nn.Dense(512, 256))  # 进行一个线性映射
        self.model.append(nn.LeakyReLU())
        # [N, 256] -> [N, 1]
        self.model.append(nn.Dense(256, 1))
        self.model.append(nn.Sigmoid())  # 二分类激活函数，将实数映射到[0,1]

    def construct(self, x):
        x_flat = ops.reshape(x, (-1, img_size * img_size))
        return self.model(x_flat)

net_d = Discriminator()
net_d.update_parameters_name('discriminator')

损失函数和优化器

定义了 Generator 和 Discriminator 后，损失函数使用MindSpore中二进制交叉熵损失函数BCELoss ；这里生成器和判别器都是使用Adam优化器，但是需要构建两个不同名称的优化器，分别用于更新两个模型的参数，详情见下文代码。注意优化器的参数名称也需要修改。

lr = 0.0002  # 学习率

# 损失函数
adversarial_loss = nn.BCELoss(reduction='mean')

# 优化器
optimizer_d = nn.Adam(net_d.trainable_params(), learning_rate=lr, beta1=0.5, beta2=0.999)
optimizer_g = nn.Adam(net_g.trainable_params(), learning_rate=lr, beta1=0.5, beta2=0.999)
optimizer_g.update_parameters_name('optim_g')
optimizer_d.update_parameters_name('optim_d')

模型训练

训练分为两个主要部分。

第一部分是训练判别器。训练判别器的目的是最大程度地提高判别图像真伪的概率。按照原论文的方法，通过提高其随机梯度来更新判别器，最大化 l o g D ( x ) + l o g ( 1 − D ( G ( z ) ) log D(x) + log(1 - D(G(z)) logD(x)+log(1−D(G(z)) 的值。

第二部分是训练生成器。如论文所述，最小化 l o g ( 1 − D ( G ( z ) ) ) log(1 - D(G(z))) log(1−D(G(z))) 来训练生成器，以产生更好的虚假图像。

在这两个部分中，分别获取训练过程中的损失，并在每轮迭代结束时进行测试，将隐码批量推送到生成器中，以直观地跟踪生成器 Generator 的训练效果。

import os
import time
import matplotlib.pyplot as plt
import mindspore as ms
from mindspore import Tensor, save_checkpoint

total_epoch = 12  # 训练周期数
batch_size = 64  # 用于训练的训练集批量大小

# 加载预训练模型的参数
pred_trained = False
pred_trained_g = './result/checkpoints/Generator99.ckpt'
pred_trained_d = './result/checkpoints/Discriminator99.ckpt'

checkpoints_path = "./result/checkpoints"  # 结果保存路径
image_path = "./result/images"  # 测试结果保存路径

# 生成器计算损失过程
def generator_forward(test_noises):
    fake_data = net_g(test_noises)
    fake_out = net_d(fake_data)
    loss_g = adversarial_loss(fake_out, ops.ones_like(fake_out))
    return loss_g


# 判别器计算损失过程
def discriminator_forward(real_data, test_noises):
    fake_data = net_g(test_noises)
    fake_out = net_d(fake_data)
    real_out = net_d(real_data)
    real_loss = adversarial_loss(real_out, ops.ones_like(real_out))
    fake_loss = adversarial_loss(fake_out, ops.zeros_like(fake_out))
    loss_d = real_loss + fake_loss
    return loss_d

# 梯度方法
grad_g = ms.value_and_grad(generator_forward, None, net_g.trainable_params())
grad_d = ms.value_and_grad(discriminator_forward, None, net_d.trainable_params())

def train_step(real_data, latent_code):
    # 计算判别器损失和梯度
    loss_d, grads_d = grad_d(real_data, latent_code)
    optimizer_d(grads_d)
    loss_g, grads_g = grad_g(latent_code)
    optimizer_g(grads_g)

    return loss_d, loss_g

# 保存生成的test图像
def save_imgs(gen_imgs1, idx):
    for i3 in range(gen_imgs1.shape[0]):
        plt.subplot(5, 5, i3 + 1)
        plt.imshow(gen_imgs1[i3, 0, :, :] / 2 + 0.5, cmap="gray")
        plt.axis("off")
    plt.savefig(image_path + "/test_{}.png".format(idx))

# 设置参数保存路径
os.makedirs(checkpoints_path, exist_ok=True)
# 设置中间过程生成图片保存路径
os.makedirs(image_path, exist_ok=True)

net_g.set_train()
net_d.set_train()

# 储存生成器和判别器loss
losses_g, losses_d = [], []

for epoch in range(total_epoch):
    start = time.time()
    for (iter, data) in enumerate(mnist_ds):
        start1 = time.time()
        image, latent_code = data
        image = (image - 127.5) / 127.5  # [0, 255] -> [-1, 1]
        image = image.reshape(image.shape[0], 1, image.shape[1], image.shape[2])
        d_loss, g_loss = train_step(image, latent_code)
        end1 = time.time()
        if iter % 10 == 10:
            print(f"Epoch:[{int(epoch):>3d}/{int(total_epoch):>3d}], "
                  f"step:[{int(iter):>4d}/{int(iter_size):>4d}], "
                  f"loss_d:{d_loss.asnumpy():>4f} , "
                  f"loss_g:{g_loss.asnumpy():>4f} , "
                  f"time:{(end1 - start1):>3f}s, "
                  f"lr:{lr:>6f}")

    end = time.time()
    print("time of epoch {} is {:.2f}s".format(epoch + 1, end - start))

    losses_d.append(d_loss.asnumpy())
    losses_g.append(g_loss.asnumpy())

    # 每个epoch结束后，使用生成器生成一组图片
    gen_imgs = net_g(test_noise)
    save_imgs(gen_imgs.asnumpy(), epoch)

    # 根据epoch保存模型权重文件
    if epoch % 1 == 0:
        save_checkpoint(net_g, checkpoints_path + "/Generator%d.ckpt" % (epoch))
        save_checkpoint(net_d, checkpoints_path + "/Discriminator%d.ckpt" % (epoch))

运行结果

time of epoch 1 is 68.72s
time of epoch 2 is 6.78s
time of epoch 3 is 6.88s
time of epoch 4 is 7.12s
time of epoch 5 is 7.06s
time of epoch 6 is 6.72s
time of epoch 7 is 6.88s
time of epoch 8 is 6.81s
time of epoch 9 is 6.80s
time of epoch 10 is 6.77s
time of epoch 11 is 6.78s
time of epoch 12 is 6.86s

image.png

效果展示

运行下面代码，描绘D和G损失与训练迭代的关系图：

plt.figure(figsize=(6, 4))
plt.title("Generator and Discriminator Loss During Training")
plt.plot(losses_g, label="G", color='blue')
plt.plot(losses_d, label="D", color='orange')
plt.xlim(-5,15)
plt.ylim(0, 3.5)
plt.xlabel("iterations")
plt.ylabel("Loss")
plt.legend()
plt.show()

image.png

可视化训练过程中通过隐向量生成的图像。

import cv2
import matplotlib.animation as animation

# 将训练过程中生成的测试图转为动态图
image_list = []
for i in range(total_epoch):
    image_list.append(cv2.imread(image_path + "/test_{}.png".format(i), cv2.IMREAD_GRAYSCALE))
show_list = []
fig = plt.figure(dpi=70)
for epoch in range(0, len(image_list), 5):
    plt.axis("off")
    show_list.append([plt.imshow(image_list[epoch], cmap='gray')])

ani = animation.ArtistAnimation(fig, show_list, interval=1000, repeat_delay=1000, blit=True)
ani.save('train_test.gif', writer='pillow', fps=1)

image.png

从上面的图像可以看出，随着训练次数的增多，图像质量也越来越好。如果增大训练周期数，当 epoch 达到100以上时，生成的手写数字图片与数据集中的较为相似。下面我们通过加载生成器网络模型参数文件来生成图像，代码如下：

模型推理

下面我们通过加载生成器网络模型参数文件来生成图像，代码如下：

import mindspore as ms

# test_ckpt = './result/checkpoints/Generator199.ckpt'

# parameter = ms.load_checkpoint(test_ckpt)
# ms.load_param_into_net(net_g, parameter)
# 模型生成结果
test_data = Tensor(np.random.normal(0, 1, (25, 100)).astype(np.float32))
images = net_g(test_data).transpose(0, 2, 3, 1).asnumpy()
# 结果展示
fig = plt.figure(figsize=(3, 3), dpi=120)
for i in range(25):
    fig.add_subplot(5, 5, i + 1)
    plt.axis("off")
    plt.imshow(images[i].squeeze(), cmap="gray")
plt.show()

image.png

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/789883.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

机器学习和AI智能写作对未来文案编辑的影响

机器学习和AI智能写作对未来文案编辑的影响

欢迎关注小知：知孤云出岫 目录 机器学习和AI智能写作对未来文案编辑的影响1. 简介2. AI智能写作工具的现状3. AI智能写作的优势3.1 提高效率3.2 降低成本3.3 数据驱动的个性化 4. AI智能写作的挑战4.1 创造力和独创性4.2 道德和伦理问题4.3 技术限制 5. 行业变化5.…
阅读更多...
鸿蒙开发：每天一个小bug----鸿蒙开发路由跳转踩坑

鸿蒙开发：每天一个小bug----鸿蒙开发路由跳转踩坑

一、前言 报错内容显示找不到页面 ，肯定我们页面没写对呗！ 可能是这几个原因:1.main_pages.json没配置路由 {"src": ["pages/02/UserInfoClass","pages/02/AppStorageCase02"] } 2.跳转路径没写对 错误：…
阅读更多...
首次使用DevEcoStudio

首次使用DevEcoStudio

1、双击桌面快捷方式，进入首次运行的欢迎页面 由于咱们之前电脑上没有安装过此软件，所以直接保持默认选项不导入配置，然后点击🆗 2、进入到欢迎界面，勾选同意后点击Agree 3、进入到工具正式页面 4、点击右侧界面中的C…
阅读更多...
【js】js高精度加减乘除函数

【js】js高精度加减乘除函数

加法 /*** 高精度加法函数，处理字符串或数字输入，去除尾部多余的零* param {string|number} a - 被加数* param {string|number} b - 加数* returns {string} - 计算结果，去除尾部多余的零*/ export const add (a, b) > {// 将输入转换为…
阅读更多...
AirPods Pro新功能前瞻：iOS 18的五大创新亮点

AirPods Pro新功能前瞻：iOS 18的五大创新亮点

随着科技的不断进步，苹果公司一直在探索如何通过创新提升用户体验。iOS 18的推出，不仅仅是iPhone的一次系统更新，更是苹果生态链中重要一环——AirPods Pro的一次重大升级。 据悉，iOS 18将为AirPods Pro带来五项新功能&#xff0…
阅读更多...
985研究生8年终毕业，学位证颁发11天后被作废？

985研究生8年终毕业，学位证颁发11天后被作废？

“正常是学校颁证给学院，但学院就没告诉我，还把学校颁发的证书给撤销了，这中间学院并没有书面或电话告知我本人。”34岁读研，如今已42岁的内蒙古任女士回想起求学不易，很是心酸。 2015年3月，任女士考取2015…
阅读更多...
昇思25天学习打卡营第12天|Vision Transformer图像分类

昇思25天学习打卡营第12天|Vision Transformer图像分类

关于Vision Transformer Vision Transformer（ViT）结构和工作原理 ViT模型的主体结构是基于Transformer模型的Encoder部分 图像分块：ViT首先将输入图像分割成一系列固定大小的patch（例如16x16像素）。然后，…
阅读更多...
【正点原子i.MX93开发板试用连载体验】简单的音频分类

【正点原子i.MX93开发板试用连载体验】简单的音频分类

本文最早发表于电子发烧友论坛： 今天测试的内容是进行简单的音频分类。我们要想进行语音控制，就需要构建和训练一个基本的自动语音识别 (ASR) 模型来识别不同的单词。如果想了解这方面的知识可以参考TensorFlow的官方文档：简单的音频识别&…
阅读更多...
在2018.3没有找到对应的器件库，需要

在2018.3没有找到对应的器件库，需要

图中的器件在vivado中没有找到 一、添加器件 发现所有的2018.3的所有器件库，其实都已经安装了，那么意味着2018.3没有办法对该器件进行综合。 二、安装更新版本的vivado 重新安装的2022.2，在选择器件的时候，把所有的器件全部勾选…
阅读更多...
Quartus程序烧录

Quartus程序烧录

1. .sof文件烧录（断电丢失） （1）Programmer（程序设计） （2）Hardware Setup...（硬件设置） （如无USB-Blaster[USB-0]，在Hardware Setup..…
阅读更多...
TCP 握手数据流

TCP 握手数据流

这张图详细描述了 TCP 握手过程中，从客户端发送 SYN 包到服务器最终建立连接的整个数据流转过程，包括网卡、内核、进程中的各个环节。下面对每个步骤进行详细解释： 客户端到服务器的初始连接请求 客户端发送 SYN 包： 客户端发起…
阅读更多...
wmv如何转为mp4格式？推荐几个将wmv转换成MP4的方法

wmv如何转为mp4格式？推荐几个将wmv转换成MP4的方法

wmv如何转为mp4格式？在当今数字化和多媒体内容分享的时代，视频格式的转换变得至关重要。wmv作为一种常见的视频格式，在Windows系统中有较好的兼容性，但实际上存在多项严重问题。更为不利的是，由于wmv属于比较新的视频类…
阅读更多...
制作一个自动养号插件的必备源代码!

制作一个自动养号插件的必备源代码!

随着网络社交平台的日益繁荣，用户对于账号的维护和运营需求也日益增长，在这样的背景下，自动养号插件应运而生，成为了许多用户提升账号活跃度、增加曝光量的得力助手。 然而，制作一个高效、稳定的自动养号插件并非易事…
阅读更多...
AMD X3D CPU 史诗级进化，锐龙7 9800X3D默秒全

AMD X3D CPU 史诗级进化，锐龙7 9800X3D默秒全

6 月份刚刚结束，这有关下半年新一代 PC 硬件消息便愈发蠢蠢欲动起来。 上个月初台北国际电脑展上，AMD 正式公布了下一代 Zen 5 架构 Ryzen 9000 系列桌面处理器。 AMD 前脚刚大吹特吹性能吊锤 Intel i9 14900K 云云，没想到反手又来了一波被自…
阅读更多...
飞腾平台虚拟机组播性能调优指南

飞腾平台虚拟机组播性能调优指南

【写在前面】 飞腾开发者平台是基于飞腾自身强大的技术基础和开放能力，聚合行业内优秀资源而打造的。该平台覆盖了操作系统、算法、数据库、安全、平台工具、虚拟化、存储、网络、固件等多个前沿技术领域，包含了应用使能套件、软件仓库、软件支持、软件适…
阅读更多...
【45 Pandas+Pyecharts | 去哪儿海南旅游攻略数据分析可视化】

【45 Pandas+Pyecharts | 去哪儿海南旅游攻略数据分析可视化】

文章目录 🏳️‍🌈 1. 导入模块🏳️‍🌈 2. Pandas数据处理2.1 读取数据2.2 查看数据信息2.3 日期处理，提取年份、月份2.4 经费处理2.5 天数处理 🏳️‍🌈 3. Pyecharts数据可视化3.1 出发日期_…
阅读更多...
Vatee万腾平台：智慧生活的无限可能

Vatee万腾平台：智慧生活的无限可能

在科技日新月异的今天，我们的生活正被各种智能技术悄然改变。从智能家居到智慧城市，从个人健康管理到企业数字化转型，科技的力量正以前所未有的速度渗透到我们生活的每一个角落。而在这场智能革命的浪潮中，Vatee万腾平台以其卓越的…
阅读更多...
【想要了解Anaconda介绍、安装配置及使用，看这篇文章就够了】

【想要了解Anaconda介绍、安装配置及使用，看这篇文章就够了】

一、Anaconda介绍及安装配置 1、Anaconda简介 Anaconda是一个用于科学计算的 Python 发行版，支持 Linux, Mac, Windows, 包含conda、Python等190多个科学包及其依赖项。它便于获取和管理包，包括python和许多常用软件库（如numpy、pandas等&a…
阅读更多...
数据库基础练习4

数据库基础练习4

准备 create table dept (dept1 int ,dept_name varchar(11)) charsetutf8; create table emp (sid int ,name varchar(11),age int,worktime_start date,incoming int,dept2 int) charsetutf8;insert into dept values(101,财务),(102,销售),(103,IT技术),(104,行政);INSERT …
阅读更多...
如何分辨AI生成的内容？AI生成内容检测工具对比实验

如何分辨AI生成的内容？AI生成内容检测工具对比实验

检测人工智能生成的文本对各个领域的组织都提出了挑战，包括学术界和新闻界等。生成式AI与大语言模型根据短描述来进行内容生成的能力，产生了一个问题：这篇文章/内容/作业/图像到底是由人类创作的，还是AI创作的？虽然 LL…
阅读更多...
最新文章

Copyright @ 2022~2023