PyTorch随笔 – 生成对抗网络的改进cGAN和LSGAN

欢迎关注我的CSDN：https://spike.blog.csdn.net/
本文地址：https://blog.csdn.net/caroline_wendy/article/details/129939225

本文介绍GAN的两个常见改进，cGAN和LSGAN，两者一般结合使用。

cGAN: Conditional Generative Adversarial Nets，条件GAN
LSGAN: Least Squares Generative Adversarial Networks，最小平方GAN

GAN

GAN，即生成对抗网络，是一种基于博弈论的生成模型，由两个神经网络组成：生成器（G）和判别器（D）。生成器的目标是从一个随机噪声向量生成与真实数据分布相似的样本，而判别器的目标是区分输入的样本是真实的还是生成的。两者相互竞争，最终达到一个纳什均衡，即生成器可以欺骗判别器，而判别器无法区分真假样本。

在训练GAN的过程中，建议使用 Spectral Normalization 优化网络层。

Spectral Normalization，即谱正则化，可以有效地控制网络的 Lipschitz 常数，从而，提高网络的泛化能力和稳定性。Spectral Normalization 的基本思想是在每一层的权重矩阵W上施加一个谱范数约束，使得其最大奇异值不超过一个预设的阈值，例如1。这样，可以避免网络在训练过程中出现梯度爆炸或消失的问题，也可以防止生成对抗网络中的模式崩溃现象。Spectral Normalization 可以很容易地应用于各种类型的神经网络，包括卷积神经网络、循环神经网络和生成对抗网络，只需要在每一层的前向传播和反向传播中增加一些简单的计算步骤，而不需要改变网络的结构或超参数。

标准GAN源码：

