【机器学习】机器学习的重要技术——生成对抗网络：理论、算法与实践

引言

生成对抗网络（Generative Adversarial Networks, GANs）由Ian Goodfellow等人在2014年提出，通过生成器和判别器两个神经网络的对抗训练，成功实现了高质量数据的生成。GANs在图像生成、数据增强、风格迁移等领域取得了显著成果，成为深度学习的重要分支。本文将深入探讨GANs的基本原理、核心算法及其在实际中的应用，并提供代码示例以帮助读者更好地理解和掌握这一技术。
在这里插入图片描述

第一章 GANs的基本概念

1.1 什么是生成对抗网络

生成对抗网络由两个相互对抗的神经网络组成：生成器（Generator）和判别器（Discriminator）。生成器负责生成与真实数据相似的假数据，判别器负责区分真实数据和生成数据。生成器和判别器通过对抗训练，最终生成器能够生成逼真的数据，判别器难以区分其真伪。

1.2 GANs的基本结构
  • 生成器（Generator）：接受随机噪声作为输入，生成与真实数据分布相似的样本。
  • 判别器（Discriminator）：接受真实数据和生成数据作为输入，输出区分它们的概率。

GANs的目标是通过对抗训练，使得生成器生成的数据与真实数据无法区分，从而实现高质量的数据生成。

1.3 GANs的训练过程

GANs的训练过程可以概括为以下步骤：

  1. 初始化：随机初始化生成器和判别器的参数。
  2. 判别器训练：固定生成器的参数，更新判别器的参数，使其能够更好地区分真实数据和生成数据。
  3. 生成器训练：固定判别器的参数，更新生成器的参数，使其生成的数据能够欺骗判别器。
  4. 迭代：重复步骤2和3，直到生成器生成的数据与真实数据难以区分。

第二章 GANs的核心算法

2.1 标准GANs

标准GANs的损失函数由生成器和判别器的对抗损失组成。判别器的目标是最大化正确分类的概率，生成器的目标是最小化生成数据被判别器识别为假的概率。

import tensorflow as tf
from tensorflow.keras import layers

# 生成器模型
def build_generator():
    model = tf.keras.Sequential()
    model.add(layers.Dense(256, activation='relu', input_dim=100))
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU(alpha=0.2))
    model.add(layers.Dense(512, activation='relu'))
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU(alpha=0.2))
    model.add(layers.Dense(1024, activation='relu'))
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU(alpha=0.2))
    model.add(layers.Dense(28 * 28 * 1, activation='tanh'))
    model.add(layers.Reshape((28, 28, 1)))
    return model

# 判别器模型
def build_discriminator():
    model = tf.keras.Sequential()
    model.add(layers.Flatten(input_shape=(28, 28, 1)))
    model.add(layers.Dense(512, activation='relu'))
    model.add(layers.LeakyReLU(alpha=0.2))
    model.add(layers.Dense(256, activation='relu'))
    model.add(layers.LeakyReLU(alpha=0.2))
    model.add(layers.Dense(1, activation='sigmoid'))
    return model

# 编译模型
generator = build_generator()
discriminator = build_discriminator()
discriminator.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# GAN模型
discriminator.trainable = False
gan_input = layers.Input(shape=(100,))
generated_image = generator(gan_input)
gan_output = discriminator(generated_image)
gan = tf.keras.models.Model(gan_input, gan_output)
gan.compile(optimizer='adam', loss='binary_crossentropy')

# 加载MNIST数据集
(x_train, _), (_, _) = tf.keras.datasets.mnist.load_data()
x_train = (x_train.astype('float32') - 127.5) / 127.5
x_train = np.expand_dims(x_train, axis=3)

# 训练GANs
batch_size = 128
epochs = 10000
half_batch = int(batch_size / 2)

for epoch in range(epochs):
    # 训练判别器
    idx = np.random.randint(0, x_train.shape[0], half_batch)
    real_images = x_train[idx]
    noise = np.random.normal(0, 1, (half_batch, 100))
    generated_images = generator.predict(noise)
    d_loss_real = discriminator.train_on_batch(real_images, np.ones((half_batch, 1)))
    d_loss_fake = discriminator.train_on_batch(generated_images, np.zeros((half_batch, 1)))
    d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

    # 训练生成器
    noise = np.random.normal(0, 1, (batch_size, 100))
    valid_y = np.array([1] * batch_size)
    g_loss = gan.train_on_batch(noise, valid_y)

    if epoch % 1000 == 0:
        print(f"{epoch} [D loss: {d_loss[0]} | D accuracy: {100 * d_loss[1]}] [G loss: {g_loss}]")
