机器学习中的卷积类型

2025年2月3日 | 阅读11分钟

从数学的角度来看，卷积是一个积分函数，它表示当一个函数 g 在另一个函数 f 上滑动时，f 和 g 的重叠程度。

直观地说，卷积就像一个搅拌机，通过组合函数来减少数据空间，同时保持信息。

在机器学习和神经网络方面，卷积通过使用可学习参数（以滤波器（矩阵/向量）的形式）从输入数据集中提取低维特征。

它们的一个特点是能够保持输入数据点之间的位置或空间关联。卷积神经网络在相邻层之间的神经元之间强制执行局部连接模式，从而利用空间局部相关性。

直观地说，卷积是通过将滑动窗口（一个具有可学习权重的滤波器）的思想应用于输入，并产生加权和（输入和权重的加权和）作为输出的过程。作为后续层输入的特征空间就是这个加权和。

人脸识别问题是其中的一个绝佳例子，前几层卷积层学习输入图像中重要区域的压力，然后学习边缘和轮廓，最后学习人脸。在这个例子中，输入空间被减小到一个低维空间（表示点和像素的信息），然后减小到包含形状和边缘的另一个维度，最后减小到对照片中的人脸进行分类。N 维允许使用卷积。

卷积的类型

机器学习中有多种卷积类型，但我们主要可以将其分为四种类型。

一维： 最简单的卷积是一维卷积，通常用于序列数据集，但也可用于其他用例。它们可用于从输入序列中提取局部一维子序列，并在卷积窗口内识别局部模式。下图显示了如何将一维卷积滤波器应用于序列以获得新特征。一维卷积的其他常见用途出现在自然语言处理（NLP）领域，其中每个句子都表示为单词序列。
二维： 卷积神经网络（CNN）设计主要在图像数据集上使用二维卷积滤波器。卷积滤波器在两个维度（x,y）上滑动，从图像数据中提取低维特征。这是二维卷积的基本概念。二维矩阵也是输出的形式。
三维： 为了计算低级特征表示，三维卷积将三维滤波器应用于数据集。滤波器在三个方向（x, y, z）上滑动。它们产生的形状是三维体积空间，如立方体或长方体。它们对于识别三维医学图像、电影和其他媒体中的事件非常有用。它们可以与二维空间输入（如图像）一起使用，而不仅仅局限于三维空间。
空洞卷积： 内核值之间的距离由空洞卷积或膨胀卷积定义。这种卷积中的核间距增强了它们的感受野。例如，一个膨胀率为 2 的 3x3 内核将具有与 5x5 内核相同的视野。在此示例中，创建了不同的特征，但复杂性保持不变。

实施

现在我们将针对各自的问题来实现每种类型的卷积。

一维卷积

Types of Convolutions in Machine Learning

首先，我们将使用一维卷积来预测欺诈卡检测。

我们将导入所需的库。

 
import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import torch
from torch.autograd import Variable
import torch.nn as nn
from sklearn.model_selection import train_test_split
import torch.nn.functional as F
import torch.utils.data as data_utils
import matplotlib.pyplot as plt
from sklearn.metrics import accuracy_score, roc_auc_score   

然后我们需要读取数据集。

 
data_sets = pd.read_csv('/kaggle/input/creditcardfraud/creditcard.csv')

# Later we divide the target variable from the data
Y = data_sets["Class"]
X = data_sets.drop(columns=["Class"])   

现在我们将数据集分割成训练集和测试集。

 
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.1, random_state=1)   

 
# Now let's have a look
data_sets.head(5)   

输出

