生成模型——自回归模型详解与PixelCNN构建

最新推荐文章于 2024-07-07 12:41:23 发布
最新推荐文章于 2024-07-07 12:41:23 发布
阅读量1.4w 收藏 66
点赞数 14
分类专栏： 深度学习 文章标签： 神经网络 tensorflow 机器学习 人工智能 卷积
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LOVEmy134611/article/details/117114850
版权
本文深入介绍了自回归模型，包括PixelRNN和PixelCNN，重点讲解了PixelCNN的构建过程，使用TensorFlow2实现，并展示了如何通过自回归模型生成图像。模型以MNIST数据集为训练基础，利用掩模卷积和残差块来逐像素预测，最终生成新的图像。
摘要由CSDN通过智能技术生成

生成模型——自回归模型详解与PixelCNN构建

自回归模型（Autoregressive models）

深度神经网络生成算法主要分为三类：

  1. 生成对抗网络(Generative Adversarial Network, GAN)
  2. 可变自动编码器(Variational Autoencoder, VAE)
  3. 自回归模型(Autoregressive models)

VAE已经在《变分自编码器（VAE）原理与实现（tensorflow2.x）》中进行了介绍。GAN的详细信息参考《深度卷积生成对抗网络（DCGAN）原理与实现（采用Tensorflow2.x）》。将在这里介绍鲜为人知的自回归模型，尽管自回归在图像生成中并不常见，但自回归仍然是研究的活跃领域，DeepMind的WaveNet使用自回归来生成逼真的音频。在本文中，将介绍自回归模型并构建PixelCNN模型。

简介

Autoregressive中的“Auto”意味着自我(self)，而机器学习术语的回归(regress)意味着预测新的值。将它们放在一起，自回归意味着我们使用模型基于模型的过去数据点来预测新数据点。
设图像的概率分布是 p ( x ) p(x) p(x)是像素的联合概率分布 p ( x 1 , x 2 , … x n ) p(x_1, x_2, …x_n) p(x1​,x2​,…xn​)，由于高维数很难建模。在这里，我们假设一个像素的值仅取决于它之前的像素的值。换句话说，当前像素仅以其前一像素为条件，即 p ( x i ) = p ( x i ∣ x i − 1 ) p ( x i − 1 ) p(x_i) = p(x_i | x_{i-1}) p(x_{i-1}) p(xi​)=p(xi​∣xi−1​)p(xi−1​)，我们就可以将联合概率近似为条件概率的乘积：
p ( x ) = p ( x n , x n − 1 , … , x 2 , x 1 ) p(x) = p(x_n, x_{n-1}, …, x_2, x_1) p(x)=p(xn​,xn−1​,…,x2​,x1​)
p ( x ) = p ( x n ∣ x n − 1 ) . . . p ( x 3 ∣ x 2 ) p ( x 2 ∣ x 1 ) p ( x 1 ) p(x) = p(x_n | x_{n-1})... p(x_3 | x_2) p(x_2 | x_1) p(x_1) p(x)=p(xn​∣xn−1​)...p(x3​∣x2​)p(x2​∣x1​)p(x1​)
举一个具体的例子，假设在图像的中心附近包含一个红色的苹果，并且该苹果被绿叶包围，在此情况下，假设仅存在两种可能的颜色：红色和绿色。 x 1 x_1 x1​是左上像素，所以 p ( x 1 ) p(x_1) p(x1​)表示左上像素是绿色还是红色的概率。如果 x 1 x_1 x1​为绿色，则其右边 p ( x 2 ) p(x_2) p(x2​)的像素也可能也为绿色，因为它可能会有更多的叶子。但是，尽管可能性较小，但它也可能是红色的。
继续进行计算，我们最终将得到红色像素。从那个像素开始，接下来的几个像素也很可能也是红色的，这比必须同时考虑所有像素要简单得多。

PixelRNN