2.2 深度卷积生成对抗网络（DCGAN）

DCGAN通过在生成器和判别器中引入卷积层，显著提高了图像生成的质量。以下是一个基于DCGAN的示例。

def build_generator():
    model = tf.keras.Sequential()
    model.add(layers.Dense(7 * 7 * 256, use_bias=False, input_shape=(100,)))
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU())
    model.add(layers.Reshape((7, 7, 256)))
    model.add(layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same', use_bias=False))
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU())
    model.add(layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False))
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU())
    model.add(layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh'))
    return model

def build_discriminator():
    model = tf.keras.Sequential()
    model.add(layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same', input_shape=[28, 28, 1]))
    model.add(layers.LeakyReLU())
    model.add(layers.Dropout(0.3))
    model.add(layers.Conv2D(128, (5, 5), strides=(2, 2), padding='same'))
    model.add(layers.LeakyReLU())
    model.add(layers.Dropout(0.3))
    model.add(layers.Flatten())
    model.add(layers.Dense(1))
    return model

generator = build_generator()
discriminator = build_discriminator()

# 编译判别器
discriminator.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# 编译GAN模型
discriminator.trainable = False
gan_input = layers.Input(shape=(100,))
generated_image = generator(gan_input)
gan_output = discriminator(generated_image)
gan = tf.keras.models.Model(gan_input, gan_output)
gan.compile(optimizer='adam', loss='binary_crossentropy')

# 加载MNIST数据集
(x_train, _), (_, _) = tf.keras.datasets.mnist.load_data()
x_train = (x_train.astype('float32') - 127.5) / 127.5
x_train = np.expand_dims(x_train, axis=3)

# 训练DCGAN
batch_size = 128
epochs = 10000
half_batch = int(batch_size / 2)

for epoch in range(epochs):
    # 训练判别器
    idx = np.random.randint(0, x_train.shape[0], half_batch)
    real_images = x_train[idx]
    noise = np.random.normal(0, 1, (half_batch, 100))
    generated_images = generator.predict(noise)
    d_loss_real = discriminator.train_on_batch(real

_images, np.ones((half_batch, 1)))
    d_loss_fake = discriminator.train_on_batch(generated_images, np.zeros((half_batch, 1)))
    d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

    # 训练生成器
    noise = np.random.normal(0, 1, (batch_size, 100))
    valid_y = np.array([1] * batch_size)
    g_loss = gan.train_on_batch(noise, valid_y)

    if epoch % 1000 == 0:
        print(f"{epoch} [D loss: {d_loss[0]} | D accuracy: {100 * d_loss[1]}] [G loss: {g_loss}]")
2.3 条件生成对抗网络（Conditional GAN）

条件生成对抗网络（Conditional GAN, cGAN）通过在生成器和判别器中引入条件变量，使生成的数据能够满足特定条件。

def build_generator():
    model = tf.keras.Sequential()
    model.add(layers.Dense(7 * 7 * 256, use_bias=False, input_shape=(110,)))
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU())
    model.add(layers.Reshape((7, 7, 256)))
    model.add(layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same', use_bias=False))
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU())
    model.add(layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False))
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU())
    model.add(layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh'))
    return model

def build_discriminator():
    model = tf.keras.Sequential()
    model.add(layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same', input_shape=[28, 28, 11]))
    model.add(layers.LeakyReLU())
    model.add(layers.Dropout(0.3))
    model.add(layers.Conv2D(128, (5, 5), strides=(2, 2), padding='same'))
    model.add(layers.LeakyReLU())
    model.add(layers.Dropout(0.3))
    model.add(layers.Flatten())
    model.add(layers.Dense(1))
    return model

generator = build_generator()
discriminator = build_discriminator()

# 编译判别器
discriminator.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# 编译cGAN模型
discriminator.trainable = False
noise_input = layers.Input(shape=(100,))
label_input = layers.Input(shape=(10,))
gan_input = layers.Concatenate()([noise_input, label_input])
generated_image = generator(gan_input)
label_image = layers.Concatenate()([generated_image, label_input])
gan_output = discriminator(label_image)
cgan = tf.keras.models.Model([noise_input, label_input], gan_output)
cgan.compile(optimizer='adam', loss='binary_crossentropy')

# 加载MNIST数据集
(x_train, y_train), (_, _) = tf.keras.datasets.mnist.load_data()
x_train = (x_train.astype('float32') - 127.5) / 127.5
x_train = np.expand_dims(x_train, axis=3)
y_train = tf.keras.utils.to_categorical(y_train, 10)

# 训练cGAN
batch_size = 128
epochs = 10000
half_batch = int(batch_size / 2)

for epoch in range(epochs):
    # 训练判别器
    idx = np.random.randint(0, x_train.shape[0], half_batch)
    real_images = x_train[idx]
    real_labels = y_train[idx]
    noise = np.random.normal(0, 1, (half_batch, 100))
    generated_labels = np.random.randint(0, 10, half_batch)
    generated_labels = tf.keras.utils.to_categorical(generated_labels, 10)
    generated_images = generator.predict([noise, generated_labels])
    real_images_with_labels = np.concatenate([real_images, real_labels], axis=3)
    generated_images_with_labels = np.concatenate([generated_images, generated_labels], axis=3)
    d_loss_real = discriminator.train_on_batch(real_images_with_labels, np.ones((half_batch, 1)))
    d_loss_fake = discriminator.train_on_batch(generated_images_with_labels, np.zeros((half_batch, 1)))
    d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

    # 训练生成器
    noise = np.random.normal(0, 1, (batch_size, 100))
    valid_y = np.array([1] * batch_size)
    labels = np.random.randint(0, 10, batch_size)
    labels = tf.keras.utils.to_categorical(labels, 10)
    g_loss = cgan.train_on_batch([noise, labels], valid_y)

    if epoch % 1000 == 0:
        print(f"{epoch} [D loss: {d_loss[0]} | D accuracy: {100 * d_loss[1]}] [G loss: {g_loss}]")

在这里插入图片描述

第三章 GANs的应用实例

3.1 图像生成

GANs在图像生成任务中表现出色，可以生成高质量的图像。以下是一个使用DCGAN生成手写数字图像的示例。

import matplotlib.pyplot as plt

# 生成手写数字图像
noise = np.random.normal(0, 1, (25, 100))
generated_images = generator.predict(noise)

# 绘制生成的图像
plt.figure(figsize=(10, 10))
for i in range(generated_images.shape[0]):
    plt.subplot(5, 5, i + 1)
    plt.imshow(generated_images[i, :, :, 0], cmap='gray')
    plt.axis('off')
plt.tight_layout()
plt.show()
3.2 数据增强

GANs可以用于数据增强，通过生成新的样本扩展训练数据集，从而提高模型的泛化能力。以下是一个使用cGAN生成带标签的手写数字图像的示例。

# 生成带标签的手写数字图像
noise = np.random.normal(0, 1, (25, 100))
labels = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9] * 2 + [0, 1, 2, 3, 4])
labels = tf.keras.utils.to_categorical(labels, 10)
generated_images = generator.predict([noise, labels])