现在，我们将定义我们的 1D 卷积网络。

 
class classifier(nn.Module):
    def __init__(self):
        super().__init__()
        self.layer1 = nn.Conv1d(in_channels=1, out_channels=10,kernel_size=3,stride=3)
        self.layer2 = nn.Conv1d(in_channels=10, out_channels=5,kernel_size=2,stride=2)
        self.max_pool = nn.MaxPool1d(kernel_size=2, stride=1)
        self.fc1 = nn.Linear(20,10)
        self.fc2 = nn.Linear(10,2)
        self.drop_out = nn.Dropout(0.2)
        
    def forward(self, x):
        x = x.view(-1,1,30)
        x = F.relu(self.layer1(x))
        x = self.max_pool(x)
        x = F.relu(self.layer2(x))        
        # Reshape the tensor
        x = x.view(-1, 5*4)
        x = F.relu(self.fc1(x))
        x = self.drop_out(x)
        x = self.fc2(x)
        return F.log_softmax(x, dim=1)   

现在我们需要准备我们的训练集，使其适合一维卷积。

 
train_target = torch.tensor(Y_train.values.astype(np.float32))
train_data = torch.tensor(X_train.values.astype(np.float32))
train_tensor = data_utils.TensorDataset(train_data, train_target)
trainloader = data_utils.DataLoader(dataset=train_tensor, batch_size=32,shuffle=True) 

再次，我们将准备我们的测试集，使其适合一维卷积。

 
test_target = torch.tensor(Y_test.values.astype(np.float32))
test_data = torch.tensor(X_test.values.astype(np.float32))
test_tensor = data_utils.TensorDataset(test_data, test_target)
testloader = data_utils.DataLoader(dataset=test_tensor, batch_size=32)   

显然，我们必须训练我们的模型。

 
model = classifier().cuda()
criterion = nn.NLLLoss()
optimizer =  torch.optim.Adam(model.parameters(), lr=0.001)
print_every_n = 10
epochs= 10
model.to(device)
train_losses, test_losses = [], []
for epoch in range(epochs):
    running_loss = 0.0
    model.train()
    for step, (data, label) in enumerate(trainloader):
        data , label = data.to(device), label.to(device)
        optimizer.zero_grad()
        train_logps = model.forward(data)
        loss = criterion(train_logps, label.long())
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    else:
        with torch.no_grad():
            model.eval()
            running_test_loss = 0.0
            accuracy = 0.0
            for test_data, test_label in testloader:
                test_data, test_label = test_data.to(device), test_label.to(device)
                test_logps = model.forward(test_data)
                test_loss = criterion(test_logps, test_label.long())
                running_test_loss += test_loss.item()
                test_prob = torch.exp(test_logps)
                prob, predic_class = test_prob.topk(1, dim=1)
                equal = predic_class == test_label.long().view(*predic_class.shape)
                accuracy += torch.mean(equal.type(torch.FloatTensor)).item()
        train_losses.append(running_loss / len(trainloader))    
        test_losses.append(running_test_loss / len(testloader))                          
                
        print(f"Epoch= {epoch+1},Training loss = {running_loss/len(trainloader)},Test loss = {running_test_loss/len(testloader)}, Accuracy >> {accuracy/len(testloader)}")   

输出

准确率似乎非常惊人！！

 
with torch.no_grad():
    x_test = torch.tensor(X_test.values).to(device)
    predicted_value = model.forward(x_test.float()).cpu().data.numpy().argmax(axis=1)
print(f"accuracy >> {accuracy_score(predicted_value, Y_test.values)} ")
print(f"Area Under the Curve >> {roc_auc_score(predicted_value, Y_test.values)} ")   

输出

准确率： 计算所有预测中正确的比例。高准确率（如 0.9992）表明模型在预测正确类标签方面做得非常好。

曲线下面积（AUC）： ROC 曲线的 AUC 特别衡量模型区分正负类别的能力。AUC 为 0.902，尽管准确率看起来很高，但模型的区分能力被认为是中等。

二维卷积

现在我们将使用二维卷积来识别 MNIST 数据集中的数字。

首先，我们需要导入所需的库。

 
import tensorflow as tf
import numpy as np
from sklearn.cross_validation import train_test_split
from PIL import Image
from matplotlib.pyplot import imshow
from sklearn.preprocessing import OneHotEncoder
from keras.models import Sequential
from keras.layers import Dense, Flatten, Activation, Dropout, Conv2D, MaxPooling2D
from keras.utils import np_utils   

