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

news2024/10/6 6:42:55

引言

生成对抗网络（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.coloradmin.cn/o/1879884.html

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

相关文章

老师期末工作怎么减负？

老师期末工作怎么减负？

期末，一个学期的尾声，也是老师们最为忙碌的时刻。在这段时间里，我们不仅要完成教学任务，还要准备期末考试、批改试卷、撰写学生评语、制定假期计划等一系列繁重的工作。那么，如何在这样紧张的期末工作中为自己减负呢&a…
阅读更多...
Android高级面试_2_IPC相关

Android高级面试_2_IPC相关

Android 高级面试-3：语言相关 1、Java 相关 1.1 缓存相关 问题：LruCache 的原理？ 问题：DiskLruCache 的原理？ LruCache 用来实现基于内存的缓存，LRU 就是最近最少使用的意思，LruCache 基于L…
阅读更多...
RocketMQ源码学习笔记：Producer启动流程

RocketMQ源码学习笔记：Producer启动流程

这是本人学习的总结，主要学习资料如下 马士兵教育rocketMq官方文档 目录 1、Overview1.1、创建MQClientInstance1.1.1、检查1.1.1、MQClientInstance的ID 1.2、MQClientInstance.start() 1、Overview 这是发送信息的代码样例， DefaultMQProducer produ…
阅读更多...
百强韧劲，进击新局 2023年度中国医药工业百强系列榜单发布

百强韧劲，进击新局 2023年度中国医药工业百强系列榜单发布

2024年，经济工作坚持稳中求进、以进促稳、先立后破等工作要求。医药健康行业以不懈进取的“韧劲”，立身破局，迎变启新。通过创新和迭代应对不确定性，进化韧性力量，坚持高质量发展，把握新时代经济和社会给予…
阅读更多...
Python之三大基本库——Numpy(2)

Python之三大基本库——Numpy(2)

接着上次的内容接着讲，连续号都续上哈 七、numpu中random的随机生成函数 以下总结的是比较常用到的函数： 下面分别介绍一下不用的用法： 首先导入创建函数 import numpy as np np.random.seed(666)1、 rand(d0,d1,d2,...,dn)：返…
阅读更多...
Keysight是德 N9912A 手持式射频分析仪

Keysight是德 N9912A 手持式射频分析仪

Keysight是德 N9912A 手持式频谱分析仪 N9912A FieldFox 手持射频分析仪，4 GHz 和 6 GHz 轻盈耐用的电缆与天线分析仪、频谱分析仪、网络分析仪等等。 Keysight FieldFox 便携式分析仪可以在非常恶劣的工作环境中，轻松完成从日常维护到深入故障诊断的…
阅读更多...
【Python】 模型训练数据归一化的原理

【Python】 模型训练数据归一化的原理

那年夏天我和你躲在 这一大片宁静的海 直到后来我们都还在 对这个世界充满期待 今年冬天你已经不在 我的心空出了一块 很高兴遇见你 让我终究明白 回忆比真实精彩 🎵 王心凌《那年夏天宁静的海》 在机器学习和深度学习中，数据归一化…
阅读更多...
如何用DCA1000持续采集雷达数据

如何用DCA1000持续采集雷达数据

摘要：本文介绍一下如何通过mmwave studio软件，搭配DCA1000数据采集卡，对AWR1843BOOST进行不间断的数据采集。本文要求读者已经掌握了有关基础知识。 本文开放获取，无需关注。 到SensorConfig页面下，一步步操作&#xf…
阅读更多...
吉时利 Keithley2601B-PULSE 脉冲数字源表

吉时利 Keithley2601B-PULSE 脉冲数字源表

Keithley2601B-PULSE吉时利脉冲SMU数字源表 无需手动脉冲调整即可实现高脉冲保真度 通过 2601B-PULSE 控制回路系统，高达 3μH 的负载变化无需手动调整，从而确保在任何电流水平（最高 10 安培）下输出 10 μs 至 500 μs 脉冲时&a…
阅读更多...
柯桥法语学习|学点黑话！法语中的「钱」可不止“argent”

柯桥法语学习|学点黑话！法语中的「钱」可不止“argent”

法语中有哪些关于钱的“黑话”？一起来和法语君看一下吧！ bl 之所以繁杂，是因为这些词在诞生之初，不止涉及一个故事，而是一大堆小轶事，以“bl”指钱的起源如迷宫般复杂。 根据Trsor de la langue frana15857…
阅读更多...
Android Graphics 显示系统 - BufferQueue的状态监测

Android Graphics 显示系统 - BufferQueue的状态监测