# 绘制生成的图像
plt.figure(figsize=(10, 10))
for i in range(generated_images.shape[0]):
    plt.subplot(5, 5, i + 1)
    plt.imshow(generated_images[i, :, :, 0], cmap='gray')
    plt.axis('off')
plt.tight_layout()
plt.show()
3.3 风格迁移

GANs可以用于风格迁移，通过将一种图像的内容与另一种图像的风格结合，生成具有新风格的图像。以下是一个使用CycleGAN进行图像风格迁移的示例。

import tensorflow as tf
import tensorflow_addons as tfa
from tensorflow.keras import layers

def residual_block(x, filters, kernel_size=3):
    fx = layers.Conv2D(filters, kernel_size, padding='same')(x)
    fx = tfa.layers.InstanceNormalization()(fx)
    fx = layers.ReLU()(fx)
    fx = layers.Conv2D(filters, kernel_size, padding='same')(fx)
    fx = tfa.layers.InstanceNormalization()(fx)
    x = layers.Add()([x, fx])
    return x

def build_generator():
    inputs = layers.Input(shape=[256, 256, 3])
    x = layers.Conv2D(64, 7, padding='same')(inputs)
    x = tfa.layers.InstanceNormalization()(x)
    x = layers.ReLU()(x)
    x = layers.Conv2D(128, 3, strides=2, padding='same')(x)
    x = tfa.layers.InstanceNormalization()(x)
    x = layers.ReLU()(x)
    x = layers.Conv2D(256, 3, strides=2, padding='same')(x)
    x = tfa.layers.InstanceNormalization()(x)
    x = layers.ReLU()(x)

    for _ in range(9):
        x = residual_block(x, 256)

    x = layers.Conv2DTranspose(128, 3, strides=2, padding='same')(x)
    x = tfa.layers.InstanceNormalization()(x)
    x = layers.ReLU()(x)
    x = layers.Conv2DTranspose(64, 3, strides=2, padding='same')(x)
    x = tfa.layers.InstanceNormalization()(x)
    x = layers.ReLU()(x)
    x = layers.Conv2D(3, 7, padding='same')(x)
    x = layers.Activation('tanh')(x)
    return tf.keras.Model(inputs, x)