为了方便起见，我们生成随机数。

 
data = np.genfromtxt('../input/train.csv', delimiter=',', skip_header = 1)
print(data.shape)   

输出

我们获得了 42000 行和 785 列。

现在我们将数据集分割成训练集和测试集。

 
# train, test, validation split
Y = data[:,0]
X = data[:,1:]

# normalize independent variables
X = X/255

# reshaping to get image structure
X_reshaped = X.reshape((42000,28,28,1))
print(X_reshaped.shape)

# one hot label encoding
Y_encode = np.eye((np.unique(Y)).size)[Y.astype(int)]

x_train, x_test, y_train, y_test = train_test_split(X_reshaped, Y_encode, test_size = 0.3)
x_test, x_val, y_test, y_val = train_test_split(x_test, y_test, test_size = 0.5)   

输出

现在将定义用于识别图像的二维卷积层。

 
conv_net = Sequential()

# convolution layer 1
conv_net.add(Conv2D(32, (3, 3), activation='relu', input_shape=(28,28,1)))
conv_net.add(MaxPooling2D(pool_size=(3,3)))
conv_net.add(Dropout(0.5))

print(conv_net.output.shape)

# convolution layer 2
conv_net.add(Conv2D(64, (3, 3), activation='relu'))
conv_net.add(MaxPooling2D(pool_size=(3,3)))
conv_net.add(Dropout(0.5))

print(conv_net.output.shape)

# fully connected
conv_net.add(Flatten())
conv_net.add(Dense(128, activation='relu'))
conv_net.add(Dropout(0.5))
conv_net.add(Dense(10, activation='softmax'))

conv_net.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])   

输出

我们需要训练模型。

现在，我们只是将其进行测试。

 
score = conv_net.evaluate(x_test, y_test, verbose=0)
print("%s: %.2f%%" % (conv_net.metrics_names[1], score[1]*100))

score = conv_net.evaluate(x_val, y_val, verbose=0)
print("%s: %.2f%%" % (conv_net.metrics_names[1], score[1]*100))   

输出

我们在测试集和验证集上获得了很高的准确率。

三维卷积

现在我们将为三维 MNIST 数据集使用三维卷积网络。首先，我们需要导入所需的库。

 
from keras.layers import Conv3D, MaxPool3D, Flatten, Dense
from keras.layers import Dropout, Input, BatchNormalization
from sklearn.metrics import confusion_matrix, accuracy_score
from plotly.offline import iplot, init_notebook_mode
from keras.losses import categorical_crossentropy
from keras.optimizers import Adadelta
import plotly.graph_objs as go
from matplotlib.pyplot import cm
from keras.models import Model
import numpy as np
import keras
import h5py

init_notebook_mode(connected=True)
%matplotlib inline  

由于三维 MNIST 数据以 .h5 格式提供，让我们将整个数据集加载到测试集和训练集中。

 
with h5py.File('../input/full_dataset_vectors.h5', 'r') as dataset:
    x_train = dataset["X_train"][:]
    x_test = dataset["X_test"][:]
    y_train = dataset["y_train"][:]
    y_test = dataset["y_test"][:]   

现在我们来检查数据集的维度。

 
print ("x_train shape: ", x_train.shape)
print ("y_train shape: ", y_train.shape)

print ("x_test shape:  ", x_test.shape)
print ("y_test shape:  ", y_test.shape)   

输出

尽管此数据集是一维平坦的，但数据集的作者还在另一个数据文件中提供了原始的 x、y 和 z 数据。让我们绘制一个三维数字。为了正确查看此三维数字，我们将对其进行旋转。

 
with h5py.File("../input/train_point_clouds.h5", "r") as points_dataset:        
    digits = []
    for i in range(10):
        digit = (points_dataset[str(i)]["img"][:], 
                 points_dataset[str(i)]["points"][:], 
                 points_dataset[str(i)].attrs["label"]) 
        digits.append(digit)
        