“ BufferQueue作为连接生产者和消费者的桥梁，时刻掌握队列中每一块Buffer的状态，对于解决一些卡死卡顿问题很有帮助，辨别是否有生产者或消费者长期持有大量Buffer不放导致运行不畅的情况。” 01 — 前言 在Android系统中，应用U…
阅读更多...
使用evo工具比较ORB-SLAM3的运行轨迹(从安装到解决报错)

使用evo工具比较ORB-SLAM3的运行轨迹(从安装到解决报错)

ORB-SLAM2和ORB-SLAM3怎么跑出来，之前都有相关的保姆级的教程，下来给大家介绍一款evo工具，给科研加速！！！ 文章目录 1.下载evo2.生成轨迹3.evo别的功能使用 1.下载evo 输入命令下载 pip install -i https…
阅读更多...
Redis的使用和原理

Redis的使用和原理

目录 1.初识Redis 1.1 Redis是什么？ 1.2 Redis的特性 1.2.1 速度快 1.2.2 基于键值对的数据结构服务器 1.2.3 丰富的功能 1.2.4 简单稳定 1.2.5 持久化 1.2.6 主从复制 1.2.7 高可用和分布式 1.3 Redis的使用场景 1.3.1 缓存 1.3.2 排行榜系统 1.3.3 计数器应用 1.3…
阅读更多...
Firefox 编译指南2024 Windows10-使用Git 管理您的Firefox（五）

Firefox 编译指南2024 Windows10-使用Git 管理您的Firefox（五）

1. 引言 在现代软件开发中，版本控制系统（VCS）是不可或缺的工具，它不仅帮助开发者有效管理代码的变化，还支持团队协作与项目管理。Mercurial 是一个高效且易用的分布式版本控制系统，其设计目标是简洁、快速…
阅读更多...
第二十三课，再识字符串

第二十三课，再识字符串

前言，再识字符串 字符串是我们学习python编程第一眼见到的东西，一行print(“hello world”)可谓是太亲切了，但在此之前我们对字符串的认知也仅局限于如何用单引号、双引号、三引号去定义字符串并打印，今天开始我们就更深入地去理…
阅读更多...
详细介绍MySQL的索引（下）

详细介绍MySQL的索引（下）

索引的使用 同一条数据在未创建索引的情况下耗时： nick字段是未创建索引的 select * from t_user WHERE nick 邹丽;SHOW PROFILES; 耗时为： user_account字段创建了唯一索引 select * from t_user WHERE user_account 13781945844;SHOW PROFILES;…
阅读更多...
重温react-06(初识函数组件和快速生成格式的插件使用方式)

重温react-06(初识函数组件和快速生成格式的插件使用方式)

开始 函数组件必然成为未来发展的趋势(个人见解),总之努力的去学习,才能赚更多的钱.加油呀! 函数组件的格式 import React from reactexport default function LearnFunction01() {return (<div>LearnFunction01</div>) }以上是函数式组件的组基本的方式 快捷生…
阅读更多...
前端优化：首屏加载速度的实践

前端优化：首屏加载速度的实践

目录 目录 前言 多图片的懒加载 避免用户多次点击请求 骨架屏原理 结束语 前言 随着互联网技术的飞速发展&#xff0c;前端网页逐渐取代了传统客户端成为用户获取信息、进行交互的重要渠道&#xff0c;但是网页也有常见的弊端&#xff0c;比如网页首屏加载速度的快慢直接…
阅读更多...
大模型压缩量化方案怎么选？无问芯穹Qllm-Eval量化方案全面评估：多模型、多参数、多维度

大模型压缩量化方案怎么选？无问芯穹Qllm-Eval量化方案全面评估：多模型、多参数、多维度

基于 Transformer架构的大型语言模型在各种基准测试中展现出优异性能&#xff0c;但数百亿、千亿乃至万亿量级的参数规模会带来高昂的服务成本。例如GPT-3有1750亿参数&#xff0c;采用FP16存储&#xff0c;模型大小约为350GB&#xff0c;而即使是英伟达最新的B200 GPU 内存也只…
阅读更多...
5G NR PUSCH物理层过程

5G NR PUSCH物理层过程

物理层过程 加扰 假设要在单个码字q上传输的bit块为 b ( q ) ( 0 ) , . . . , b ( q ) ( M b i t ( q ) − 1 ) b^{(q)}(0),...,b^{(q)}(M_{bit}^{(q)} - 1) b(q)(0),...,b(q)(Mbit(q)​−1) &#xff0c;其中 M b i t ( q ) M_{bit}^{(q)} Mbit(q)​是总比特数&#xff0c;加…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023