def build_discriminator():
   

 inputs = layers.Input(shape=[256, 256, 3])
    x = layers.Conv2D(64, 4, strides=2, padding='same')(inputs)
    x = layers.LeakyReLU(alpha=0.2)(x)
    x = layers.Conv2D(128, 4, strides=2, padding='same')(x)
    x = tfa.layers.InstanceNormalization()(x)
    x = layers.LeakyReLU(alpha=0.2)(x)
    x = layers.Conv2D(256, 4, strides=2, padding='same')(x)
    x = tfa.layers.InstanceNormalization()(x)
    x = layers.LeakyReLU(alpha=0.2)(x)
    x = layers.Conv2D(512, 4, strides=2, padding='same')(x)
    x = tfa.layers.InstanceNormalization()(x)
    x = layers.LeakyReLU(alpha=0.2)(x)
    x = layers.Conv2D(1, 4, padding='same')(x)
    return tf.keras.Model(inputs, x)

# 构建CycleGAN模型
generator_g = build_generator()
generator_f = build_generator()
discriminator_x = build_discriminator()
discriminator_y = build_discriminator()

# 编译模型
generator_g.compile(optimizer='adam', loss='mse')
generator_f.compile(optimizer='adam', loss='mse')
discriminator_x.compile(optimizer='adam', loss='mse')
discriminator_y.compile(optimizer='adam', loss='mse')

# 训练CycleGAN
# 训练数据准备和训练代码略

# 使用CycleGAN进行风格迁移
def generate_images(model, test_input):
    prediction = model(test_input)
    plt.figure(figsize=(12, 12))
    display_list = [test_input[0], prediction[0]]
    title = ['Input Image', 'Predicted Image']

    for i in range(2):
        plt.subplot(1, 2, i + 1)
        plt.title(title[i])
        plt.imshow(display_list[i] * 0.5 + 0.5)
        plt.axis('off')
    plt.show()

# 测试图像
test_image = tf.expand_dims(tf.image.resize(test_image, (256, 256)), axis=0) / 127.5 - 1
generate_images(generator_g, test_image)

在这里插入图片描述

第四章 GANs的未来发展与挑战

4.1 训练稳定性

GANs的训练过程容易出现不稳定性，如模式崩溃（mode collapse）和梯度消失等问题。研究如何提高GANs训练的稳定性是一个重要的方向。

4.2 模型评价

如何有效评估GANs生成数据的质量和多样性是一个挑战。研究方向包括开发更好的评价指标，如Frechet Inception Distance（FID）和Inception Score（IS）等。

4.3 应用扩展

GANs的应用范围不断扩大，研究如何在更多领域和任务中应用GANs，如文本生成、音频生成和科学模拟等，是一个重要的方向。

结论

生成对抗网络作为一种强大的生成模型，通过生成器和判别器的对抗训练，实现了高质量的数据生成和多种应用。本文详细介绍了GANs的基本概念、核心算法及其在实际中的应用，并提供了具体的代码示例，帮助读者深入理解和掌握这一技术。希望本文能够为您进一步探索和应用生成对抗网络提供有价值的参考。

在这里插入图片描述

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

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

相关文章

qt文件如何打包成一个独立的exe文件

qt文件如何打包成一个独立的exe文件

QT官方给我们安装好了打包软件，就在你QT安装的位置 把这个在cmd打开C:\Qt\6.7.1\mingw_64\bin\windeployqt6.exe（或复制地址） 然后把要打包项目的exe复制到新的空文件夹，再复制他的地址 按回车后生成新文件 再下载打包软件&#…
阅读更多...
使用pyqt5编写一个七彩时钟