x_c = [r[0] for r in digits[0][1]]
y_c = [r[1] for r in digits[0][1]]
z_c = [r[2] for r in digits[0][1]]
trace1 = go.Scatter3d(x=x_c, y=y_c, z=z_c, mode='markers', 
                      marker=dict(size=12, color=z_c, colorscale='Viridis', opacity=0.7))

data = [trace1]
layout = go.Layout(height=500, width=600, title= "Digit: "+str(digits[0][2]) + " in 3D space")
fig = go.Figure(data=data, layout=layout)
iplot(fig)   

输出

现在，让我们使用此数据集创建一个三维卷积神经网络。在使用二维卷积之前，我们首先将每个图像转换为三维形状——宽度、高度和通道。红色、绿色和蓝色层切片由通道表示。因此，它被配置为 3。类似地，我们将使用输入数据集的四维形状转换来启用长度、宽度、高度和通道（r/g/b）的三维卷积。

 
## Introduce the channel dimension in the input dataset 
xtrain = np.ndarray((x_train.shape[0], 4096, 3))
xtest = np.ndarray((x_test.shape[0], 4096, 3))

## iterate in train and test, add the rgb dimension 
def add_rgb_dimention(array):
    scaler_map = cm.ScalarMappable(cmap="Oranges")
    array = scaler_map.to_rgba(array)[:, : -1]
    return array
for i in range(x_train.shape[0]):
    xtrain[i] = add_rgb_dimention(x_train[i])
for i in range(x_test.shape[0]):
    xtest[i] = add_rgb_dimention(x_test[i])

class Conv2d(tf.Module):
  # Note the added `**kwargs`, as Keras supports many arguments
    def __init__(self,
                 filters,
                 kernel_size,
                 strides=(1, 1),
                 padding="SAME",
                 data_format=None,
                 dilation_rate=(1, 1),
                 use_bias=True,
                 **kwargs):
        super().__init__(**kwargs)
        self.filters = filters
        self.kernel_size = kernel_size
        self.strides = strides
        self.padding = padding
        self.is_built = False
    
    # Create the state of the layer (weights)
    def build(self, inputs) -> None:  
        self.w = tf.Variable(
            tf.random.truncated_normal(
                [self.kernel_size, self.kernel_size, inputs.shape[-1], self.filters],
                stddev=0.03), name='w'
        )
        
        self.b = tf.Variable(
            tf.zeros([self.filters]),
            name='b'
        )
              
    @tf.function
    def __call__(self, inputs):  # Defines the computation from inputs to outputs
        if not self.is_built:
            self.build(inputs)
            self.is_built = True
        return tf.nn.conv2d(inputs, self.w, self.strides, self.padding) + self.b

## Introduce the channel dimension in the input dataset 
xtrain = np.ndarray((x_train.shape[0], 4096, 3))
xtest = np.ndarray((x_test.shape[0], 4096, 3))

## iterate in train and test, add the rgb dimension 
def add_rgb_dimention(array):
    scaler_map = cm.ScalarMappable(cmap="Oranges")
    array = scaler_map.to_rgba(array)[:, : -1]
    return array
for i in range(x_train.shape[0]):
    xtrain[i] = add_rgb_dimention(x_train[i])
for i in range(x_test.shape[0]):
    xtest[i] = add_rgb_dimention(x_test[i])

## convert to 1 + 4D space (1st argument represents number of rows in the dataset)
xtrain = xtrain.reshape(x_train.shape[0], 16, 16, 16, 3)
xtest = xtest.reshape(x_test.shape[0], 16, 16, 16, 3)

## Convert target variable into one-hot
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)

y_train.shape   

输出

三个输出层，维度为 16、16、16，一个输入层，维度为 10。应用四个卷积层，具有恒定的核大小 (3, 3, 3) 和递增的滤波器大小（典型大小：8、16、32、64）。

在第二个和第四个卷积层分别放置两个最大池化层。

 
## input layer
input_layer = Input((16, 16, 16, 3))