PixelRNN由DeepMind于2016年提出。正如名称RNN（Recurrent Neural Network, 递归神经网络）所暗示的那样，该模型使用一种称为长短期记忆（LSTM）的RNN来学习图像的分布。它在LSTM中的一个步骤中一次读取图像的一行，并使用一维卷积层对其进行处理，然后将激活信息馈送到后续层中以预测该行的像素。
由于LSTM运行缓慢，因此需要花费很长时间来训练和生成样本。因此，我们不会对其进行过多的研究，而将注意力转移到同一论文中提出的一种变体——PixelCNN。

使用TensorFlow 2构建PixelCNN模型

PixelCNN仅由卷积层组成，使其比PixelRNN快得多。在这里，我们将为使用MNIST数据集训练一个简单的PixelCNN模型。

输入和标签

MNIST由28 x 28 x 1灰度数字手写数字组成。它只有一个通道：
数据集查看
在本实验中，通过将图像转换为二进制数据来简化问题：0代表黑色，1代表白色：

def binarize(image, label):
    image = tf.cast(image, tf.float32)
    image = tf.math.round(image/255.)
    return image, tf.cast(image, tf.int32)

该函数需要两个输入——图像和标签。该函数的前两行将图像转换为二进制float32格式，即0.0或1.0。并且，我们将二进制图像转换为整数并返回，以遵循使用整数作为标签的惯例而已。返回的数据，将作为网络训练的输入和标签，都是28 x 28 x 1的二进制MNIST图像，它们仅在数据类型上有所不同。

掩膜

与PixelRNN逐行读取不同，PixelCNN在图像中从左到右，从上到下滑动卷积核。当执行卷积以预测当前像素时，传统的卷积核能够看到当前输入像素及其周围的像素，其中包括当前像素之后的像素信息，这与在简介部分的条件概率假设相悖。
为了避免这种情况，我们需要确保CNN在预测输出像素 x i x_i xi​时不会看到输入像素 x i x_i xi​。
这是通过使用掩膜卷积来实现的，其中在执行卷积之前将掩膜应用于卷积核权重。下图显示了一个7 x 7卷积核的掩膜，其中从中心开始的权重为0。这会阻止CNN看到它正在预测的像素（卷积核的中心）以及所有之后的像素。这称为A型掩膜，仅应用于输入层。
掩膜卷积核

由于中心像素在第一层中被遮挡，因此我们不再需要在后面的层中隐藏中心要素。实际上，我们需要将卷积核中心设置为1，以使其能够读取先前层的特征，这称为B型掩膜。

实现自定义层

现在，我们将为掩膜卷积创建一个自定义层。我们可以使用从基类tf.keras.layers.Layer继承的子类在TensorFlow2.x中创建自定义层，以便将能够像使用其他Keras层一样使用它。以下是自定义层类的基本结构：

class MaskedConv2D(tf.keras.layers.Layer):
    def __init__(self):
        ...       
    def build(self, input_shape):
        ...
    def call(self, inputs):
        ...
        return output

build()将输入张量的形状作为参数，我们将使用此信息来确保创建正确形状的变量。构建图层时，此函数仅运行一次。我们可以通过声明不可训练的变量或常量来创建掩码，以使TensorFlow知道它不需要梯度来反向传播：

	def build(self, input_shape):
	        self.w = self.add_weight(shape=[self.kernel,
	                                        self.kernel,
	                                        input_shape[-1],
	                                        self.filters],
	                                initializer='glorot_normal',
	                                trainable=True)
	        self.b = self.add_weight(shape=(self.filters,),
	                                initializer='zeros',
	                                trainable=True)
	        mask = np.ones(self.kernel**2, dtype=np.float32)
	        center = len(mask)//2
	        mask[center+1:] = 0
	        if self.mask_type == 'A':
	            mask[center] = 0
	        mask = mask.reshape((self.kernel, self.kernel, 1, 1))
	        self.mask = tf.constant(mask, dtype='float32')