使用pyqt5编写一个七彩时钟

使用pyqt5编写一个七彩时钟 效果代码解析定义 RainbowClockWindow 类初始化用户界面显示时间方法 完整代码 在这篇博客中，我们将使用 PyQt5 创建一个简单的七彩数字时钟。 效果 代码解析 定义 RainbowClockWindow 类 class RainbowClockWindow(QMainWindow):def _…
阅读更多...
【乐器识别系统】图像识别+人工智能+深度学习+Python+TensorFlow+卷积神经网络+模型训练

【乐器识别系统】图像识别+人工智能+深度学习+Python+TensorFlow+卷积神经网络+模型训练

一、介绍 乐器识别系统。使用Python为主要编程语言，基于人工智能框架库TensorFlow搭建ResNet50卷积神经网络算法，通过对30种乐器（‘迪吉里杜管’, ‘铃鼓’, ‘木琴’, ‘手风琴’, ‘阿尔卑斯号角’, ‘风笛’, ‘班卓琴’, ‘邦戈鼓’, ‘…
阅读更多...
Lumos学习王佩丰Excel第三讲：查找替换定位

Lumos学习王佩丰Excel第三讲：查找替换定位

一、查找和替换 1、按值查找 2、按格式查找 将红色的单元格替换成黄色的单元格，其他格式同理处理。 3、是否开启单元格匹配 若不打开选项卡直接全部替换，会出现“苏州市市”的情况；加入单元格匹配的规则，检索时会以整个单元格内…
阅读更多...
【车载开发系列】S32 Design Studio工具安装步骤

【车载开发系列】S32 Design Studio工具安装步骤

【车载开发系列】S32 Design Studio工具安装步骤 S32 Design Studio工具安装步骤 【车载开发系列】S32 Design Studio工具安装步骤※关键字提炼※一. 准备工作二. 下载安装包三. 获取License许可四. 开始预安装五. 开始正式安装六. 启动软件七. 安装插件八. 卸载插件九. 确认安…
阅读更多...
系留无人机+自组网+单兵图传：低空集群组网指挥系统技术详解

系留无人机+自组网+单兵图传：低空集群组网指挥系统技术详解

低空无人机集群的控制、调度、信息回传需要有高度可靠和稳定的无线通信链路来保障。我国发达的公网基础设施为上述应用创造了良好的条件，但低空应用必须要考虑到在极端情况下公网瘫痪造成的通信链路中断带来的影响，因此有必要在公网之外，寻求…
阅读更多...
【机器学习】机器学习重要方法——迁移学习：理论、方法与实践

【机器学习】机器学习重要方法——迁移学习：理论、方法与实践

文章目录 迁移学习：理论、方法与实践引言第一章 迁移学习的基本概念1.1 什么是迁移学习1.2 迁移学习的类型1.3 迁移学习的优势 第二章 迁移学习的核心方法2.1 特征重用（Feature Reuse）2.2 微调（Fine-Tuning）2.3 领域适…
阅读更多...
线性代数|机器学习-P18快速下降奇异值

线性代数|机器学习-P18快速下降奇异值

文章目录 1. 为什么要低秩矩阵1.1 矩阵A的秩定义1.2 矩阵压缩PCA 2. 低秩矩阵图像处理3. 秩的相关性质3.1 秩的公差轴表示3.2 Eckart-Young 定理 4. 低秩矩阵4.1 低秩矩阵描述4.2 函数低秩矩阵形式4.3通项小结4.4 函数采样拟合 5. 西尔维斯特方程5.1 希尔伯特矩阵举例5.2 范德蒙…
阅读更多...
c++(三)

c++(三)

1. STL 1.1. 迭代器 迭代器是访问容器中元素的通用方法。如果使用迭代器，不同的容器，访问元素的方法是相同的；迭代器支持的基本操作：赋值（）、解引用（*）、比较（和!&…
阅读更多...
ros笔记01--初次体验ros2

ros笔记01--初次体验ros2

ros笔记01--初次体验ros2 介绍安装ros2测试验证ros2说明 介绍 机器人操作系统(ROS)是一组用于构建机器人应用程序的软件库和工具。从驱动程序和最先进的算法到强大的开发者工具，ROS拥有我们下一个机器人项目所需的开源工具。 当前ros已经应用到各类机器人项目开发中…
阅读更多...
【IVI】CarService启动-Android13

【IVI】CarService启动-Android13