## convolutional layers
conv_layer1 = Conv3D(filters=8, kernel_size=(3, 3, 3), activation='relu')(input_layer)
conv_layer2 = Conv3D(filters=16, kernel_size=(3, 3, 3), activation='relu')(conv_layer1)

## Add max pooling to obtain the most informative features
pooling_layer1 = MaxPool3D(pool_size=(2, 2, 2))(conv_layer2)

conv_layer3 = Conv3D(filters=32, kernel_size=(3, 3, 3), activation='relu')(pooling_layer1)
conv_layer4 = Conv3D(filters=64, kernel_size=(3, 3, 3), activation='relu')(conv_layer3)
pooling_layer2 = MaxPool3D(pool_size=(2, 2, 2))(conv_layer4)

## Perform batch normalization on the convolution outputs before feeding it to MLP architecture
pooling_layer2 = BatchNormalization()(pooling_layer2)
flatten_layer = Flatten()(pooling_layer2)

## Create an MLP architecture with dense layers: 4096 -> 512 -> 10
## add dropouts to avoid overfitting / perform regularization
dense_layer1 = Dense(units=2048, activation='relu')(flatten_layer)
dense_layer1 = Dropout(0.4)(dense_layer1)
dense_layer2 = Dense(units=512, activation='relu')(dense_layer1)
dense_layer2 = Dropout(0.4)(dense_layer2)
output_layer = Dense(units=10, activation='softmax')(dense_layer2)

## Define the model with the input layer and output layer
model = Model(inputs=input_layer, outputs=output_layer)  

现在，让我们编译并训练模型。

 
model.compile(loss=categorical_crossentropy, optimizer=Adadelta(lr=0.1), metrics=['acc'])
model.fit(x=xtrain, y=y_train, batch_size=128, epochs=50, validation_split=0.2)   

输出

我们可以看到验证集的准确率在模型训练过程中有所变化，这表明网络可以进一步改进。让我们预测并评估当前模型的准确率。

 
pred = model.predict(xtest)
pred = np.argmax(pred, axis=1)
pred   

输出

 
score = conv_net.evaluate(x_test, y_test, verbose=0)
print("%s: %.2f%%" % (conv_net.metrics_names[1], score[1]*100)) 

输出

尽管模型目前不太准确，但通过架构修改和超参数调整，可以使其变得更好。

空洞卷积

现在我们将尝试使用空洞卷积生成 CAM（分类激活图）。

首先，我们需要导入所需的库。

 
import cv2
import matplotlib.pyplot as plt
import torch
from torchvision import transforms
import torchvision
import torchvision.models as models
from PIL import Image  

让我们获取数据集

 
imdir = '/kaggle/input/fruit-images-for-object-detection/train_zip/train/'
filenames = os.listdir(imdir)
filenames = list(s for s in filenames if 'jpg' in s)   

我们现在创建我们的数据加载器。

 
image_size = 506
num_classes = 3

class CatsDogsDataset(torch.utils.data.Dataset):
    
    def __init__(self, filenames, transform = None):
        self.filenames = filenames
        self.transform = transform
    
    def __len__(self):
        return len(self.filenames)
    
    def __getitem__(self, idx):
        filename = imdir + self.filenames[idx]
        image = cv2.cvtColor(cv2.imread(filename), cv2.COLOR_BGR2RGB)
        if self.transform is not None:
            image = self.transform(image)
        label = 1 if 'apple' in filename else 2 if 'banana' in filename else 0
        return image, np.array(label)
    
transform = transforms.Compose([
    transforms.ToPILImage(),
    transforms.Resize((image_size, image_size)),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize(
      mean=[0.485, 0.456, 0.406],
      std=[0.229, 0.224, 0.225]
    )
])    
dataset = CatsDogsDataset(filenames, transform)
dataloader = torch.utils.data.DataLoader(dataset,
                                        batch_size = 32,
                                        shuffle = True)   