call()用来执行前向传递。在掩膜卷积层中，在使用低级tf.nn API执行卷积之前，我们将权重乘以掩码后将下半部分的值设为零：

	def call(self, inputs):
	        masked_w = tf.math.multiply(self.w, self.mask)
	        output=tf.nn.conv2d(inputs, masked_w, 1, "SAME") + self.b
	        return output
网络架构

PixelCNN架构非常简单。在使用A型掩膜的第一个7 x 7 conv2d图层之后，有几层带有B型掩膜的残差块：

Model: "PixelCnn"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_2 (InputLayer)         [(None, 28, 28, 1)]       0         
_________________________________________________________________
masked_conv2d_22 (MaskedConv (None, 28, 28, 128)       6400      
_________________________________________________________________
residual_block_7 (ResidualBl (None, 28, 28, 128)       53504     
_________________________________________________________________
residual_block_8 (ResidualBl (None, 28, 28, 128)       53504     
_________________________________________________________________
residual_block_9 (ResidualBl (None, 28, 28, 128)       53504     
_________________________________________________________________
residual_block_10 (ResidualB (None, 28, 28, 128)       53504     
_________________________________________________________________
residual_block_11 (ResidualB (None, 28, 28, 128)       53504     
_________________________________________________________________
residual_block_12 (ResidualB (None, 28, 28, 128)       53504     
_________________________________________________________________
residual_block_13 (ResidualB (None, 28, 28, 128)       53504     
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 28, 28, 64)        8256      
_________________________________________________________________
conv2d_3 (Conv2D)            (None, 28, 28, 1)         65        
=================================================================
Total params: 389,249
Trainable params: 389,249
Non-trainable params: 0

下图说明了PixelCNN中使用的残差块架构：
残差块架构

交叉熵损失

交叉熵损失也称为对数损失，它衡量模型的性能，其中输出的概率在0到1之间。以下是二进制交叉熵损失的方程，其中只有两个类，标签y可以是0或1， p ( x ) p(x) p(x)是模型的预测：
B C E = − 1 N ∑ i = 1 N ( y i l o g p ( x ) + ( 1 − y i ) l o g ( 1 − p ( x ) ) ) BCE = -\frac1N\sum_{i=1}^N(y_ilogp(x)+(1-y_i)log(1-p(x))) BCE=−N1​i=1∑N​(yi​logp(x)+(1−yi​)log(1−p(x)))
在PixelCNN中，单个图像像素用作标签。在二值化MNIST中，我们要预测输出像素是0还是1，这使其成为使用交叉熵作为损失函数的分类问题。
最后，编译和训练神经网络，我们对损失和度量均使用二进制交叉熵，并使用RMSprop作为优化器。有许多不同的优化器可供使用，它们的主要区别在于它们根据过去的统计信息调整学习率的方式。没有一种最佳的优化器可以在所有情况下使用，因此建议尝试使用不同的优化器。
编译和训练pixelcnn模型：

pixelcnn = SimplePixelCnn()
pixelcnn.compile(
    loss = tf.keras.losses.BinaryCrossentropy(),
    optimizer=tf.keras.optimizers.RMSprop(learning_rate=0.001),
    metrics=[ tf.keras.metrics.BinaryCrossentropy()])
pixelcnn.fit(ds_train, epochs = 10, validation_data=ds_test)

接下来，我们将根据先前的模型生成一个新图像。

采样生成图片

训练后，我们可以通过以下步骤使用该模型生成新图像：

  1. 创建一个具有与输入图像相同形状的空张量，并用1填充。将其馈入网络并获得 p ( x 1 ) p(x1) p(x1)，即第一个像素的概率。
  2. 从 p ( x 1 ) p(x_1) p(x1​)进行采样，并将采样值分配给输入张量中的像素 x 1 x_1 x1​。
  3. 再次将输入提供给网络，并对下一个像素执行步骤2。
  4. 重复步骤2和3，直到生成 x N x_N xN​。

自回归模型的一个主要缺点是它生成速度慢，因为需要逐像素生成，而无法并行化。以下图像是我们的PixelCNN模型经过100个训练周期后生成的。它们看起来还不太像正确的数字，但我们现在可以凭空生成新图像。可以通过训练更长的模型并进行一些超参数调整来生成更好的数字。
生成结果图片

完整代码

import tensorflow as tf
from tensorflow.keras import layers
from tensorflow.keras.activations import relu
from tensorflow.keras.models import Sequential

import tensorflow_datasets as tfds

import numpy as np
import matplotlib.pyplot as plt

import warnings
warnings.filterwarnings('ignore')
print(tf.__version__)

(ds_train, ds_test), ds_info = tfds.load(
    'mnist',
    split=['test', 'test'],
    shuffle_files=True,
    as_supervised=True,
    with_info=True)
fig = tfds.show_examples(ds_train, ds_info)

def binarize(image, label):
    image = tf.cast(image, tf.float32)
    image = tf.math.round(image/255.)
    return image, tf.cast(image, tf.int32)
    
ds_train = ds_train.map(binarize)
ds_train = ds_train.cache() # put dataset into memory
ds_train = ds_train.shuffle(ds_info.splits['train'].num_examples)
ds_train = ds_train.batch(128)
ds_test = ds_test.map(binarize).batch(128).prefetch(64)

class MaskedConv2D(layers.Layer):
    def __init__(self, mask_type, kernel=5, filters=1):
        super(MaskedConv2D, self).__init__()
        self.kernel = kernel
        self.filters = filters
        self.mask_type = mask_type
    
    def build(self, input_shape):
        
        self.w = self.add_weight(shape=[
            self.kernel, 
            self.kernel, 
            input_shape[-1],
            self.filters],
            initializer='glorot_normal',
            trainable=True)
        
        self.b = self.add_weight(shape=(self.filters,),
            initializer='zeros',
            trainable=True)
        
        # Create Mask
        mask = np.ones(self.kernel ** 2, dtype=np.float32)
        center = len(mask) // 2
        mask[center+1:] = 0
        if self.mask_type == 'A':
            mask[center] = 0
        
        mask = mask.reshape((self.kernel, self.kernel, 1, 1))

        self.mask = tf.constant(mask, dtype='float32')
    
    def call(self, inputs):
        # mask the convolution
        masked_w = tf.math.multiply(self.w, self.mask)

        # preform conv2d using low level API
        output = tf.nn.conv2d(inputs, masked_w, 1, 'SAME') + self.b

        return tf.nn.relu(output)

class ResidualBlock(layers.Layer):
    def __init__(self, h=32):
        super(ResidualBlock, self).__init__()

        self.forward = Sequential([
            MaskedConv2D('B', kernel=1, filters=h),
            MaskedConv2D('B', kernel=3, filters=h),
            MaskedConv2D('B', kernel=1, filters=2*h),
        ])
    
    def call(self, inputs):
        x = self.forward(inputs)
        return x + inputs

def SimplePixelCnn(
    hidden_features=64,
    output_features=64,
    resblocks_num=7):
    
    inputs = layers.Input(shape=[28, 28, 1])
    x = inputs
    
    x = MaskedConv2D('A', kernel=7, filters=2*hidden_features)(x)

    for _ in range(resblocks_num):
        x = ResidualBlock(hidden_features)(x)
    
    x = layers.Conv2D(output_features, (1,1), padding='same', activation='relu')(x)
    x = layers.Conv2D(1, (1,1), padding='same', activation='sigmoid')(x)

    return tf.keras.Model(inputs=inputs, outputs=x, name='PixelCnn')

pixel_cnn = SimplePixelCnn()
pixel_cnn.summary()

pixel_cnn.compile(
    loss=tf.keras.losses.BinaryCrossentropy(),
    optimizer=tf.keras.optimizers.RMSprop(learning_rate=0.001),
    metrics=[tf.keras.losses.BinaryCrossentropy()]
)

grid_row = 5
grid_col = 5
batch = grid_row * grid_col
h = w = 28
images = np.ones((batch,h,w,1), dtype=np.float32)

for row in range(h):
    for col in range(w):
        prob = pixel_cnn.predict(images)[:, row,col,0]
        pixel_samples = tf.random.categorical(
            tf.math.log(np.stack([1-prob,prob],1)),1
        )
        #print(pixel_samples.shape)
        images[:,row,col,0] = tf.reshape(pixel_samples, [batch])

# Display
f, axarr = plt.subplots(grid_row, grid_col, figsize=(grid_col*1.1,grid_row))

i = 0
for row in range(grid_row):
    for col in range(grid_col):
        axarr[row,col].imshow(images[i,:,:,0], cmap='gray')
        axarr[row,col].axis('off')
        i += 1
f.tight_layout(0.1, h_pad=0.2, w_pad=0.1)        
plt.show()
盼小辉丶
关注
  • 14
    点赞
  • 踩
  • 66
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 8
    评论
专栏目录
AIGC实战——自回归模型(Autoregressive Model)
盼小辉丶的博客
01-05 3546
自回归模型 (Autoregressive Model) 通过将生成问题视为一个序列过程来简化生成模型。自回归模型将预测条件建立在序列中的先前值上，而不是一个以随机潜变量为条件。因此，自回归模型尝试对数据生成分布进行显式建模，而不是尝试近似数据分布。在本节中，将介绍一类经典的自回归模型，长短期记忆网络 (Long Short-Term Memory Network, LSTM)，并将 LSTM 应用于生成文本数据。
简要介绍 | 自回归生成：探索序列的未来之旅
NLOS的博客
07-27 435
自回归生成模型的研究仍在继续，人们希望通过改进自回归模型，解决上述挑战，使其在更多的场景下发挥作用。例如，通过引入更复杂的模型，使自回归模型能够处理更复杂的序列；自回归生成模型是一种强大的序列生成工具，它能够从已有的序列中学习，然后生成新的序列。在学习阶段，我们首先定义一个模型，例如一个神经网络，然后使用一种优化算法（例如梯度下降）来调整模型的参数，使得模型的预测与实际的序列值尽可能接近。在此模型中，我们使用了一个LSTM网络作为自回归模型的基础，然后通过一个全连接层将LSTM的输出转换为预测的序列值。
生成模型概述
weixin_43186779的博客
03-23 1775
生成模型是深度学习领域的一类模型，它们的目标是学习如何生成数据的分布，从而能够生成新的、与真实数据类似的样本。以下是一些主要的生成模型：生成对抗网络（GANs）:GAN由两个部分组成：生成器（生成新数据）和判别器（区分真实数据和生成的数据）。这两部分在训练过程中相互竞争，提高彼此的性能。应用：图像生成、艺术创作、数据增强、风格迁移等。自回归模型（Autoregressive Models）:如Transformer在自然语言处理领域的应用。这些模型预测序列中的下一个元素，基于前面的元素。
什么是自回归模型
最新发布
dc爱傲雪和技术
07-07 839
自回归模型（Autoregressive Model, AR模型）是时间序列分析中的一种基本模型，其核心思想是当前观测值可以通过其过去的若干个观测值的加权和来预测，其中的权重参数由数据自身决定。数学上，一个自回归模型可以表示为：Xtcϕ1Xt−1ϕ2Xt−2⋯ϕpXt−pϵtXt​cϕ1​Xt−1​ϕ2​Xt−2​⋯ϕp​Xt−p​ϵt​XtX_tXt​) 是在时间 (ttt。
序列模型（自回归模型，马尔可夫模型，因果关系）
liuyingshudian的博客
12-12 2701
序列模型
【DL】第 4 章：自回归模型
sikh_0529的博客
03-06 2252
索普先生的故事他的众包寓言是对顺序数据最常用和最成功的深度学习技术之一的类比如文：长短期记忆（LSTM）网络。LSTM 网络是一种特殊类型递归神经网络（RNN）。RNN 包含一个循环层（或cell），它能够通过在特定时间步使其自己的输出成为下一个时间步输入的一部分来处理顺序数据，因此来自过去的信息可以影响当前时间步的预测。我们说LSTM 网络是指具有 LSTM 循环层的神经网络。
生成模型——自回归模型详解与PixelCNN构建，2024年最新全世界都在问Python开发凉了吗
2401_84302628的博客
04-11 794
…def call(self, inputs):…return outputbuild()将输入张量的形状作为参数，我们将使用此信息来确保创建正确形状的变量。构建图层时，此函数仅运行一次。我们可以通过声明不可训练的变量或常量来创建掩码，以使TensorFlow知道它不需要梯度来反向传播：def build(self, input_shape):self.w = self.add_weight(shape=[self.kernel,self.kernel,input_shape[-1],self.filter
生成模型笔记（七）：自回归模型
D_Trump的博客
10-14 842
生成模型笔记（七）：自回归模型
【时间序列】自回归模型
AI蜗牛车
11-02 8513
作者| 追光者研究| 机器学习与时间序列出品 | AI蜗牛车本篇主要讲解AR，ARMA，ARIMA等传统时间序列模型，包括具体代码操作。并附讲时间序列的一些基础知识点，如果有基础的可...
实例分割模型MaskR-CNN详解
02-24
本文来自于csdn，本文主要概述一下R-CNN是如何采用卷积神经网络进行目标检测的工作，希望会对您的学习有所帮助。MaskR-CNN是ICCV2017的bestpaper，彰显了机器学习计算机视觉领域在2017年的最新成果。在机器学习2017...
多变量自回归模型MATLAB代码实现
03-12
多变量自回归模型（Multivariate Autoregressive Model，MVAR）是一种统计分析工具，常用于研究多个时间序列之间的相互依赖关系。在MATLAB环境中，MVAR模型被广泛应用于信号处理，特别是生物医学信号分析，如脑电图...
Autoregressive Models
03-16
NULL 博文链接：https://yexin218.iteye.com/blog/445904
python 线性回归分析模型检验标准–拟合优度详解
12-20
在Python中，我们可以利用scikit-learn库来构建线性回归模型。然而，建立模型只是第一步，更重要的是评估模型的性能和适用性，其中拟合优度（Goodness of Fit）是一个关键指标。 拟合优度是用来衡量模型对数据的...
同步习题与详解——第1章 电路模型和电路定律-教程与笔记习题
05-19
标题中的“同步习题与详解”可能是指针对课程或者教学大纲中第1章内容而设计的配套习题集和详细的解答指导。 电路模型是指用数学关系或图形符号来模拟真实电路中的元件和相互作用关系的一种抽象表示方法。电路模型...
自回归生成网络--WaveNet
你这个代码我看不懂的博客
03-31 4039
WaveNet取代了对音频信号使用傅里叶变换的传统方法。它通过令神经网络找出要执行的转换来实现。因此，转换可以反向传播，原始音频数据可以通过一些技术来处理，例如膨胀卷积、8位量化等。但是人们一直在研究将WaveNet方法与传统方法相结合的方式，尽管该方式将损失函数转换为多元回归的损失函数而不是WaveNet所使用的分类。 WaveNet的基本构建模块是膨胀卷积，它取代了RNN获取上下文信息的功能 下图展示了WaveNet在进行预测时如何提取有关上下文的信息。图片的底部是输入，这是原始音频样本。例如，一个16
【自回归视觉生成（VAR）】Visual Autoregressive Modeling: Scalable Image Generation via Next-Scale Prediction
Arachis_X的博客
04-10 1734
视觉自回归模型（VAR）将图像上的自回归学习重新定义为从粗到细的 "下一尺度预测 "或 “下一分辨率预测”，有别于标准的栅格扫描 “下一标记预测”。我们提出了**视觉自回归建模（VAR）**这一新一代范式，它将图像上的自回归学习重新定义为从粗到细的 "下一尺度预测 "或 “下一分辨率预测”，有别于标准的栅格扫描 “下一标记预测”。这种简单、直观的方法使自回归（AR）变换器能够快速学习视觉分布，并具有良好的泛化能力：VAR 首次使 AR 模型在图像生成方面超越了扩散变换器。
自回归模型（Autoregressive Models）
m0_62464865的博客
05-22 2403
时间序列是随时间变化的同一变量（或变量集合）的一系列测量结果。通常情况下，这些测量是在均匀间隔的时间点上进行的，例如每月或每年。让我们首先考虑一个问题，我们有一个作为时间序列测量的y变量。例如，我们可能有y作为全球温度的测量结果，每年进行一次观测。为了强调我们对时间内测量值的存在，我们使用下标"t"代替通常的"i"，即表示在t时间段内进行的测量。自回归模型是指将时间序列中的一个值回归到该时间序列的先前值上。
多元线性回归模型模型拟合优度理论详解含公式等
05-23
多元线性回归模型是一种常见的统计分析方法，用于研究一个或多个自变量对因变量的影响关系。在实际应用中，我们需要对多元线性回归模型进行拟合，并评估拟合的优度。本文将详细介绍多元线性回归模型的拟合优度理论，包括相关概念、公式和计算方法。 1. 相关概念 在介绍拟合优度理论之前，我们先了解几个相关概念： - 总平方和（SST）：反映因变量与其平均值的差异，即所有观测值与其平均值之差的平方和。其公式为：$$ SST= \sum_{i=1}^{n}(Y_i-\bar{Y})^2 $$ - 回归平方和（SSR）：反映因变量与自变量之间的关系，即回归模型所解释的因变量差异。其公式为：$$ SSR= \sum_{i=1}^{n}(\hat{Y_i}-\bar{Y})^2 $$ 其中，$\hat{Y_i}$为第$i$个观测值的预测值。 - 误差平方和（SSE）：反映因变量与回归模型之间的差异，即回归模型未解释的因变量差异。其公式为：$$ SSE= \sum_{i=1}^{n}(Y_i-\hat{Y_i})^2 $$ - 自由度（df）：表示用于估计总体参数的独立信息数，通常为样本容量减去估计参数个数。对于多元线性回归模型，自由度为$n-p-1$，其中$n$为样本容量，$p$为自变量个数。 - 均方差（MSE）：误差平方和与自由度的比值，反映误差的平均大小。其公式为：$$ MSE= \frac{SSE}{n-p-1} $$ 2. 拟合优度 拟合优度是用来评估回归模型对数据拟合的程度，通常用$R^2$表示。$R^2$的取值范围在0到1之间，越接近1表示模型对数据的拟合越好。 $R^2$的计算公式为：$$ R^2= \frac{SSR}{SST} $$ 其中，$SSR$为回归平方和，$SST$为总平方和。 3. 调整后的拟合优度 当自变量个数增加时，$R^2$会自然地增加，但这并不意味着模型的效果变得更好了。因此，我们需要考虑自变量个数对$R^2$的影响，从而得到更准确的拟合优度。调整后的拟合优度$R_{adj}^2$考虑了自变量的个数，其计算公式为：$$ R_{adj}^2= 1-\frac{SSE/(n-p-1)}{SST/(n-1)} $$ 其中，$SSE/(n-p-1)$为均方差，$SST/(n-1)$为总体方差的无偏估计。 4. 总结 本文介绍了多元线性回归模型拟合优度的理论，包括相关概念、公式和计算方法。在实际应用中，我们可以根据$R^2$和$R_{adj}^2$来评估回归模型的拟合效果，并选择最优的自变量组合。
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

盼小辉丶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值