【IVI】CarService启动-Android13 1、CarServiceImpl启动概述2、简要时序图 1、CarServiceImpl启动概述 【IVI】CarService启动： CarServiceHelperService中绑定CarServiceICarImpl初始化各种服务 packages/services/Car/README.md 2、简要时序图
阅读更多...
Linux——passwd文件，grep，cut

Linux——passwd文件，grep，cut

/etc/passwd文件含义 作用 - 记录用户账户信息：共分为7段，使用冒号分割 含义 - 文件内容意义：账户名：密码代号x：UID：GID：注释：家目录：SHELL - 第7列/sbin/nologin&#x…
阅读更多...
昇思25天学习打卡营第7天之二 | 模型保存与加载

昇思25天学习打卡营第7天之二 | 模型保存与加载

1. 保存与加载 在训练网络模型的过程中，实际上我们希望保存中间和最后的结果，用于微调（fine-tune）和后续的模型推理与部署，本章节我们将介绍如何保存与加载模型。 1.1 导入依赖 # 导入numpy库，并将其重命…
阅读更多...
【C语言】--分支和循环（1）

【C语言】--分支和循环（1）

🍿个人主页: 起名字真南 🧇个人专栏:【数据结构初阶】 【C语言】 目录 前言1 if 语句1.1 if1.2 else1.3 嵌套if1.4 悬空else 前言 C语言是结构化的程序设计语言，这里的结构指的是顺序结构、选择结构、循环结构。 我们可以用if、switch实现分支…
阅读更多...
51单片机第6步_stdlib.h库函数

51单片机第6步_stdlib.h库函数

本章重点学习stdlib.h库函数。 #include <REG51.h> //包含头文件REG51.h,使能51内部寄存器; #include <stdlib.h> //float atof (char *s1); //参数s1字符串可包含正负号,小数点或E(e)来表示指数部分,如123.456或123e-2; //若首字符是非数据字符,或为正负号…
阅读更多...
力扣每日一题 6/30 记忆化搜索/动态规划

力扣每日一题 6/30 记忆化搜索/动态规划

博客主页&#xff1a;誓则盟约系列专栏&#xff1a;IT竞赛 专栏关注博主&#xff0c;后期持续更新系列文章如果有错误感谢请大家批评指出&#xff0c;及时修改感谢大家点赞&#x1f44d;收藏⭐评论✍ 494.目标和【中等】 题目&#xff1a; 给你一个非负整数数组 nums 和一个…
阅读更多...
VMware中的三种虚拟网络模式

VMware中的三种虚拟网络模式

虚拟机网络模式 1 主机网络环境2 VMware中的三种虚拟网络模式2.1 桥接模式NAT模式仅主机模式网络模式选择1 VMware虚拟网络配置2 虚拟机选择网络模式3 Windows主机网络配置 配置静态IP 虚拟机联网方式为桥接模式&#xff0c;这种模式下&#xff0c;虚拟机通过主机的物理网卡&am…
阅读更多...
mysql8.0-学习

mysql8.0-学习

文章目录 mysql8.0基础知识-学习安装mysql_8.0登录mysql8.0的体系结构与管理体系结构图连接mysqlmysql8.0的 “新姿势” mysql的日常管理用户安全权限练习查看用户的权限回收:revoke角色 mysql的多种连接方式socket显示系统中当前运行的所有线程 tcp/ip客户端工具基于SSL的安全…
阅读更多...
2024最新boss直聘岗位数据爬虫，并进行可视化分析

2024最新boss直聘岗位数据爬虫，并进行可视化分析

前言 近年来，随着互联网的发展和就业市场的变化，数据科学与爬虫技术在招聘信息分析中的应用变得越来越重要。通过对招聘信息的爬取和可视化分析，我们可以更好地了解当前的就业市场动态、职位需求和薪资水平，从而为求职者和招聘企业提供有价值的数据支持。本文将介绍如何使…
阅读更多...
Linux系统编程--进程间通信

Linux系统编程--进程间通信

目录 1. 介绍 1.1 进程间通信的目的 1.2 进程间通信的分类 2. 管道 2.1 什么是管道 2.2 匿名管道 2.2.1 接口 2.2.2 步骤--以父子进程通信为例 2.2.3 站在文件描述符角度-深度理解 2.2.4 管道代码 2.2.5 读写特征 2.2.6 管道特征 2.3 命名管道 2.3.1 接口 2.3.2…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站