现在我们将创建我们的空洞卷积网络。

 
class DilatedCNN(BaseModel):
    
    def __init__(self, in_channels, num_classes):
        super(DilatedCNN, self).__init__()
        self.conv11 = torch.nn.Conv2d(in_channels = 3, out_channels = 32, kernel_size = 3)
        self.conv12 = torch.nn.Conv2d(in_channels = 32, out_channels = 32, kernel_size = 3)
        self.pool1 = torch.nn.MaxPool2d(kernel_size = 2, stride = 2)

        self.conv21 = torch.nn.Conv2d(in_channels = 32, out_channels = 64, kernel_size = 3)
        self.conv22 = torch.nn.Conv2d(in_channels = 64, out_channels = 64, kernel_size = 3)
        
        self.conv31 = torch.nn.Conv2d(in_channels = 64, out_channels = 128, kernel_size = 3, dilation = 2, padding = 2)
        
        self.conv41 = torch.nn.Conv2d(in_channels = 128, out_channels = 256, kernel_size = 3, dilation = 2, padding = 2)
        
        
        self.avg = torch.nn.AvgPool2d(kernel_size = 247)
        self.fc = torch.nn.Linear(256, num_classes)
        
    def get_feature_map(self, input):
        out = self.conv11(input)
        out = self.conv12(out)
        out = self.pool1(out)
        out = torch.nn.ReLU()(out)
        
        out = self.conv21(out)
        out = self.conv22(out)
        out = torch.nn.ReLU()(out)
        
        out = self.conv31(out)
        out = torch.nn.ReLU()(out)
        
        out = self.conv41(out)
        out = torch.nn.ReLU()(out)
        
        return out   

 
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
epochs = 20
dilatedCnn.to(device)   

输出

我们必须训练我们的模型。

 
def train_model(model, epochs, lr = 0.001):
    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
    criterion = torch.nn.CrossEntropyLoss()
    
    for epoch in range(epochs):
        for idx, (data, label) in enumerate(dataloader):
            optimizer.zero_grad()
            data = data.to(device).float()
            label = label.to(device).float()
            pred = model(data)
            loss = criterion(pred, label.long())
            loss.backward()
            optimizer.step()
            if idx % 10 == 0:
                y_hat = torch.argmax(pred, dim = 1)
                correct = (y_hat == label).sum()
                print(f"Epoch {epoch} Loss = {loss.data:.03f}, acc = {correct / label.shape[0]:.02f}")
train_model(dilatedCnn, epochs)   

输出

现在让我们生成一些 CAM

 
dilatedCnn.cpu()

n = 7
fig, axs = plt.subplots(n, 3, figsize=(15,25))

for i in range(n):
    im = cv2.cvtColor(cv2.imread(imdir + filenames[i]), cv2.COLOR_BGR2RGB)
    axs[i, 0].imshow(im)
    axs[i, 0].set_title('Original image')
    
    classIdx = 1 if 'apple' in filename else 2 if 'banana' in filename else 0
    im = transform(im).reshape(1,3, 506, 506)
    dilatedCnnCams = dilatedCnn.get_cams(im).detach().numpy()
   
    axs[i, 2].imshow(dilatedCnnCams[0][classIdx])
    axs[i, 2].set_title('Dilated CNN CAM')

plt.show()   

输出

下一个主题机器学习工具

← 上一个下一个 →

机器学习中的卷积类型

卷积的类型

实施

一维卷积

二维卷积

三维卷积

空洞卷积

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

机器学习

监督式学习

分类

杂项

相关教程

面试题

机器学习中的卷积类型

卷积的类型

实施

一维卷积

二维卷积

三维卷积

空洞卷积

相关帖子

餐厅评论的 NLP 分析

理解用于机器学习回归的 3 种最常见的损失函数

机器学习中的剪枝

什么是 MLOps

半监督学习

概率密度函数

贝叶斯主动学习与最优实验设计

深度学习中的注意力机制

贝叶斯定理的直观解释

ACF 和 PCF

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器