#!/usr/bin/env python
# -- coding: utf-8 --
"""
Copyright (c) 2022. All rights reserved.
Created by C. L. Wang on 2023/4/3
"""import os
import timeimport numpy as np
import torch
import torch.nn as nn
import torchvisionimage_size = [1, 28, 28]
latent_dim = 96
batch_size = 1024
use_gpu = torch.cuda.is_available()
save_dir = "gan_images"
os.makedirs(save_dir, exist_ok=True)class Generator(nn.Module):"""生成器数据torchvision.datasets.MNIST"""def __init__(self):super(Generator, self).__init__()self.model = nn.Sequential(nn.Linear(latent_dim, 128),nn.BatchNorm1d(128),nn.GELU(),nn.Linear(128, 256),nn.BatchNorm1d(256),nn.GELU(),nn.Linear(256, 512),nn.BatchNorm1d(512),nn.GELU(),nn.Linear(512, 1024),nn.BatchNorm1d(1024),nn.GELU(),nn.Linear(1024, np.prod(image_size, dtype=np.int32)),# nn.Tanh(),nn.Sigmoid(),)def forward(self, z):"""shape of z: [batchsize, latent_dim]随机高斯分布z生成图像"""output = self.model(z)image = output.reshape(z.shape[0], *image_size)return imageclass Discriminator(nn.Module):"""判别器"""def __init__(self):super(Discriminator, self).__init__()self.model = nn.Sequential(nn.Linear(np.prod(image_size, dtype=np.int32), 512),nn.GELU(),# nn.Linear(512, 256),nn.utils.spectral_norm(nn.Linear(512, 256)),  # 谱归一化nn.GELU(),# nn.Linear(256, 128),nn.utils.spectral_norm(nn.Linear(256, 128)),nn.GELU(),# nn.Linear(128, 64),nn.utils.spectral_norm(nn.Linear(128, 64)),nn.GELU(),# nn.Linear(64, 32),nn.utils.spectral_norm(nn.Linear(64, 32)),nn.GELU(),# nn.Linear(32, 1),nn.utils.spectral_norm(nn.Linear(32, 1)),nn.Sigmoid())def forward(self, img):"""shape of img: [batchsize, 1, 28, 28]"""prob = self.model(img.reshape(img.shape[0], -1))  # 只保留第0维return prob# Training
transform = torchvision.transforms.Compose([torchvision.transforms.Resize(28),torchvision.transforms.ToTensor(),  # [0, 1]# torchvision.transforms.Normalize(mean=[0.5], std=[0.5])  # [-1, 1]])
dataset = torchvision.datasets.MNIST("mnist_data", train=True, download=True, transform=transform)
print(f"[Info] dataset: {len(dataset)}")
# for i in range(len(dataset)):
#     if i < 5:
#         print(dataset[i][0].shape)dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True, drop_last=True, num_workers=20)generator = Generator()
discriminator = Discriminator()g_optimizer = torch.optim.Adam(generator.parameters(), lr=0.0003, betas=(0.4, 0.8), weight_decay=0.0001)
d_optimizer = torch.optim.Adam(discriminator.parameters(), lr=0.0003, betas=(0.4, 0.8), weight_decay=0.0001)loss_fn = torch.nn.BCELoss()
labels_one = torch.ones(batch_size, 1)
labels_zero = torch.zeros(batch_size, 1)if use_gpu:print("use gpu for training!")generator = generator.cuda()discriminator = discriminator.cuda()loss_fn = loss_fn.cuda()labels_one = labels_one.to("cuda")labels_zero = labels_zero.to("cuda")num_epoch = 1000for epoch in range(num_epoch):s_time = time.time()for idx, mini_batch in enumerate(dataloader):gt_images, _ = mini_batch# print(f"[Info] gt_images.shape: {gt_images.shape}")z = torch.randn(batch_size, latent_dim)if use_gpu:gt_images = gt_images.cuda()z = z.cuda()pred_images = generator(z)g_optimizer.zero_grad()  # 生成器的优化recons_loss = torch.abs(pred_images - gt_images).mean()  # 重构loss# 预测为真实数据1g_loss = recons_loss * 0.05 + loss_fn(discriminator(pred_images), labels_one)g_loss.backward()g_optimizer.step()d_optimizer.zero_grad()real_loss = loss_fn(discriminator(gt_images), labels_one)fake_loss = loss_fn(discriminator(pred_images.detach()), labels_zero)  # 生成照片d_loss = real_loss + fake_lossd_loss.backward()d_optimizer.step()# 判别器的优化if idx % 50 == 0:print(f"step: {len(dataloader)*epoch + idx}, recons_loss: {recons_loss.item()}, "f"g_loss: {g_loss.item()}, d_loss: {d_loss.item()}, real_loss: {real_loss}, fake_loss: {fake_loss}")if idx % 800 == 0:image = pred_images[:64].data# 保存照片torchvision.utils.save_image(image, f"{save_dir}/image_{str(len(dataloader)*epoch + idx).zfill(6)}.png")

输出image_030044.png，训练效果如下：

cGAN

论文：cGAN – Conditional Generative Adversarial Nets，条件GAN

引用量4000多次
cGAN的作者是Mehdi Mirza和Simon Osindero，加拿大蒙特利尔大学的博士生和博士后。在2014年发表了一篇论文，介绍了CGAN的原理和应用，他们的研究受到了Yann LeCun和Yoshua Bengio等人的指导和支持。

其中，cGAN 与 GAN 的差别是，cGAN 在生成和判别的过程中都加入了条件变量，比如类别标签、图像特征等。这样可以使得生成器能够根据指定的条件生成相应的数据，而判别器能够根据条件判断数据的真实性。cGAN 可以解决 GAN 的一些问题，比如模式崩溃、生成数据的多样性不足等。cGAN 也可以应用于更多的领域，比如图像转换、文本生成、语音合成等。

GAN的公式，如下：

cGAN的公式，如下：

源码如下：

#!/usr/bin/env python
# -- coding: utf-8 --
"""
Copyright (c) 2022. All rights reserved.
Created by C. L. Wang on 2023/4/3
"""import os
import timeimport numpy as np
import torch
import torch.nn as nn
import torchvisionimage_size = [1, 28, 28]
latent_dim = 96
label_emb_dim = 32  # 标签的嵌入维度
batch_size = 1024
use_gpu = torch.cuda.is_available()
save_dir = "cgan_images"  # 输出文件夹
os.makedirs(save_dir, exist_ok=True)class Generator(nn.Module):"""生成器数据torchvision.datasets.MNIST"""def __init__(self):super(Generator, self).__init__()self.embedding = nn.Embedding(10, label_emb_dim)  # 将10维标签映射为嵌入表征self.model = nn.Sequential(nn.Linear(latent_dim + label_emb_dim, 128),  # 输入维度增加nn.BatchNorm1d(128),nn.GELU(),nn.Linear(128, 256),nn.BatchNorm1d(256),nn.GELU(),nn.Linear(256, 512),nn.BatchNorm1d(512),nn.GELU(),nn.Linear(512, 1024),nn.BatchNorm1d(1024),nn.GELU(),nn.Linear(1024, np.prod(image_size, dtype=np.int32)),# nn.Tanh(),nn.Sigmoid(),)def forward(self, z, labels):"""shape of z: [batchsize, latent_dim]随机高斯分布z生成图像"""label_embedding = self.embedding(labels)z = torch.cat([z, label_embedding], dim=-1)  # 将条件也作为输入output = self.model(z)image = output.reshape(z.shape[0], *image_size)return imageclass Discriminator(nn.Module):"""判别器"""def __init__(self):super(Discriminator, self).__init__()self.embedding = nn.Embedding(10, label_emb_dim)self.model = nn.Sequential(nn.Linear(np.prod(image_size, dtype=np.int32) + label_emb_dim, 512),    # 输入维度增加nn.GELU(),# nn.Linear(512, 256),nn.utils.spectral_norm(nn.Linear(512, 256)),  # 谱归一化nn.GELU(),# nn.Linear(256, 128),nn.utils.spectral_norm(nn.Linear(256, 128)),nn.GELU(),# nn.Linear(128, 64),nn.utils.spectral_norm(nn.Linear(128, 64)),nn.GELU(),# nn.Linear(64, 32),nn.utils.spectral_norm(nn.Linear(64, 32)),nn.GELU(),# nn.Linear(32, 1),nn.utils.spectral_norm(nn.Linear(32, 1)),nn.Sigmoid())def forward(self, img, labels):"""shape of img: [batchsize, 1, 28, 28]"""label_embedding = self.embedding(labels)  # 离散变量转换为连续变量model_input = torch.cat([img.reshape(img.shape[0], -1), label_embedding], dim=-1)prob = self.model(model_input)  # 只保留第0维return prob# Training
transform = torchvision.transforms.Compose([torchvision.transforms.Resize(28),torchvision.transforms.ToTensor(),  # [0, 1]# torchvision.transforms.Normalize(mean=[0.5], std=[0.5])  # [-1, 1]])
dataset = torchvision.datasets.MNIST("mnist_data", train=True, download=True, transform=transform)
print(f"[Info] dataset: {len(dataset)}")
# for i in range(len(dataset)):
#     if i < 5:
#         print(dataset[i][0].shape)dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True, drop_last=True, num_workers=20)generator = Generator()
discriminator = Discriminator()g_optimizer = torch.optim.Adam(generator.parameters(), lr=0.0003, betas=(0.4, 0.8), weight_decay=0.0001)
d_optimizer = torch.optim.Adam(discriminator.parameters(), lr=0.0003, betas=(0.4, 0.8), weight_decay=0.0001)loss_fn = torch.nn.BCELoss()
labels_one = torch.ones(batch_size, 1)
labels_zero = torch.zeros(batch_size, 1)if use_gpu:print("use gpu for training!")generator = generator.cuda()discriminator = discriminator.cuda()loss_fn = loss_fn.cuda()labels_one = labels_one.to("cuda")labels_zero = labels_zero.to("cuda")num_epoch = 1000for epoch in range(num_epoch):s_time = time.time()for idx, mini_batch in enumerate(dataloader):gt_images, labels = mini_batch  # 需要输入标签# print(f"[Info] gt_images.shape: {gt_images.shape}")z = torch.randn(batch_size, latent_dim)if use_gpu:gt_images = gt_images.cuda()labels = labels.cuda()z = z.cuda()pred_images = generator(z, labels)g_optimizer.zero_grad()  # 生成器的优化recons_loss = torch.abs(pred_images - gt_images).mean()  # 重构loss# 预测为真实数据1g_loss = recons_loss * 0.05 + loss_fn(discriminator(pred_images, labels), labels_one)g_loss.backward()g_optimizer.step()d_optimizer.zero_grad()real_loss = loss_fn(discriminator(gt_images, labels), labels_one)fake_loss = loss_fn(discriminator(pred_images.detach(), labels), labels_zero)  # 生成照片d_loss = real_loss + fake_lossd_loss.backward()d_optimizer.step()# 判别器的优化if idx % 50 == 0:print(f"step: {len(dataloader)*epoch + idx}, recons_loss: {recons_loss.item()}, "f"g_loss: {g_loss.item()}, d_loss: {d_loss.item()}, real_loss: {real_loss}, fake_loss: {fake_loss}")if idx % 800 == 0:image = pred_images[:64].data# 保存照片torchvision.utils.save_image(image, f"{save_dir}/image_{str(len(dataloader)*epoch + idx).zfill(6)}.png")

输出image_030044.png，cGAN优于GAN，训练效果如下：

LSGAN

论文：LSGAN – Least Squares Generative Adversarial Networks，最小平方GAN

引用量3000多次

其中，LSGAN 和 GAN 是两种生成对抗网络的变体，都可以用于生成逼真的图像。主要区别在于损失函数的设计，GAN 使用了交叉熵损失函数，要求判别器输出生成图像和真实图像的概率。这样的损失函数，可能导致梯度消失的问题，使得生成器难以学习。LSGAN 使用了最小二乘损失函数，要求判别器输出生成图像和真实图像的分数，这样的损失函数可以提供更多的梯度信息，使得生成器更容易学习。LSGAN 还可以减少模式崩溃的现象，即生成器只能生成有限种类的图像。总之，LSGAN 是一种改进了 GAN 的损失函数的方法，可以提高生成图像的质量和多样性。

LSGAN的公式，如下

由于Sigmoid+交叉熵损失导致梯度消失，因此替换为L2损失，即：

import torch
import torch.nn as nn
import matplotlib.pyplot as plt# sigmoid ce 图像
logits = torch.linspace(-10, 10, 2000)loss = []
loss_fn = nn.BCELoss()for lgs in logits:loss.append(loss_fn(torch.sigmoid(lgs), torch.ones_like(lgs)))plt.plot(logits, loss)
plt.show()

Sigmoid+交叉熵损失的效果：

其中，LSGAN公式中，a、b、c的数值约束：

约束：b – c = 1，b – a = 2，例如：a = -1、b = 1、c = 0 或者 b = c = 1，a = 0，第二种方案更优，也更常见。

同时使用LSGAN + cGAN的源码，如下：

#!/usr/bin/env python
# -- coding: utf-8 --
"""
Copyright (c) 2022. All rights reserved.
Created by C. L. Wang on 2023/4/3
"""import os
import timeimport numpy as np
import torch
import torch.nn as nn
import torchvisionimage_size = [1, 28, 28]
latent_dim = 96
label_emb_dim = 32  # 标签的嵌入维度
batch_size = 1024
use_gpu = torch.cuda.is_available()
save_dir = "ls_cgan_images"  # 输出文件夹
os.makedirs(save_dir, exist_ok=True)class Generator(nn.Module):"""生成器数据torchvision.datasets.MNIST"""def __init__(self):super(Generator, self).__init__()self.embedding = nn.Embedding(10, label_emb_dim)  # 将10维标签映射为嵌入表征self.model = nn.Sequential(nn.Linear(latent_dim + label_emb_dim, 128),  # 输入维度增加nn.BatchNorm1d(128),nn.GELU(),nn.Linear(128, 256),nn.BatchNorm1d(256),nn.GELU(),nn.Linear(256, 512),nn.BatchNorm1d(512),nn.GELU(),nn.Linear(512, 1024),nn.BatchNorm1d(1024),nn.GELU(),nn.Linear(1024, np.prod(image_size, dtype=np.int32)),# nn.Tanh(),nn.Sigmoid(),)def forward(self, z, labels):"""shape of z: [batchsize, latent_dim]随机高斯分布z生成图像"""label_embedding = self.embedding(labels)z = torch.cat([z, label_embedding], dim=-1)  # 将条件也作为输入output = self.model(z)image = output.reshape(z.shape[0], *image_size)return imageclass Discriminator(nn.Module):"""判别器"""def __init__(self):super(Discriminator, self).__init__()self.embedding = nn.Embedding(10, label_emb_dim)self.model = nn.Sequential(nn.Linear(np.prod(image_size, dtype=np.int32) + label_emb_dim, 512),    # 输入维度增加nn.GELU(),# nn.Linear(512, 256),nn.utils.spectral_norm(nn.Linear(512, 256)),  # 谱归一化nn.GELU(),# nn.Linear(256, 128),nn.utils.spectral_norm(nn.Linear(256, 128)),nn.GELU(),# nn.Linear(128, 64),nn.utils.spectral_norm(nn.Linear(128, 64)),nn.GELU(),# nn.Linear(64, 32),nn.utils.spectral_norm(nn.Linear(64, 32)),nn.GELU(),# nn.Linear(32, 1),nn.utils.spectral_norm(nn.Linear(32, 1)),nn.Sigmoid())def forward(self, img, labels):"""shape of img: [batchsize, 1, 28, 28]"""label_embedding = self.embedding(labels)  # 离散变量转换为连续变量model_input = torch.cat([img.reshape(img.shape[0], -1), label_embedding], dim=-1)prob = self.model(model_input)  # 只保留第0维return prob# Training
transform = torchvision.transforms.Compose([torchvision.transforms.Resize(28),torchvision.transforms.ToTensor(),  # [0, 1]# torchvision.transforms.Normalize(mean=[0.5], std=[0.5])  # [-1, 1]])
dataset = torchvision.datasets.MNIST("mnist_data", train=True, download=True, transform=transform)
print(f"[Info] dataset: {len(dataset)}")
# for i in range(len(dataset)):
#     if i < 5:
#         print(dataset[i][0].shape)dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True, drop_last=True, num_workers=20)generator = Generator()
discriminator = Discriminator()g_optimizer = torch.optim.Adam(generator.parameters(), lr=0.0003, betas=(0.4, 0.8), weight_decay=0.0001)
d_optimizer = torch.optim.Adam(discriminator.parameters(), lr=0.0003, betas=(0.4, 0.8), weight_decay=0.0001)# loss_fn = torch.nn.BCELoss()
loss_fn = torch.nn.MSELoss()  # LSGAN Least Squares
labels_one = torch.ones(batch_size, 1)
labels_zero = torch.zeros(batch_size, 1)if use_gpu:print("use gpu for training!")generator = generator.cuda()discriminator = discriminator.cuda()loss_fn = loss_fn.cuda()labels_one = labels_one.to("cuda")labels_zero = labels_zero.to("cuda")num_epoch = 1000for epoch in range(num_epoch):s_time = time.time()for idx, mini_batch in enumerate(dataloader):gt_images, labels = mini_batch  # 需要输入标签# print(f"[Info] gt_images.shape: {gt_images.shape}")z = torch.randn(batch_size, latent_dim)if use_gpu:gt_images = gt_images.cuda()labels = labels.cuda()z = z.cuda()pred_images = generator(z, labels)g_optimizer.zero_grad()  # 生成器的优化recons_loss = torch.abs(pred_images - gt_images).mean()  # 重构loss# 预测为真实数据1g_loss = recons_loss * 0.05 + loss_fn(discriminator(pred_images, labels), labels_one)g_loss.backward()g_optimizer.step()d_optimizer.zero_grad()real_loss = loss_fn(discriminator(gt_images, labels), labels_one)fake_loss = loss_fn(discriminator(pred_images.detach(), labels), labels_zero)  # 生成照片d_loss = real_loss + fake_lossd_loss.backward()d_optimizer.step()# 判别器的优化if idx % 50 == 0:print(f"step: {len(dataloader)*epoch + idx}, recons_loss: {recons_loss.item()}, "f"g_loss: {g_loss.item()}, d_loss: {d_loss.item()}, real_loss: {real_loss}, fake_loss: {fake_loss}")if idx % 800 == 0:image = pred_images[:64].data# 保存照片torchvision.utils.save_image(image, f"{save_dir}/image_{str(len(dataloader)*epoch + idx).zfill(6)}.png")

输出image_030044.png，训练效果如下：

That’s all!

查看全文

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

如若内容造成侵权/违法违规/事实不符，请联系一条长河网进行投诉反馈，一经查实，立即删除！

PyTorch随笔 – 生成对抗网络的改进cGAN和LSGAN

欢迎关注我的CSDN：https://spike.blog.csdn.net/ 本文地址：https://blog.csdn.net/caroline_wendy/article/details/129939225 本文介绍GAN的两个常见改进，cGAN和LSGAN，两者一般结合使用。
cGAN: Conditional Generative Adversa……

编程日记2023/4/3 22:11:57

ROS移动机器人 Solidworks整个机器人设计文件（三维激光雷达 arduino nvidia）（SLDPRT SLDASM）

还是17年本科时制作的毕业设计，基于solidworks 2014所制作。
文件里包含了制作的整个移动机器人的SolidWorks原文件。
是设计完各个零件然后组合在一起的，所以适用性很强，可以根据你的需求将绘制的零件加到你的机器人solidwroks三维中&……

编程日记2023/4/3 22:11:11

IOC、AOP以及spring框架的面试汇总

一、控制反转（IOC）
将创建管理对象的工作交给容器来做。在容器初始化（或在某个时间节点）通过反射机制创建好对象，在使用时直接从容器中获取。
控制反转：将对象的控制权反过来交给容器管理。
官方解释
控……

编程日记2023/4/3 22:10:19

2021蓝桥杯真题格点（填空题） C语言/C++

问题描述如果一个点(x,y) 的两维坐标都是整数, 即 x∈Z 且 y∈Z, 则称这个点为一个格点。
如果一个点 (x,y) 的两维坐标都是正数, 即 x>0 且 y>0, 则称这个点在第一象限。
请问在第一象限的格点中, 有多少个点(x,y) 的两维坐标乘积不超过 2021 , 即x⋅y≤2021 。
掟……

编程日记2023/4/3 22:10:05

ubuntu20 caffe opencv4 conda python3.7.10

如果你只想要pycaffe，那可以condapython3.7.10，然后conda install caffe-gpu
环境
ubuntu20 cuda11.7 cudnn8（不过caffe似乎不能加速cudnn8） conda python3.7.10 假设你已经装了opencv4，cuda11.7，cudnn8 ……

编程日记2023/4/3 22:09:51

【数据库管理】①① Oracle逻辑存储架构

1. Tablespace表空间
1.1 TBS的分类 TBS（Tablespace）是Oracle数据库中用于存储数据和索引的逻辑存储单元，可以将不同的数据和索引存储在不同的TBS中，以便于管理和维护。根据不同的管理和维护需求，TBS可以分为以下几类……

编程日记2023/4/3 22:09:40

OCR部署使用

文章目录一、项目介绍二、服务端部署步骤一：导入 Docker 镜像步骤二：启动并进入容器步骤三：启动服务端程序三、安卓端使用一、项目介绍
OCR 项目分为安卓端和服务端两部分。安卓端选择图片并对图片进行矫正，矫正后的图片将传送到……

编程日记2023/4/3 22:08:58

零基础学SQL（十二、存储过程）

目录
前言
一、什么是存储过程
二、为什么使用存储过程
三、创建存储过程
1、创建存储过程语法
2、创建无参存储过程 3、创建有参存过
4、检查存过四、游标介绍
1、什么是游标
2、使用游标前言原本是不打算写这一篇存储过程的文章的，因为目前大数据时代……

编程日记2023/4/3 22:08:47

线性回归判断能否与预测

#判断适合不适合做回归分析
# 导入库
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import sklearn
from sklearn.linear_model import LinearRegression# 读取数据
data pd.read_excel(data1.xlsx)
X data.iloc[:, :-1].values # 特征, 取所有行……

编程日记2023/4/3 22:08:21

STM32常用数据类型及其取值范围

带符号数：
typedef signed char int8_t; // -128~127
typedef signed short int int16_t; // -32768~32767
typedef signed int int32_t; // -2147483648~2147483647
typedef s……

编程日记2023/4/3 22:08:20

HR：面试官最爱问的linux问题，看看你能答对多少

文章目录摘要Linux的文件系统是什么样子的？如何访问和管理文件和目录？如何在Linux中查看和管理进程？如何使用Linux命令行工具来查看系统资源使用情况？如何配置Linux系统的网络设置？如何使用Linux的cron任务调度器来执行……

编程日记2023/4/16 14:56:56

vscode开发常用的工具栏选项,查看源码技巧以及【vscode常用的快捷键】

一、开发常用的工具栏选项
1、当前打开的文件快速在左侧资源树中定位：其实打开了当前的文件已经有在左侧资源树木定位了，只是颜色比较浅 2、打开太多文件的时候，可以关闭 3、设置查看当前类或文件的结构 OUTLINE
相当于idea 查看当前类或接……

编程日记2023/4/16 14:56:45

数据要素化条件之一：原始性

随着技术的发展，计算机不仅成为人类处理信息的工具，而且逐渐地具有自主处理数据的能力，出现了替代人工的数据智能技术。数据智能的大规模使用需要关于同一分析对象或同一问题的、来源于不同数据源的海量数据。这种数据必须是针对特定对象的记……

编程日记2023/4/16 14:56:36

【面试题高逼格利用类实现加法】编写代码, 实现多线程数组求和.

编写代码, 实现多线程数组求和.关键1. 数组的初始化关键2. 奇偶的相加import java.util.Random;public class Thread_2533 {public static void main(String[] args) throws InterruptedException {// 记录开始时间long start System.currentTimeMillis();// 1. 给定一个很长的……

编程日记2023/4/16 14:56:10

一个python训练

美国:28:麻省理工学院,斯坦福大学,哈佛大学,加州理工学院,芝加哥大学,普林斯顿大学,宾夕法尼亚大学,耶鲁大学,康奈尔大学,哥伦比亚大学,密歇根大学安娜堡分校,约翰霍普金斯大学,西北大学,加州大学伯克利分校,纽约大学,加州大学洛杉矶分校,杜克大学,卡内基梅隆大学,加州大学圣地……

编程日记2023/4/16 14:55:59

Mybatis03学习笔记

目录使用注解开发
设置事务自动提交
mybatis运行原理
注解CRUD
lombok使用（偷懒神器，大神都不建议使用）
复杂查询环境（多对一）
复杂查询环境（一对多）
动态sql环境搭建
动态sql常用标签……

编程日记2023/4/16 14:55:50 PyTorch随笔 – 生成对抗网络的改进cGAN和LSGAN-编程之家

设置或取得c# NumericUpDown 编辑框值的方法,(注意：不是Value值)

本人在C#开发中使用到了NumericUpDown控件，但是发现该控件不能直接控制显示值，经研究得到下面的解决办法
NumericUpDown由于是由多个控件组合而来的控件，其中包含一个类似TextBox的控件，若想取得或改变其中的值要使用如下方法
N……

编程日记2023/4/16 14:55:46 PyTorch随笔 – 生成对抗网络的改进cGAN和LSGAN-编程之家

使用NPOI 技术的SetColumnWidth 精确控制列宽不能成功的解决办法（C#）

在使用NPOI技术开发自动操作EXCEL软件时遇到不能精确设置列宽的问题。
如
ISheet sheet1 hssfworkbook.CreateSheet("Sheet1");
sheet1.SetColumnWidth(0, 50 * 256); // 在EXCEL文档中实际列宽为49.29
sheet1.SetColumnWidth(1, 100 * 256); // 在EXCEL文……

编程日记2023/4/16 14:55:46 PyTorch随笔 – 生成对抗网络的改进cGAN和LSGAN-编程之家

Mysql 数据库zip版安装时basedir datadir 路径设置问题，避免转义符的影响

本人在开发Mysql数据库自动安装程序时遇到个很奇怪的问题，其中my.ini的basedir 的路径设置是下面这样的：
basedir d:\测试\test\mysql
但是在使用mysqld安装mysql服务时老是启动不了，报1067错误，后来查看window事件发现一个独特……

编程日记2023/4/16 14:55:45

java stream sorted排序考虑null值

项目里使用到排序, java里没有像C# 里的linq，只有stream,查找stream.sorted源码看到有个
Comparator.nullsLast
然后看了一下实现，果然是能够处理null值的排序，如：minPriceList.stream().sorted(Comparator.comparing(l -> l.g……

编程日记2023/4/16 14:55:45