7.4. Multiple Input and Multiple Output Channels — Dive into Deep Learning 1.0.0-beta0 documentation (d2l.ai)

7.4. Multiple Input and Multiple Output Channels

While we described the multiple channels that comprise each image (e.g., color images have the standard RGB channels to indicate the amount of red, green and blue) and convolutional layers for multiple channels in Section 7.1.4, until now, we simplified all of our numerical examples by working with just a single input and a single output channel. This allowed us to think of our inputs, convolution kernels, and outputs each as two-dimensional tensors.

섹션 7.1.4에서 각 이미지를 구성하는 여러 채널(예: 컬러 이미지에는 빨강, 녹색 및 파랑의 양을 나타내는 표준 RGB 채널이 있음)과 여러 채널에 대한 컨볼루션 레이어에 대해 설명했지만 지금까지 모든 이미지를 단순화했습니다. 단일 입력 및 단일 출력 채널로 작업하여 수치 예를 들어 보겠습니다. 이를 통해 입력, 컨볼루션 커널 및 출력을 각각 2차원 텐서로 생각할 수 있습니다.

When we add channels into the mix, our inputs and hidden representations both become three-dimensional tensors. For example, each RGB input image has shape 3×ℎ×w. We refer to this axis, with a size of 3, as the channel dimension. The notion of channels is as old as CNNs themselves. For instance LeNet5 (LeCun et al., 1995) uses them. In this section, we will take a deeper look at convolution kernels with multiple input and multiple output channels.

mix에 채널을 추가하면 입력과 hidden representations이 3차원 텐서가 됩니다. 예를 들어 각 RGB 입력 이미지의 모양은 3×ℎ×w입니다. 크기가 3인 이 축을 channel dimension이라고 합니다. 채널의 개념은 CNN 자체만큼이나 오래되었습니다. 예를 들어 LeNet5(LeCun et al., 1995)가 그것을 사용합니다. 이 섹션에서는 다중 입력 및 다중 출력 채널이 있는 컨볼루션 커널에 대해 자세히 살펴보겠습니다.

import torch
from d2l import torch as d2l

7.4.1. Multiple Input Channels

When the input data contains multiple channels, we need to construct a convolution kernel with the same number of input channels as the input data, so that it can perform cross-correlation with the input data. Assuming that the number of channels for the input data is ci, the number of input channels of the convolution kernel also needs to be ci. If our convolution kernel’s window shape is kℎ×kw, then when ci=1, we can think of our convolution kernel as just a two-dimensional tensor of shape kℎ×kw.

입력 데이터가 여러 채널을 포함하는 경우 입력 데이터와 상호 상관을 수행할 수 있도록 입력 데이터와 동일한 수의 입력 채널로 컨볼루션 커널을 구성해야 합니다. 입력 데이터의 채널 수가 ci라고 가정하면 컨볼루션 커널의 입력 채널 수도 ci가 되어야 합니다. 컨볼루션 커널의 창 모양이 kℎ×kw이면 ci=1일 때 컨볼루션 커널을 kℎ×kw 모양의 2차원 텐서로 생각할 수 있습니다.

However, when ci>1, we need a kernel that contains a tensor of shape kℎ×kw for every input channel. Concatenating these ci tensors together yields a convolution kernel of shape ci×kℎ×kw. Since the input and convolution kernel each have ci channels, we can perform a cross-correlation operation on the two-dimensional tensor of the input and the two-dimensional tensor of the convolution kernel for each channel, adding the ci results together (summing over the channels) to yield a two-dimensional tensor. This is the result of a two-dimensional cross-correlation between a multi-channel input and a multi-input-channel convolution kernel.

그러나 ci>1이면 모든 입력 채널에 대해 shape kℎ×kw의 텐서를 포함하는 커널이 필요합니다. 이 ci 텐서를 함께 연결하면 ci×kℎ×kw 모양의 컨볼루션 커널이 생성됩니다. 입력 및 컨볼루션 커널에는 각각 ci 채널이 있으므로 각 채널에 대한 입력의 2차원 텐서와 컨볼루션 커널의 2차원 텐서에 대해 cross-correlation 연산을 수행하여 ci 결과를 함께 더할 수 있습니다(합산 채널)을 사용하여 2차원 텐서를 생성합니다. 이것은 다중 채널 입력과 다중 입력 채널 컨볼루션 커널 사이의 2차원 cross-correlation의 결과입니다.

Fig. 7.4.1 provides an example of a two-dimensional cross-correlation with two input channels. The shaded portions are the first output element as well as the input and kernel tensor elements used for the output computation: (1×1+2×2+4×3+5×4)+(0×0+1×1+3×2+4×3)=56.

그림 7.4.1은 2개의 입력 채널이 있는 2차원 상호 상관의 예를 제공합니다. 음영 부분은 출력 계산에 사용되는 입력 및 커널 텐서 요소뿐만 아니라 첫 번째 출력 요소입니다. (1×1+2×2+4×3+5×4)+(0×0+1×1+ 3×2+4×3)=56.

To make sure we really understand what is going on here, we can implement cross-correlation operations with multiple input channels ourselves. Notice that all we are doing is performing a cross-correlation operation per channel and then adding up the results.

여기서 무슨 일이 일어나고 있는지 확실히 이해하기 위해 여러 입력 채널을 사용하여 상호 상관 작업을 직접 구현할 수 있습니다. 우리가 하는 일은 채널당 교차 상관 작업을 수행한 다음 결과를 합산하는 것뿐입니다.

def corr2d_multi_in(X, K):
    # Iterate through the 0th dimension (channel) of K first, then add them up
    return sum(d2l.corr2d(x, k) for x, k in zip(X, K))

• corr2d_multi_in 함수는 다중 입력 채널에 대한 2D 크로스-코릴레이션을 수행합니다.
• X는 입력 데이터를 나타내며, K는 커널을 나타냅니다.
• zip(X, K)를 사용하여 X와 K를 쌍으로 묶어 순회하면서 corr2d 함수를 적용한 결과를 모두 더하여 반환합니다.

https://www.programiz.com/python-programming/methods/built-in/zip

We can construct the input tensor X and the kernel tensor K corresponding to the values in Fig. 7.4.1 to validate the output of the cross-correlation operation.

그림 7.4.1의 값에 해당하는 입력 텐서 X와 커널 텐서 K를 구성하여 상호 상관 연산의 출력을 검증할 수 있습니다.

X = torch.tensor([[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],
               [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]])
K = torch.tensor([[[0.0, 1.0], [2.0, 3.0]], [[1.0, 2.0], [3.0, 4.0]]])

corr2d_multi_in(X, K)

• X는 입력 데이터를 나타내며, shape은 (2, 3, 3)입니다. 즉, 2개의 채널을 가지며 각 채널은 3x3 크기의 2D 행렬입니다.
• K는 커널을 나타내며, shape은 (2, 2, 2)입니다. 즉, 2개의 채널을 가지며 각 채널은 2x2 크기의 2D 행렬입니다.
• corr2d_multi_in(X, K)를 호출하여 X와 K의 다중 입력 채널에 대한 2D 크로스-코릴레이션을 계산합니다. 결과는 (2, 2) shape을 가진 2D 텐서로 반환됩니다.

7.4.2. Multiple Output Channels

Regardless of the number of input channels, so far we always ended up with one output channel. However, as we discussed in Section 7.1.4, it turns out to be essential to have multiple channels at each layer. In the most popular neural network architectures, we actually increase the channel dimension as we go deeper in the neural network, typically downsampling to trade off spatial resolution for greater channel depth. Intuitively, you could think of each channel as responding to a different set of features. The reality is a bit more complicated than this. A naive interpretation would suggest that representations are learned independently per pixel or per channel. Instead, channels are optimized to be jointly useful. This means that rather than mapping a single channel to an edge detector, it may simply mean that some direction in channel space corresponds to detecting edges.

입력 채널 수에 관계없이 지금까지 우리는 항상 하나의 출력 채널로 끝났습니다. 그러나 섹션 7.1.4에서 논의한 것처럼 각 계층에 여러 채널을 갖는 것이 필수적임이 밝혀졌습니다. 가장 널리 사용되는 신경망 아키텍처에서 우리는 신경망이 더 깊어짐에 따라 실제로 채널 차원을 증가시키고 일반적으로 더 큰 채널 깊이를 위해 공간 해상도를 절충하기 위해 다운샘플링합니다. 직관적으로 각 채널이 서로 다른 기능 집합에 응답한다고 생각할 수 있습니다. 현실은 이것보다 조금 더 복잡합니다. 순진한 해석은 표현이 픽셀 또는 채널별로 독립적으로 학습된다고 제안합니다. 대신 채널은 공동으로 유용하도록 최적화됩니다. 이는 단일 채널을 에지 검출기에 매핑하는 것이 아니라 단순히 채널 공간의 일부 방향이 에지 검출에 해당함을 의미할 수 있음을 의미합니다.

Denote by ci and co the number of input and output channels, respectively, and let kℎ and kw be the height and width of the kernel. To get an output with multiple channels, we can create a kernel tensor of shape ci×kℎ×kw for every output channel. We concatenate them on the output channel dimension, so that the shape of the convolution kernel is co×ci×kℎ×kw. In cross-correlation operations, the result on each output channel is calculated from the convolution kernel corresponding to that output channel and takes input from all channels in the input tensor.

ci 및 co는 각각 입력 및 출력 채널의 수를 나타내고 kℎ 및 kw는 커널의 높이 및 너비입니다. 여러 채널의 출력을 얻기 위해 모든 출력 채널에 대해 모양 ci×kℎ×kw의 커널 텐서를 만들 수 있습니다. 컨볼루션 커널의 모양이 co×ci×kℎ×kw가 되도록 출력 채널 차원에서 이들을 연결합니다. 교차 상관 연산에서 각 출력 채널의 결과는 해당 출력 채널에 해당하는 컨벌루션 커널에서 계산되며 입력 텐서의 모든 채널에서 입력을 받습니다.

We implement a cross-correlation function to calculate the output of multiple channels as shown below.

아래와 같이 여러 채널의 출력을 계산하기 위해 교차 상관 함수를 구현합니다.

def corr2d_multi_in_out(X, K):
    # Iterate through the 0th dimension of K, and each time, perform
    # cross-correlation operations with input X. All of the results are
    # stacked together
    return torch.stack([corr2d_multi_in(X, k) for k in K], 0)

• X는 입력 데이터를 나타내며, shape은 (2, 3, 3)입니다. 즉, 2개의 입력 채널을 가지며 각 채널은 3x3 크기의 2D 행렬입니다.
• K는 커널을 나타내며, shape은 (3, 2, 2, 2)입니다. 즉, 3개의 입력 채널과 2개의 출력 채널을 가지며 각 채널은 2x2 크기의 2D 행렬입니다.
• corr2d_multi_in_out(X, K)를 호출하여 다중 입력 채널과 다중 출력 채널에 대한 2D 크로스-코릴레이션을 계산합니다. 결과는 (3, 2, 2) shape을 가진 3D 텐서로 반환됩니다.

We construct a trivial convolution kernel with 3 output channels by concatenating the kernel tensor for K with K+1 and K+2.

우리는 K에 대한 커널 텐서를 K+1 및 K+2와 연결하여 3개의 출력 채널이 있는 trivial convolution 커널을 구성합니다.

K = torch.stack((K, K + 1, K + 2), 0)
K.shape

• K는 커널을 나타내는 텐서입니다.
• torch.stack((K, K + 1, K + 2), 0)를 사용하여 K의 차원 0을 따라 여러 개의 커널을 쌓습니다.
• 결과적으로 K의 shape은 (3, 2, 2, 2)가 됩니다. 즉, 3개의 커널을 가지며 각 커널은 2개의 입력 채널과 2개의 출력 채널을 가지는 2x2 크기의 2D 행렬입니다.

Below, we perform cross-correlation operations on the input tensor X with the kernel tensor K. Now the output contains 3 channels. The result of the first channel is consistent with the result of the previous input tensor X and the multi-input channel, single-output channel kernel.

아래에서는 입력 텐서 X와 커널 텐서 K에 대한 상호 상관 연산을 수행합니다. 이제 출력에는 3개의 채널이 포함됩니다. 첫 번째 채널의 결과는 이전 입력 텐서 X 및 다중 입력 채널, 단일 출력 채널 커널의 결과와 일치합니다.

corr2d_multi_in_out(X, K)

• X는 입력 데이터를 나타내는 텐서입니다.
• K는 커널을 나타내는 텐서입니다.
• corr2d_multi_in_out(X, K) 함수는 K의 차원 0을 따라 반복하면서 X와의 크로스-코릴레이션 연산을 수행합니다.
• 결과적으로 모든 결과가 스택되어 텐서로 반환됩니다. 반환된 텐서의 shape은 (3, 1, 2, 2)가 됩니다. 즉, 3개의 커널을 가지며 각 커널은 1개의 입력 채널과 2개의 출력 채널을 가지는 2x2 크기의 2D 행렬입니다.

7.4.3. 1×1 Convolutional Layer

At first, a 1×1 convolution, i.e., kℎ=kw=1, does not seem to make much sense. After all, a convolution correlates adjacent pixels. A 1×1 convolution obviously does not. Nonetheless, they are popular operations that are sometimes included in the designs of complex deep networks (Lin et al., 2013, Szegedy et al., 2017) Let’s see in some detail what it actually does.

처음에는 1×1 컨벌루션, 즉 kℎ=kw=1이 별 의미가 없는 것 같습니다. 결국 컨볼루션은 인접한 픽셀을 연관시킵니다. 1×1 컨볼루션은 분명히 그렇지 않습니다. 그럼에도 불구하고 복잡한 심층 네트워크의 설계에 때때로 포함되는 인기 있는 작업입니다(Lin et al., 2013, Szegedy et al., 2017) 실제로 어떤 일을 하는지 자세히 살펴보겠습니다.

Because the minimum window is used, the 1×1 convolution loses the ability of larger convolutional layers to recognize patterns consisting of interactions among adjacent elements in the height and width dimensions. The only computation of the 1×1 convolution occurs on the channel dimension.

minimum window이 사용되기 때문에 1×1 컨볼루션은 높이와 너비 차원에서 인접한 요소 간의 상호 작용으로 구성된 패턴을 인식하는 더 큰 컨볼루션 레이어의 기능을 잃습니다. 1×1 컨벌루션의 유일한 계산은 채널 차원에서 발생합니다.

Fig. 7.4.2 shows the cross-correlation computation using the 1×1 convolution kernel with 3 input channels and 2 output channels. Note that the inputs and outputs have the same height and width. Each element in the output is derived from a linear combination of elements at the same position in the input image. You could think of the 1×1 convolutional layer as constituting a fully connected layer applied at every single pixel location to transform the ci corresponding input values into c0 output values. Because this is still a convolutional layer, the weights are tied across pixel location. Thus the 1×1 convolutional layer requires co×ci weights (plus the bias). Also note that convolutional layers are typically followed by nonlinearities. This ensures that 1×1 convolutions cannot simply be folded into other convolutions.

그림 7.4.2는 3개의 입력 채널과 2개의 출력 채널이 있는 1×1 컨볼루션 커널을 사용한 교차 상관 계산을 보여줍니다. 입력과 출력의 높이와 너비는 동일합니다. 출력의 각 요소는 입력 이미지의 동일한 위치에 있는 요소의 선형 조합에서 파생됩니다. 1×1 컨벌루션 레이어는 모든 단일 픽셀 위치에 적용되는 완전 연결 레이어를 구성하여 ci 해당 입력 값을 c0 출력 값으로 변환하는 것으로 생각할 수 있습니다. 이것은 여전히 컨볼루션 레이어이기 때문에 가중치는 픽셀 위치 전체에 묶여 있습니다. 따라서 1×1 컨벌루션 레이어에는 co×ci 가중치(바이어스 포함)가 필요합니다. 또한 컨볼루션 레이어 다음에는 일반적으로 비선형성이 뒤따릅니다. 이렇게 하면 1×1 컨볼루션이 단순히 다른 컨볼루션으로 접힐 수 없습니다.

Let’s check whether this works in practice: we implement a 1×1 convolution using a fully connected layer. The only thing is that we need to make some adjustments to the data shape before and after the matrix multiplication.

이것이 실제로 작동하는지 확인해 보겠습니다. 완전 연결 레이어를 사용하여 1×1 컨볼루션을 구현합니다. 유일한 것은 행렬 곱셈 전후에 데이터 모양을 약간 조정해야 한다는 것입니다.

def corr2d_multi_in_out_1x1(X, K):
    c_i, h, w = X.shape
    c_o = K.shape[0]
    X = X.reshape((c_i, h * w))
    K = K.reshape((c_o, c_i))
    # Matrix multiplication in the fully connected layer
    Y = torch.matmul(K, X)
    return Y.reshape((c_o, h, w))

• X는 입력 데이터를 나타내는 텐서입니다.
• K는 커널을 나타내는 텐서입니다.
• c_i, h, w는 X의 차원을 나타냅니다. c_i는 입력 채널의 개수, h는 높이, w는 너비입니다.
• c_o는 K의 차원 0의 크기로, 출력 채널의 개수를 나타냅니다.
• X와 K를 형태에 맞게 재조정합니다. X는 (c_i, h * w) 형태로, K는 (c_o, c_i) 형태로 재조정됩니다.
• 행렬 곱셈을 통해 완전 연결 층에서의 계산을 수행합니다. Y = torch.matmul(K, X)를 통해 결과를 얻습니다.
• 최종적으로 Y를 (c_o, h, w) 형태로 재조정하여 반환합니다. 즉, 출력 채널 개수가 c_o이고 높이와 너비가 같은 2D 텐서를 반환합니다.

When performing 1×1 convolutions, the above function is equivalent to the previously implemented cross-correlation function corr2d_multi_in_out. Let’s check this with some sample data.

1×1 컨벌루션을 수행할 때 위의 함수는 이전에 구현된 교차 상관 함수 corr2d_multi_in_out과 동일합니다. 몇 가지 샘플 데이터로 이를 확인해보자.

X = torch.normal(0, 1, (3, 3, 3))
K = torch.normal(0, 1, (2, 3, 1, 1))
Y1 = corr2d_multi_in_out_1x1(X, K)
Y2 = corr2d_multi_in_out(X, K)
assert float(torch.abs(Y1 - Y2).sum()) < 1e-6

• X는 평균 0, 표준 편차 1인 정규 분포를 따르는 3차원 텐서입니다. 크기는 (3, 3, 3)입니다.
• K는 평균 0, 표준 편차 1인 정규 분포를 따르는 4차원 텐서입니다. 크기는 (2, 3, 1, 1)입니다. 이는 1x1 커널을 사용하는 다중 입력 다중 출력(conv2d_multi_in_out_1x1) 연산에 사용됩니다.
• Y1은 X와 K를 사용하여 1x1 커널을 적용한 다중 입력 다중 출력(conv2d_multi_in_out_1x1) 연산의 결과입니다.
• Y2는 X와 K를 사용하여 일반적인 다중 입력 다중 출력(conv2d_multi_in_out) 연산의 결과입니다.
• Y1과 Y2의 차이를 절댓값으로 계산하고 그 합이 1e-6보다 작은지 확인합니다. 즉, 두 연산의 결과가 거의 동일한지 확인하는 검증(assert)입니다.

7.4.4. Discussion

Channels allow us to combine the best of both worlds: MLPs that allow for significant nonlinearities and convolutions that allow for localized analysis of features. In particular, channels allow the CNN to reason with multiple features, such as edge and shape detectors at the same time. They also offer a practical trade-off between the drastic parameter reduction arising from translation invariance and locality, and the need for expressive and diverse models in computer vision.

채널을 통해 두 세계의 장점을 결합할 수 있습니다. 중요한 비선형성을 허용하는 MLP와 기능의 국지적 분석을 허용하는 컨볼루션입니다. 특히 채널을 통해 CNN은 모서리 및 모양 감지기와 같은 여러 기능을 동시에 추론할 수 있습니다. 또한 변환 불변성 및 지역성으로 인해 발생하는 급격한 매개변수 감소와 컴퓨터 비전에서 표현적이고 다양한 모델에 대한 필요성 사이의 실용적인 절충안을 제공합니다.

그러나 이러한 유연성에는 대가가 따른다는 점에 유의하십시오. 크기가 (ℎ×w)인 이미지가 주어지면 k×k 컨벌루션을 계산하는 비용은 O(ℎ⋅w⋅k2)입니다. ci 및 co 입력 및 출력 채널의 경우 각각 O(ℎ⋅w⋅k2⋅ci⋅co)로 증가합니다. 5×5 커널과 각각 128개의 입력 및 출력 채널이 있는 256×256 픽셀 이미지의 경우 이는 530억 개가 넘는 작업에 해당합니다(곱셈과 덧셈은 별도로 계산함). 나중에 우리는 ResNeXt(Xie et al., 2017)와 같은 아키텍처로 이어지는 채널별 작업이 블록 대각선이 되도록 요구함으로써 비용을 절감하는 효과적인 전략에 직면하게 될 것입니다.

7.4.5. Exercises

7.3. Padding and Stride — Dive into Deep Learning 1.0.0-beta0 documentation (d2l.ai)

7.3. Padding and Stride

Recall the example of a convolution in Fig. 7.2.1. The input had both a height and width of 3 and the convolution kernel had both a height and width of 2, yielding an output representation with dimension 2×2. Assuming that the input shape is nℎ×nw and the convolution kernel shape is kℎ×kw, the output shape will be (nℎ−kℎ+1)×(nw−kw+1): we can only shift the convolution kernel so far until it runs out of pixels to apply the convolution to.

그림 7.2.1의 컨벌루션의 예를 상기하십시오. 입력은 높이와 너비가 모두 3이고 컨볼루션 커널은 높이와 너비가 모두 2이므로 크기가 2×2인 출력 표현이 생성됩니다. 입력 형태가 nℎ×nw이고 컨볼루션 커널 형태가 kℎ×kw라고 가정하면, 출력 형태는 (nℎ−kℎ+1)×(nw−kw+1)입니다. 컨볼루션을 적용할 픽셀이 부족해 질때 까지만 컨볼루션 커널을 이동할 수 있습니다.

In the following we will explore a number of techniques, including padding and strided convolutions, that offer more control over the size of the output. As motivation, note that since kernels generally have width and height greater than 1, after applying many successive convolutions, we tend to wind up with outputs that are considerably smaller than our input. If we start with a 240×240 pixel image, 10 layers of 5×5 convolutions reduce the image to 200×200 pixels, slicing off 30% of the image and with it obliterating any interesting information on the boundaries of the original image. Padding is the most popular tool for handling this issue. In other cases, we may want to reduce the dimensionality drastically, e.g., if we find the original input resolution to be unwieldy. Strided convolutions are a popular technique that can help in these instances.

다음에서는 패딩 및 스트라이드 컨볼루션을 포함하여 출력 크기를 더 잘 제어할 수 있는 여러 기술을 살펴보겠습니다. 동기 부여로, 커널은 일반적으로 너비와 높이가 1보다 크기 때문에 많은 연속 컨볼루션을 적용한 후 입력보다 상당히 작은 출력으로 마무리되는 경향이 있습니다. 240×240픽셀 이미지로 시작하면 5×5 컨볼루션의 10개 레이어가 이미지를 200×200픽셀로 축소하여 이미지의 30%를 잘라내고 원본 이미지의 경계에 대한 흥미로운 정보를 제거합니다. 패딩은 이 문제를 처리하는 데 가장 널리 사용되는 도구입니다. 다른 경우, 예를 들어 원래 입력 해상도가 다루기 힘든 경우와 같이 차원을 대폭 줄이고 싶을 수 있습니다. Strided convolution은 이러한 경우에 도움이 될 수 있는 인기 있는 기술입니다.

import torch
from torch import nn

7.3.1. Padding

As described above, one tricky issue when applying convolutional layers is that we tend to lose pixels on the perimeter of our image. Consider Fig. 7.3.1 that depicts the pixel utilization as a function of the convolution kernel size and the position within the image. The pixels in the corners are hardly used at all.

위에서 설명한 것처럼 컨볼루션 레이어를 적용할 때 까다로운 문제 중 하나는 이미지 주변에서 픽셀이 손실되는 경향이 있다는 것입니다. 컨벌루션 커널 크기와 이미지 내 위치의 함수로 픽셀 활용도를 나타내는 그림 7.3.1을 고려하십시오. 모서리의 픽셀은 거의 사용되지 않습니다.

Since we typically use small kernels, for any given convolution, we might only lose a few pixels, but this can add up as we apply many successive convolutional layers. One straightforward solution to this problem is to add extra pixels of filler around the boundary of our input image, thus increasing the effective size of the image. Typically, we set the values of the extra pixels to zero. In Fig. 7.3.2, we pad a 3×3 input, increasing its size to 5×5. The corresponding output then increases to a 4×4 matrix. The shaded portions are the first output element as well as the input and kernel tensor elements used for the output computation: 0×0+0×1+0×2+0×3=0.

우리는 일반적으로 작은 커널을 사용하기 때문에 주어진 컨볼루션에 대해 몇 개의 픽셀만 손실될 수 있지만 이는 많은 연속 컨볼루션 레이어를 적용함에 따라 합산될 수 있습니다. 이 문제에 대한 간단한 해결책 중 하나는 입력 이미지의 경계 주위에 필러 픽셀을 추가하여 이미지의 유효 크기를 늘리는 것입니다. 일반적으로 추가 픽셀 값을 0으로 설정합니다. 그림 7.3.2에서 3×3 입력을 패딩하여 크기를 5×5로 늘립니다. 그러면 해당 출력이 4×4 행렬로 증가합니다. 음영 부분은 첫 번째 출력 요소이자 출력 계산에 사용되는 입력 및 커널 텐서 요소입니다: 0×0+0×1+0×2+0×3=0.

In general, if we add a total of pℎ rows of padding (roughly half on top and half on bottom) and a total of pw columns of padding (roughly half on the left and half on the right), the output shape will be

일반적으로 총 pℎ 행의 패딩(대략 절반은 위쪽, 절반은 아래쪽)과 총 pw 열의 패딩(대략 왼쪽 절반, 오른쪽 절반)을 추가하면 출력 모양은 다음과 같습니다.

This means that the height and width of the output will increase by pℎ and pw, respectively.

이것은 출력의 높이와 너비가 각각 pℎ와 pw만큼 증가한다는 것을 의미합니다.

In many cases, we will want to set pℎ=kℎ−1 and pw=kw−1 to give the input and output the same height and width. This will make it easier to predict the output shape of each layer when constructing the network. Assuming that kℎ is odd here, we will pad pℎ/2 rows on both sides of the height. If kℎ is even, one possibility is to pad ⌈pℎ/2⌉ rows on the top of the input and ⌊pℎ/2⌋ rows on the bottom. We will pad both sides of the width in the same way.

대부분의 경우 입력과 출력에 동일한 높이와 너비를 제공하기 위해 pℎ=kℎ−1 및 pw=kw−1을 설정하려고 합니다. 이렇게 하면 네트워크를 구성할 때 각 레이어의 출력 모양을 더 쉽게 예측할 수 있습니다. 여기서 kℎ가 홀수라고 가정하면 높이 양쪽에 pℎ/2 행을 채울 것입니다. kℎ가 짝수인 경우 한 가지 가능성은 입력 상단의 ⌈pℎ/2⌉ 행과 하단의 ⌊pℎ/2⌋ 행을 채우는 것입니다. 너비의 양쪽을 같은 방식으로 채웁니다.

CNNs commonly use convolution kernels with odd height and width values, such as 1, 3, 5, or 7. Choosing odd kernel sizes has the benefit that we can preserve the dimensionality while padding with the same number of rows on top and bottom, and the same number of columns on left and right.

CNN은 일반적으로 1, 3, 5 또는 7과 같은 홀수 높이 및 너비 값을 가진 컨볼루션 커널을 사용합니다. 홀수 커널 크기를 선택하면 위와 아래에 동일한 수의 행으로 패딩하면서 차원을 보존할 수 있다는 이점이 있습니다. 왼쪽과 오른쪽에 같은 수의 열이 있습니다.

Moreover, this practice of using odd kernels and padding to precisely preserve dimensionality offers a clerical benefit. For any two-dimensional tensor X, when the kernel’s size is odd and the number of padding rows and columns on all sides are the same, producing an output with the same height and width as the input, we know that the output Y[i, j] is calculated by cross-correlation of the input and convolution kernel with the window centered on X[i, j].

더욱이 차원을 정확하게 보존하기 위해 홀수 커널과 패딩을 사용하는 이러한 관행은 사무적인 이점을 제공합니다. 임의의 2차원 텐서 X에 대해 커널의 크기가 홀수이고 모든 면의 패딩 행과 열의 수가 동일하여 입력과 동일한 높이와 너비의 출력을 생성할 때 출력 Y[i , j]는 X[i, j]를 중심으로 하는 윈도우와 입력 및 컨벌루션 커널의 상호 상관에 의해 계산됩니다.

In the following example, we create a two-dimensional convolutional layer with a height and width of 3 and apply 1 pixel of padding on all sides. Given an input with a height and width of 8, we find that the height and width of the output is also 8.

다음 예제에서는 높이와 너비가 3인 2차원 컨볼루션 레이어를 만들고 모든 면에 1픽셀의 패딩을 적용합니다. 높이와 너비가 8인 입력이 주어지면 출력의 높이와 너비도 8임을 알 수 있습니다.

# We define a helper function to calculate convolutions. It initializes the
# convolutional layer weights and performs corresponding dimensionality
# elevations and reductions on the input and output
def comp_conv2d(conv2d, X):
    # (1, 1) indicates that batch size and the number of channels are both 1
    X = X.reshape((1, 1) + X.shape)
    Y = conv2d(X)
    # Strip the first two dimensions: examples and channels
    return Y.reshape(Y.shape[2:])

# 1 row and column is padded on either side, so a total of 2 rows or columns
# are added
conv2d = nn.LazyConv2d(1, kernel_size=3, padding=1)
X = torch.rand(size=(8, 8))
comp_conv2d(conv2d, X).shape

• 합성곱(convolution)을 계산하기 위한 도우미 함수를 정의합니다. 이 함수는 컨볼루션 레이어 가중치를 초기화하고 입력과 출력에 대한 차원 변환을 수행합니다.
• (1, 1)은 배치 크기와 채널 수가 모두 1임을 나타냅니다.
• 입력 X를 (1, 1) 크기로 재구성합니다. 이 때, X의 형상에 (1, 1) 차원을 추가합니다.
• 재구성된 입력을 사용하여 컨볼루션 레이어 conv2d를 통과시킵니다.
• 결과인 Y를 반환하기 전에 첫 번째와 두 번째 차원을 제거하여 형상을 조정합니다. 이는 예시와 채널 차원을 제거하는 것을 의미합니다.
• conv2d는 1개의 입력 채널과 3x3 크기의 커널(kernel)을 가지는 컨볼루션 레이어를 정의합니다.
• X는 8x8 크기의 랜덤한 텐서입니다.
• comp_conv2d 함수를 사용하여 conv2d를 X에 적용한 결과의 형상을 확인합니다.

When the height and width of the convolution kernel are different, we can make the output and input have the same height and width by setting different padding numbers for height and width.

컨볼루션 커널의 높이와 너비가 다른 경우 높이와 너비에 다른 패딩 수를 설정하여 출력과 입력의 높이와 너비를 같게 만들 수 있습니다.

# We use a convolution kernel with height 5 and width 3. The padding on either
# side of the height and width are 2 and 1, respectively
conv2d = nn.LazyConv2d(1, kernel_size=(5, 3), padding=(2, 1))
comp_conv2d(conv2d, X).shape

• 높이(height)가 5이고 너비(width)가 3인 컨볼루션 커널을 사용합니다. 높이와 너비 양쪽에 대한 패딩(padding)은 각각 2와 1입니다.
• conv2d는 1개의 입력 채널과 5x3 크기의 커널을 가지는 컨볼루션 레이어를 정의합니다.
• 앞선 설명에서 정의한 comp_conv2d 함수를 사용하여 conv2d를 X에 적용한 결과의 형상을 확인합니다.

7.3.2. Stride

When computing the cross-correlation, we start with the convolution window at the upper-left corner of the input tensor, and then slide it over all locations both down and to the right. In the previous examples, we defaulted to sliding one element at a time. However, sometimes, either for computational efficiency or because we wish to downsample, we move our window more than one element at a time, skipping the intermediate locations. This is particularly useful if the convolution kernel is large since it captures a large area of the underlying image.

상호 상관을 계산할 때 입력 텐서의 왼쪽 위 모서리에 있는 컨볼루션 창에서 시작한 다음 모든 위치를 아래로 오른쪽으로 밉니다. 이전 예제에서는 기본적으로 한 번에 하나의 요소를 슬라이딩했습니다. 그러나 때로는 계산 효율성을 위해 또는 다운샘플링을 원하기 때문에 중간 위치를 건너뛰고 한 번에 둘 이상의 요소를 이동합니다. 이는 기본 이미지의 넓은 영역을 캡처하기 때문에 컨볼루션 커널이 큰 경우에 특히 유용합니다.

We refer to the number of rows and columns traversed per slide as stride. So far, we have used strides of 1, both for height and width. Sometimes, we may want to use a larger stride. Fig. 7.3.3 shows a two-dimensional cross-correlation operation with a stride of 3 vertically and 2 horizontally. The shaded portions are the output elements as well as the input and kernel tensor elements used for the output computation: 0×0+0×1+1×2+2×3=8, 0×0+6×1+0×2+0×3=6. We can see that when the second element of the first column is generated, the convolution window slides down three rows. The convolution window slides two columns to the right when the second element of the first row is generated. When the convolution window continues to slide two columns to the right on the input, there is no output because the input element cannot fill the window (unless we add another column of padding).

슬라이드당 통과하는 행과 열의 수를 stride(보폭)이라고 합니다. 지금까지 높이와 너비 모두에 1의 보폭(stride)을 사용했습니다. 때로는 더 큰 보폭(stride)을 사용하고 싶을 수도 있습니다. 그림 7.3.3은 스트라이드가 수직으로 3, 수평으로 2인 2차원 교차 상관 연산을 보여줍니다. 음영 부분은 출력 요소와 출력 계산에 사용되는 입력 및 커널 텐서 요소입니다: 0×0+0×1+1×2+2×3=8, 0×0+6×1+0× 2+0×3=6. 첫 번째 열의 두 번째 요소가 생성되면 컨볼루션 창이 세 행 아래로 미끄러지는 것을 볼 수 있습니다. 컨볼루션 창은 첫 번째 행의 두 번째 요소가 생성될 때 오른쪽으로 두 열을 슬라이드합니다. 컨볼루션 창이 입력에서 오른쪽으로 두 열을 계속 슬라이드하면 입력 요소가 창을 채울 수 없기 때문에 출력이 없습니다(다른 패딩 열을 추가하지 않는 한).

In general, when the stride for the height is sℎ and the stride for the width is sw, the output shape is

일반적으로 높이에 대한 stride를 sℎ, 너비에 대한 stride를 sw라고 하면 출력 형태는

Below, we set the strides on both the height and width to 2, thus halving the input height and width.

pℎ=kℎ−1 및 pw=kw−1로 설정하면 출력 형태를 ⌊(nℎ+sℎ−1)/sℎ⌋×⌊(nw+sw−1)/sw⌋로 단순화할 수 있습니다. 한 단계 더 나아가 입력 높이와 너비를 높이와 너비의 보폭으로 나눌 수 있는 경우 출력 모양은 (nℎ/sℎ)×(nw/sw)가 됩니다.

아래에서는 높이와 너비 모두에 대한 보폭을 2로 설정하여 입력 높이와 너비를 반으로 줄입니다.

conv2d = nn.LazyConv2d(1, kernel_size=3, padding=1, stride=2)
comp_conv2d(conv2d, X).shape

• 패딩(padding) 값은 1이고 스트라이드(stride) 값은 2인 3x3 커널을 사용하는 컨볼루션 레이어 conv2d를 정의합니다.
• conv2d를 입력 데이터 X에 적용한 결과의 형상을 확인합니다.
• comp_conv2d 함수를 사용하여 컨볼루션 레이어를 적용할 때의 형상 변화를 확인합니다.

Let’s look at a slightly more complicated example.

조금 더 복잡한 예를 살펴보겠습니다.

conv2d = nn.LazyConv2d(1, kernel_size=(3, 5), padding=(0, 1), stride=(3, 4))
comp_conv2d(conv2d, X).shape

• 패딩(padding) 값은 (0, 1)이고 스트라이드(stride) 값은 (3, 4)인 3x5 커널을 사용하는 컨볼루션 레이어 conv2d를 정의합니다.
• conv2d를 입력 데이터 X에 적용한 결과의 형상을 확인합니다.
• comp_conv2d 함수를 사용하여 컨볼루션 레이어를 적용할 때의 형상 변화를 확인합니다.

7.3.3. Summary and Discussion

Padding can increase the height and width of the output. This is often used to give the output the same height and width as the input to avoid undesirable shrinkage of the output. Moreover, it ensures that all pixels are used equally frequently. Typically we pick symmetric padding on both sides of the input height and width. In this case we refer to (pℎ,pw) padding. Most commonly we set pℎ=pw, in which case we simply state that we choose padding p.

패딩은 출력의 높이와 너비를 증가시킬 수 있습니다. 이는 종종 출력이 바람직하지 않게 축소되는 것을 방지하기 위해 입력과 동일한 높이와 너비를 출력에 제공하는 데 사용됩니다. 또한 모든 픽셀이 균등하게 자주 사용되도록 합니다. 일반적으로 입력 높이와 너비의 양쪽에서 대칭 패딩을 선택합니다. 이 경우 (pℎ,pw) 패딩을 참조합니다. 가장 일반적으로 우리는 pℎ=pw를 설정합니다. 이 경우 단순히 패딩 p를 선택한다고 명시합니다.

A similar convention applies to strides. When horizontal stride sℎ and vertical stride sw match, we simply talk about stride s. The stride can reduce the resolution of the output, for example reducing the height and width of the output to only 1/n of the height and width of the input for n>1. By default, the padding is 0 and the stride is 1.

strides에도 유사한 규칙이 적용됩니다. 수평 stride sℎ와 수직 stride sw가 일치하면 간단하게 stride s 라고 합니다. strides은 출력의 해상도를 줄일 수 있습니다. 예를 들어 출력의 높이와 너비를 n>1의 경우 입력의 높이와 너비의 1/n으로만 줄입니다. 기본적으로 패딩은 0이고 스트라이드는 1입니다.

So far all padding that we discussed simply extended images with zeros. This has significant computational benefit since it is trivial to accomplish. Moreover, operators can be engineered to take advantage of this padding implicitly without the need to allocate additional memory. At the same time, it allows CNNs to encode implicit position information within an image, simply by learning where the “whitespace” is. There are many alternatives to zero-padding. Alsallakh et al. (2020) provided an extensive overview of alternatives (albeit without a clear case to use nonzero paddings unless artifacts occur).

지금까지 우리가 논의한 모든 패딩은 단순히 0으로 확장된 이미지입니다. 이것은 달성하기가 쉽지 않기 때문에 계산상 상당한 이점이 있습니다. 또한 연산자는 추가 메모리를 할당할 필요 없이 암시적으로 이 패딩을 활용하도록 설계할 수 있습니다. 동시에 CNN은 단순히 "whitespace"이 어디에 있는지 학습함으로써 이미지 내의 암시적 위치 정보를 인코딩할 수 있습니다. 제로 패딩에 대한 많은 대안이 있습니다. Alsallakhet al. (2020)은 대안에 대한 광범위한 개요를 제공했습니다(아티팩트가 발생하지 않는 한 0이 아닌 패딩을 사용하는 명확한 사례는 없지만).

7.3.4. Exercises

7.2. Convolutions for Images — Dive into Deep Learning 1.0.0-beta0 documentation (d2l.ai)

7.2. Convolutions for Images

Now that we understand how convolutional layers work in theory, we are ready to see how they work in practice. Building on our motivation of convolutional neural networks as efficient architectures for exploring structure in image data, we stick with images as our running example.

이제 컨볼루션 레이어가 이론적으로 어떻게 작동하는지 이해했으므로 실제로 어떻게 작동하는지 확인할 준비가 되었습니다. 이미지 데이터의 구조를 탐색하기 위한 효율적인 아키텍처로서의 convolutional neural networks에 대한 motivation을 Building on 하겠습니다. 우리는 이미지들을 실행 예제로 사용할 것입니다.

import torch
from torch import nn
from d2l import torch as d2l

7.2.1. The Cross-Correlation Operation

Recall that strictly speaking, convolutional layers are a misnomer, since the operations they express are more accurately described as cross-correlations. Based on our descriptions of convolutional layers in Section 7.1, in such a layer, an input tensor and a kernel tensor are combined to produce an output tensor through a cross-correlation operation.

엄밀히 말하면 컨볼루션 레이어(convolutional layers)는 잘못된 이름이라는 것을 상기하세요. 왜냐하면 그들이 표현하는 연산은 cross-correlations라고 말하는 것이 더 정확한 표현이기 때문입니다.  7.1절의 컨벌루션 레이어에 대한 설명을 기반으로 이러한 레이어에서 입력 텐서와 커널 텐서를 결합하여 cross-correlation 연산을 통해 출력 텐서를 생성합니다.

cross-correlation operation이란?

Cross-correlation is a mathematical operation that measures the similarity between two signals or sequences as they are shifted relative to each other. In the context of image processing and convolutional neural networks (CNNs), cross-correlation is commonly used for feature detection and matching.

교차 상관(Cross-correlation)은 두 신호 또는 시퀀스가 서로 이동하면서 유사성을 측정하는 수학적 연산입니다. 이미지 처리와 합성곱 신경망(CNN)의 맥락에서는 교차 상관이 특징 감지와 매칭에 일반적으로 사용됩니다.

In cross-correlation, the two signals are multiplied together at each position of the shift and then summed up. This process provides a measure of similarity or correlation between the two signals. When applied to image processing, it involves sliding a filter or kernel over an input image and computing the similarity between the filter and the corresponding image region.

교차 상관에서 두 신호는 서로의 이동 위치에서 곱해진 후 합산됩니다. 이 과정은 두 신호 간의 유사성이나 상관성을 측정하는 척도를 제공합니다. 이미지 처리에 적용할 때는 필터나 커널을 입력 이미지 위에 슬라이딩시켜 필터와 해당 이미지 영역 사이의 유사성을 계산합니다.

Cross-correlation is useful in tasks such as image recognition, object detection, and pattern matching. By comparing the similarity between a given feature or pattern and different regions of an image, cross-correlation allows for the identification of relevant features or objects.

교차 상관은 이미지 인식, 물체 감지, 패턴 매칭 등과 같은 작업에서 유용합니다. 주어진 특징이나 패턴과 이미지의 다양한 영역 간의 유사성을 비교함으로써 교차 상관은 관련 특징이나 객체를 식별하는 데 사용됩니다.

Let’s ignore channels for now and see how this works with two-dimensional data and hidden representations. In Fig. 7.2.1, the input is a two-dimensional tensor with a height of 3 and width of 3. We mark the shape of the tensor as 3×3 or (3, 3). The height and width of the kernel are both 2. The shape of the kernel window (or convolution window) is given by the height and width of the kernel (here it is 2×2).

지금은 채널을 무시하고 이것이 2차원 데이터 및 숨겨진 표현(hidden representations)에서 어떻게 작동하는지 살펴보겠습니다. 그림 7.2.1에서 입력은 높이가 3이고 너비가 3인 2차원 텐서입니다. 텐서의 모양을 3×3 또는 (3, 3)으로 표시합니다. 커널의 높이와 너비는 모두 2입니다. 커널 창(또는 컨볼루션 창)의 모양은 커널의 높이와 너비로 지정됩니다(여기서는 2×2).

In the two-dimensional cross-correlation operation, we begin with the convolution window positioned at the upper-left corner of the input tensor and slide it across the input tensor, both from left to right and top to bottom. When the convolution window slides to a certain position, the input subtensor contained in that window and the kernel tensor are multiplied elementwise and the resulting tensor is summed up yielding a single scalar value. This result gives the value of the output tensor at the corresponding location. Here, the output tensor has a height of 2 and width of 2 and the four elements are derived from the two-dimensional cross-correlation operation:

2차원 교차 상관 연산에서는 입력 텐서의 왼쪽 위 모서리에 있는 컨볼루션 창에서 시작하여 왼쪽에서 오른쪽으로 그리고 위에서 아래로 입력 텐서를 가로질러 슬라이드합니다. 컨볼루션 윈도우가 특정 위치로 슬라이드되면 해당 윈도우에 포함된 입력 하위 텐서와 커널 텐서가 요소별로 곱해지고 결과 텐서가 합산되어 단일 스칼라 값이 생성됩니다. 이 결과는 해당 위치에서 출력 텐서의 값을 제공합니다. 여기서 출력 텐서는 높이가 2이고 너비가 2이며 4개의 요소는 2차원 교차 상관 연산에서 파생됩니다.

Note that along each axis, the output size is slightly smaller than the input size. Because the kernel has width and height greater than one, we can only properly compute the cross-correlation for locations where the kernel fits wholly within the image, the output size is given by the input size nℎ×bw minus the size of the convolution kernel kℎ×kw via

각 축을 따라 출력 크기는 입력 크기보다 약간 작습니다.  커널의은 1보다 큰  너비와 높이가 있기 때문에 우리는 location에 대한 cross-correlation 계산만 할 수 있습니다. 출력 크기는 다음을 거쳐서 입력 크기 n_ℎ×n_w에서 컨볼루션 커널 크기 k_ℎ×k_w를 뺀 값입니다.

This is the case since we need enough space to “shift” the convolution kernel across the image. Later we will see how to keep the size unchanged by padding the image with zeros around its boundary so that there is enough space to shift the kernel. Next, we implement this process in the corr2d function, which accepts an input tensor X and a kernel tensor K and returns an output tensor Y.

이것은 이미지에서 컨볼루션 커널을 "shift"할 충분한 공간이 필요하기 때문입니다. 나중에 커널을 이동할 충분한 공간이 있도록 이미지 경계 주위에 0을 채워 크기를 변경하지 않고 유지하는 방법을 살펴보겠습니다. 다음으로 입력 텐서 X와 커널 텐서 K를 받아들이고 출력 텐서 Y를 반환하는 corr2d 함수에서 이 프로세스를 구현합니다.

def corr2d(X, K):  #@save
    """Compute 2D cross-correlation."""
    h, w = K.shape
    Y = torch.zeros((X.shape[0] - h + 1, X.shape[1] - w + 1))
    for i in range(Y.shape[0]):
        for j in range(Y.shape[1]):
            Y[i, j] = (X[i:i + h, j:j + w] * K).sum()
    return Y

위 코드는 2D 크로스-상관(correlation) 연산을 수행하는 함수인 corr2d를 구현한 코드입니다.

해당 코드를 한 줄씩 설명하면 다음과 같습니다:

• def corr2d(X, K): : corr2d라는 함수를 정의하고, X와 K라는 두 개의 인자를 받습니다. X는 입력 데이터이고, K는 커널(필터)입니다.
• h, w = K.shape : 커널의 높이 h와 너비 w를 추출합니다.
• Y = torch.zeros((X.shape[0] - h + 1, X.shape[1] - w + 1)) : 출력을 저장할 Y 텐서를 생성합니다. Y의 크기는 입력 데이터와 커널의 크기에 따라 결정됩니다.
• for i in range(Y.shape[0]): : Y의 행을 반복합니다.
• for j in range(Y.shape[1]): : Y의 열을 반복합니다.
• Y[i, j] = (X[i:i + h, j:j + w] * K).sum() : 입력 데이터 X와 커널 K 사이의 2D 크로스-상관 값을 계산하여 Y에 저장합니다. 이를 위해 입력 데이터와 커널을 요소별로 곱한 후 합을 구합니다.
• return Y : 계산된 출력 텐서 Y를 반환합니다.

이 함수는 입력 데이터 X와 커널 K 사이의 2D 크로스-상관 값을 계산하여 출력하는 함수입니다. 크로스-상관은 입력 데이터와 커널 간의 유사성을 측정하는데 사용되며, 주로 이미지 처리에서 필터와 이미지의 관련성을 파악하는 데 활용됩니다.

We can construct the input tensor X and the kernel tensor K from Fig. 7.2.1 to validate the output of the above implementation of the two-dimensional cross-correlation operation.

그림 7.2.1에서 입력 텐서 X와 커널 텐서 K를 구성하여 위의 2차원 교차 상관 연산의 출력을 검증할 수 있습니다.

X = torch.tensor([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]])
K = torch.tensor([[0.0, 1.0], [2.0, 3.0]])
corr2d(X, K)

위 코드는 주어진 입력 데이터 X와 커널 K를 이용하여 corr2d 함수를 호출하는 코드입니다.

해당 코드를 한 줄씩 설명하면 다음과 같습니다:

• X = torch.tensor([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]) : 입력 데이터인 X를 정의합니다. 이는 크기가 3x3인 텐서로, 2D 매트릭스 형태의 데이터입니다.
• K = torch.tensor([[0.0, 1.0], [2.0, 3.0]]) : 커널인 K를 정의합니다. 이는 크기가 2x2인 텐서로, 2D 매트릭스 형태의 필터입니다.
• corr2d(X, K) : corr2d 함수를 호출하여 입력 데이터 X와 커널 K 사이의 2D 크로스-상관 값을 계산합니다.

즉, 주어진 입력 데이터 X와 커널 K를 사용하여 corr2d 함수를 호출하고, 2D 크로스-상관 값을 계산하는 결과를 반환합니다. 이를 통해 입력 데이터와 커널 사이의 유사성을 측정하고, 컨볼루션 연산을 수행할 수 있습니다.

7.2.2. Convolutional Layers

A convolutional layer cross-correlates the input and kernel and adds a scalar bias to produce an output. The two parameters of a convolutional layer are the kernel and the scalar bias. When training models based on convolutional layers, we typically initialize the kernels randomly, just as we would with a fully connected layer.

컨볼루션 계층은 입력과 커널(혹은 필터)을 상호 연관(cross-correlates)시키고 스칼라 편향(scalar bias)을 추가하여 출력을 생성합니다. 컨볼루션 레이어의 두 매개변수는 커널과 스칼라 편향((scalar bias))입니다. 컨벌루션 레이어를 기반으로 모델을 교육할 때 일반적으로 완전히 연결된 레이어에서와 마찬가지로 커널을 무작위로 초기화합니다.

scalar bias란?

In the context of a convolutional layer, the scalar bias refers to a single constant value that is added to each output channel of the convolutional operation. It is an additional learnable parameter in the convolutional layer, apart from the kernel/filter weights.

합성곱 층에서의 스칼라 편향은 커널(필터)과 별개로 각 출력 채널에 더해지는 단일 상수값을 의미합니다. 합성곱 층에서 스칼라 편향은 커널 가중치 외에 추가적인 학습 가능한 매개변수입니다.

During the convolution operation, the input data is convolved with the kernel weights, and the resulting values are summed along with the scalar bias for each output channel. The scalar bias helps introduce an additional degree of freedom in the model by allowing the network to shift the output values based on the bias term.

합성곱 연산 과정에서 입력 데이터는 커널 가중치와 합성곱되고, 각 출력 채널에 대해 스칼라 편향이 더해집니다. 스칼라 편향은 신경망에게 추가적인 자유도를 부여하여 편향 항에 따라 출력 값을 조정할 수 있게 합니다.

The scalar bias allows the network to adjust the baseline or offset of the output feature maps, enabling the model to capture and represent more complex patterns and relationships in the data. It provides flexibility in modeling data with varying levels of intensity or activation.

스칼라 편향은 출력 특징 맵의 기준선 또는 오프셋을 조정할 수 있도록 합니다. 이를 통해 모델은 데이터의 다양한 강도나 활성화 수준에 따라 출력 값을 조절할 수 있게 됩니다.

In summary, the scalar bias is a single constant value added to the output channels of a convolutional layer to introduce an offset or baseline to the feature maps. It helps the model capture and represent complex patterns and relationships in the data.

요약하면, 스칼라 편향은 합성곱 층의 출력 채널에 더해지는 단일 상수값으로, 특징 맵에 기준선 또는 오프셋을 도입합니다. 이를 통해 모델은 데이터의 복잡한 패턴과 관계를 포착하고 표현할 수 있습니다.

We are now ready to implement a two-dimensional convolutional layer based on the corr2d function defined above. In the __init__ constructor method, we declare weight and bias as the two model parameters. The forward propagation method calls the corr2d function and adds the bias.

이제 위에서 정의한 corr2d 함수를 기반으로 2차원 컨볼루션 계층을 구현할 준비가 되었습니다. __init__ 생성자 메서드에서 가중치와 편향을 두 모델 매개변수로 선언합니다. 정방향 전파 방법은 corr2d 함수를 호출하고 바이어스를 추가합니다.

class Conv2D(nn.Module):
    def __init__(self, kernel_size):
        super().__init__()
        self.weight = nn.Parameter(torch.rand(kernel_size))
        self.bias = nn.Parameter(torch.zeros(1))

    def forward(self, x):
        return corr2d(x, self.weight) + self.bias

• Conv2D 클래스는 nn.Module을 상속하는 합성곱 층을 정의합니다.
• __init__ 메서드는 합성곱 커널 크기(kernel_size)를 입력으로 받고, 초기화 작업을 수행합니다.
• self.weight는 커널 가중치를 나타내는 파라미터로 정의됩니다. torch.rand(kernel_size)를 사용하여 랜덤한 초기값으로 초기화됩니다.
• self.bias는 스칼라 편향을 나타내는 파라미터로 정의됩니다. 초기값으로 0을 가집니다.
• forward 메서드는 입력(x)을 받고, corr2d 함수를 사용하여 입력과 커널 가중치의 합성곱을 계산합니다. 그리고 스칼라 편향(self.bias)을 더한 결과를 반환합니다.

이 코드는 합성곱 층을 정의하고, 커널 가중치와 스칼라 편향을 포함한 학습 가능한 매개변수를 가지고 있습니다. 입력과 커널의 합성곱 결과에 편향을 더한 값이 출력으로 반환됩니다.

In ℎ×w convolution or a ℎ×w convolution kernel, the height and width of the convolution kernel are ℎ and w, respectively. We also refer to a convolutional layer with a ℎ×w convolution kernel simply as a ℎ×w convolutional layer.

ℎ×w 컨볼루션 또는 ℎ×w 컨볼루션 커널에서 컨볼루션 커널의 높이와 너비는 각각 ℎ와 w입니다. 또한 ℎ×w 컨볼루션 커널이 있는 컨볼루션 레이어를 단순히 ℎ×w 컨볼루션 레이어라고 합니다.

7.2.3. Object Edge Detection in Images

Let’s take a moment to parse a simple application of a convolutional layer: detecting the edge of an object in an image by finding the location of the pixel change. First, we construct an “image” of 6×8 pixels. The middle four columns are black (0) and the rest are white (1).

컨볼루션 레이어의 간단한 애플리케이션을 파싱하는 시간을 가져보겠습니다. 픽셀 변화의 위치를 찾아 이미지에서 객체의 가장자리를 감지합니다. 먼저 6×8 픽셀의 "이미지"를 구성합니다. 가운데 4개 열은 검은색(0)이고 나머지는 흰색(1)입니다.

X = torch.ones((6, 8))
X[:, 2:6] = 0
X

• X는 크기가 (6, 8)인 텐서로 초기값은 모두 1로 설정됩니다.
• X[:, 2:6] = 0은 X 텐서의 모든 행(:)에서 열 인덱스 2부터 6 전까지의 범위에 해당하는 요소들을 0으로 변경합니다. 즉, 2부터 5까지의 열에 해당하는 값들을 0으로 설정합니다.
• X를 출력하면 변경된 텐서가 나타납니다.

이 코드는 크기가 (6, 8)인 텐서 X를 생성한 후, 열 인덱스 2부터 5까지의 범위에 해당하는 요소들을 0으로 변경합니다. 변경된 X 텐서가 출력됩니다.

Next, we construct a kernel K with a height of 1 and a width of 2. When we perform the cross-correlation operation with the input, if the horizontally adjacent elements are the same, the output is 0. Otherwise, the output is non-zero. Note that this kernel is special case of a finite difference operator. At location (i,j) it computes x_i,j−x_(i+1),j',  i.e., it computes the difference between the values of horizontally adjacent pixels. This is a discrete approximation of the first derivative in the horizontal direction. After all, for a function f(i,j) its derivative −∂_if(i,j)=lim_ϵ→0 f(i,j)−f(i+ϵ,j)/ϵ. Let’s see how this works in practice.

다음으로 높이가 1이고 너비가 2인 커널 K를 구성합니다. 입력으로 교차 상관 연산을 수행할 때 가로로 인접한 요소가 같으면 출력은 0입니다. 그렇지 않으면 출력은 0이 아닙니다. 이 커널은 유한 차분 연산자(finite difference operator)의 특수한 경우입니다. 위치 (i,j)에서 x_i,j−x_(i+1),j'를 계산합니다. 즉, 수평으로 인접한 픽셀 값 간의 차이를 계산합니다. 이것은 수평 방향에서 1차 도함수의 이산 근사치(discrete approximation)입니다. 결국, 함수 f(i,j)의 경우 파생물 −∂_if(i,j)=lim_ϵ→0 f(i,j)−f(i+ϵ,j)/ϵ입니다. 이것이 실제로 어떻게 작동하는지 봅시다.

K = torch.tensor([[1.0, -1.0]])

• K는 크기가 (1, 2)인 텐서로 초기값은 [1.0, -1.0]으로 설정됩니다.

이 코드는 크기가 (1, 2)인 텐서 K를 생성하고, 초기값으로 [1.0, -1.0]을 사용합니다.

We are ready to perform the cross-correlation operation with arguments X (our input) and K (our kernel). As you can see, we detect 1 for the edge from white to black and -1 for the edge from black to white. All other outputs take value 0.

인수 X(입력) 및 K(커널)를 사용하여 cross-correlation 연산을 수행할 준비가 되었습니다. 보시다시피 흰색에서 검은색으로의 가장자리에 대해 1을 감지하고 검은색에서 흰색으로의 가장자리에 대해 -1을 감지합니다. 다른 모든 출력은 값이 0입니다.

Y = corr2d(X, K)
Y

• Y는 corr2d 함수에 X와 K를 입력으로 전달하여 얻은 결과입니다.

이 코드는 X와 K를 corr2d 함수에 입력으로 전달하여 얻은 결과를 Y에 할당합니다. Y는 corr2d 함수의 결과값입니다.

We can now apply the kernel to the transposed image. As expected, it vanishes. The kernel K only detects vertical edges.

이제 커널을 전치된 이미지(transposed image)에 적용할 수 있습니다. 예상대로 사라집니다. 커널 K는 수직 에지만 감지합니다.

corr2d(X.t(), K)

• corr2d 함수에 X.t()와 K를 입력으로 전달하여 호출합니다.
• X.t()는 X의 전치(transpose)를 반환하는 연산입니다. 이는 X의 행과 열을 바꾼 행렬을 의미합니다.
• 따라서 corr2d 함수는 X의 전치된 행렬과 K를 입력으로 받아 결과를 계산합니다.

7.2.4. Learning a Kernel

Designing an edge detector by finite differences [1, -1] is neat if we know this is precisely what we are looking for. However, as we look at larger kernels, and consider successive layers of convolutions, it might be impossible to specify precisely what each filter should be doing manually.

유한 차이(finite differences) [1, -1]로 edge detector를 설계하는 것은 이것이 우리가 찾고 있는 것이 정확히 무엇인지 안다면 깔끔합니다. 그러나 더 큰 커널을 살펴보고 연속적인 컨볼루션 레이어를 고려할 때 각 필터가 수동으로 수행해야 하는 작업을 정확하게 지정하는 것이 불가능할 수 있습니다.

Now let’s see whether we can learn the kernel that generated Y from X by looking at the input–output pairs only. We first construct a convolutional layer and initialize its kernel as a random tensor. Next, in each iteration, we will use the squared error to compare Y with the output of the convolutional layer. We can then calculate the gradient to update the kernel. For the sake of simplicity, in the following we use the built-in class for two-dimensional convolutional layers and ignore the bias.

이제 입력-출력 쌍만 보고 X에서 Y를 생성한 커널을 학습할 수 있는지 살펴보겠습니다. 먼저 컨볼루션 레이어를 구성하고 커널을 랜덤 텐서로 초기화합니다. 다음으로 각 반복에서 제곱 오차를 사용하여 Y를 컨볼루션 레이어의 출력과 비교합니다. 그런 다음 기울기를 계산하여 커널을 업데이트할 수 있습니다. 단순화를 위해 다음에서는 2차원 컨볼루션 레이어에 내장 클래스를 사용하고 바이어스를 무시합니다.

# Construct a two-dimensional convolutional layer with 1 output channel and a
# kernel of shape (1, 2). For the sake of simplicity, we ignore the bias here
conv2d = nn.LazyConv2d(1, kernel_size=(1, 2), bias=False)

# The two-dimensional convolutional layer uses four-dimensional input and
# output in the format of (example, channel, height, width), where the batch
# size (number of examples in the batch) and the number of channels are both 1
X = X.reshape((1, 1, 6, 8))
Y = Y.reshape((1, 1, 6, 7))
lr = 3e-2  # Learning rate

for i in range(10):
    Y_hat = conv2d(X)
    l = (Y_hat - Y) ** 2
    conv2d.zero_grad()
    l.sum().backward()
    # Update the kernel
    conv2d.weight.data[:] -= lr * conv2d.weight.grad
    if (i + 1) % 2 == 0:
        print(f'epoch {i + 1}, loss {l.sum():.3f}')

첫째줄은 (conv2d = nn.LazyConv2d(1, kernel_size=(1, 2), bias=False))

• 1개의 출력 채널과 (1, 2) 크기의 커널을 가지는 2D 컨볼루션 레이어(conv2d)를 생성합니다.
• 여기서는 편향(bias)을 고려하지 않고 설정합니다.

• X와 Y를 4차원 형태로 변형하여 입력합니다. 입력과 출력은 (예제 개수, 채널 수, 높이, 너비) 형식을 따릅니다.
• 여기서는 배치 크기(배치에 있는 예제 수)와 채널 수가 모두 1인 형태로 설정합니다.
• lr은 학습률(learning rate)로, 0.03으로 설정합니다.

for loop 문은

• 10번의 에폭(epoch) 동안 학습을 수행합니다.
• conv2d(X)를 통해 예측값 Y_hat을 계산합니다.
• 손실 함수 l은 예측값과 실제값의 차이의 제곱으로 정의됩니다.
• conv2d.zero_grad()를 통해 기울기를 초기화합니다.
• l.sum().backward()를 통해 손실을 역전파합니다.
• 커널을 업데이트합니다. 업데이트는 학습률과 기울기를 이용하여 수행됩니다.
• 매 2번째 에폭마다 손실을 출력합니다.

Note that the error has dropped to a small value after 10 iterations. Now we will take a look at the kernel tensor we learned.

오류는 10회 반복 후 작은 값으로 떨어졌습니다. 이제 우리가 배운 커널 텐서를 살펴보겠습니다.

conv2d.weight.data.reshape((1, 2))

• conv2d의 가중치(weight)를 (1, 2) 크기로 변형합니다.
• 가중치는 2D 컨볼루션 레이어에 사용되는 커널(kernel)을 나타냅니다.
• (1, 2) 크기로 변형된 가중치는 1개의 출력 채널과 2개의 요소를 가지는 형태로 재구성됩니다.

Indeed, the learned kernel tensor is remarkably close to the kernel tensor K we defined earlier.

실제로 학습된 커널 텐서는 이전에 정의한 커널 텐서 K에 매우 가깝습니다.

7.2.5. Cross-Correlation and Convolution

Recall our observation from Section 7.1 of the correspondence between the cross-correlation and convolution operations. Here let’s continue to consider two-dimensional convolutional layers. What if such layers perform strict convolution operations as defined in (7.1.6) instead of cross-correlations? In order to obtain the output of the strict convolution operation, we only need to flip the two-dimensional kernel tensor both horizontally and vertically, and then perform the cross-correlation operation with the input tensor.

교차 상관과 컨볼루션 연산 사이의 대응에 대한 섹션 7.1의 관찰을 상기하십시오. 여기서 계속해서 2차원 컨볼루션 레이어를 살펴보겠습니다. 이러한 레이어가 교차 상관 대신 (7.1.6)에 정의된 엄격한 컨벌루션 연산을 수행한다면 어떻게 될까요? 엄격한 컨벌루션 연산의 출력을 얻기 위해서는 2차원 커널 텐서를 수평 및 수직으로 뒤집은 다음 입력 텐서와 교차 상관 연산을 수행하면 됩니다.

It is noteworthy that since kernels are learned from data in deep learning, the outputs of convolutional layers remain unaffected no matter such layers perform either the strict convolution operations or the cross-correlation operations.

커널은 딥 러닝의 데이터에서 학습되기 때문에 컨볼루션 레이어의 출력은 이러한 레이어가 strict convolution operations또는 cross-correlation operations을 수행하는 것과 상관없이 영향을 받지 않습니다.

To illustrate this, suppose that a convolutional layer performs cross-correlation and learns the kernel in Fig. 7.2.1, which is denoted as the matrix K here. Assuming that other conditions remain unchanged, when this layer performs strict convolution instead, the learned kernel K′ will be the same as K after K′ is flipped both horizontally and vertically. That is to say, when the convolutional layer performs strict convolution for the input in Fig. 7.2.1 and K′, the same output in Fig. 7.2.1 (cross-correlation of the input and K) will be obtained.

이를 설명하기 위해 합성곱 계층이 교차 상관을 수행하고 여기에서 행렬 K로 표시되는 그림 7.2.1의 커널을 학습한다고 가정합니다. 다른 조건이 변하지 않는다고 가정하면, 이 레이어가 대신 엄격한 컨볼루션을 수행하면 학습된 커널 K'는 K'가 수평 및 수직으로 뒤집힌 후 K와 동일할 것입니다. 즉, convolutional layer가 그림 7.2.1의 입력과 K'에 대해 엄격한 컨벌루션을 수행하면 그림 7.2.1과 동일한 출력(입력과 K의 상호 상관)이 얻어집니다.

In keeping with standard terminology with deep learning literature, we will continue to refer to the cross-correlation operation as a convolution even though, strictly-speaking, it is slightly different. Besides, we use the term element to refer to an entry (or component) of any tensor representing a layer representation or a convolution kernel.

딥 러닝 문헌의 표준 용어에 따라 엄밀히 말하면 약간 다르지만 cross-correlation operation 을 convolution 으로 계속 언급할 것입니다. 게다가 element 라는 용어는 layer representation 또는 convolution kernel을 나타내는 모든 텐서의 entry (또는 component)을 참조하는 데 사용됩니다.

7.2.6. Feature Map and Receptive Field

As described in Section 7.1.4, the convolutional layer output in Fig. 7.2.1 is sometimes called a feature map, as it can be regarded as the learned representations (features) in the spatial dimensions (e.g., width and height) to the subsequent layer. In CNNs, for any element x of some layer, its receptive field refers to all the elements (from all the previous layers) that may affect the calculation of x during the forward propagation. Note that the receptive field may be larger than the actual size of the input.

섹션 7.1.4에서 설명한 것처럼 그림 7.2.1의 컨볼루션 레이어 출력은 spatial dimensions(예: 너비 및 높이)에서 subsequent layer로 가면서 learned representations (features)으로 간주될 수 있으므로 feature map이라고도 합니다.  CNN에서 일부 계층의 모든 요소 x에 대해 수용 필드는 순방향 전파 중에 x 계산에 영향을 미칠 수 있는 모든 이전 계층의 요소를 참조합니다. 수용 필드는 입력의 실제 크기보다 클 수 있습니다.

Let’s continue to use Fig. 7.2.1 to explain the receptive field. Given the 2×2 convolution kernel, the receptive field of the shaded output element (of value 19) is the four elements in the shaded portion of the input. Now let’s denote the 2×2 output as Y and consider a deeper CNN with an additional 2×2 convolutional layer that takes Y as its input, outputting a single element z. In this case, the receptive field of z on Y includes all the four elements of Y, while the receptive field on the input includes all the nine input elements. Thus, when any element in a feature map needs a larger receptive field to detect input features over a broader area, we can build a deeper network.

계속해서 그림 7.2.1을 사용하여 수용 필드를 설명하겠습니다. 2×2 컨볼루션 커널이 주어지면 음영 처리된 출력 요소(값 19)의 수용 필드는 입력의 음영 처리된 부분에 있는 4개의 요소입니다. 이제 2×2 출력을 Y로 표시하고 Y를 입력으로 사용하여 단일 요소 z를 출력하는 추가 2×2 컨벌루션 레이어가 있는 더 깊은 CNN을 고려해 보겠습니다. 이 경우 Y에 대한 z의 수용 필드는 Y의 네 가지 요소를 모두 포함하고 입력의 수용 필드는 9개의 입력 요소를 모두 포함합니다. 따라서 기능 맵의 요소가 더 넓은 영역에서 입력 기능을 감지하기 위해 더 큰 수용 필드가 필요한 경우 더 깊은 네트워크를 구축할 수 있습니다.

Receptive fields derive their name from neurophysiology. In a series of experiments (Hubel and Wiesel, 1959, Hubel and Wiesel, 1962, Hubel and Wiesel, 1968) on a range of animals and different stimuli, Hubel and Wiesel explored the response of what is called the visual cortex on said stimuli. By and large they found that lower levels respond to edges and related shapes. Later on, Field (1987) illustrated this effect on natural images with, what can only be called, convolutional kernels. We reprint a key figure in Fig. 7.2.2 to illustrate the striking similarities.

수용 분야는 신경생리학에서 이름을 따왔습니다. 다양한 동물과 다양한 자극에 대한 일련의 실험(Hubel과 Wiesel, 1959, Hubel과 Wiesel, 1962, Hubel과 Wiesel, 1968)에서 Hubel과 Wiesel은 상기 자극에 대한 시각 피질이라고 불리는 것의 반응을 탐구했습니다. 전반적으로 그들은 낮은 수준이 가장자리 및 관련 모양에 반응한다는 것을 발견했습니다. 나중에 Field(1987)는 컨볼루션 커널이라고만 할 수 있는 자연 이미지에 대한 이 효과를 설명했습니다. 놀라운 유사성을 설명하기 위해 그림 7.2.2의 핵심 수치를 다시 인쇄합니다.

As it turns out, this relation even holds for the features computed by deeper layers of networks trained on image classification tasks, as demonstrated e.g., in Kuzovkin et al. (2018). Suffice it to say, convolutions have proven to be an incredibly powerful tool for computer vision, both in biology and in code. As such, it is not surprising (in hindsight) that they heralded the recent success in deep learning.

결과적으로 Kuzovkin et al. (2018)에서 보여 주었듯 이 관계는 이미지 분류 작업에 대해 훈련된 더 깊은 네트워크 계층에서 계산된 기능에도 적용됩니다.  컨볼루션은 생물학과 코드 모두에서 컴퓨터 비전을 위한 매우 강력한 도구임이 입증되었습니다. 따라서 그들이 최근 딥 러닝의 성공을 예고한 것은 (돌이켜보면) 놀라운 일이 아닙니다.

7.2.7. Summary

The core computation required for a convolutional layer is a cross-correlation operation. We saw that a simple nested for-loop is all that is required to compute its value. If we have multiple input and multiple output channels, we are performing a matrix-matrix operation between channels. As can be seen, the computation is straightforward and, most importantly, highly local. This affords significant hardware optimization and many recent results in computer vision are only possible due to that. After all, it means that chip designers can invest into fast computation rather than memory, when it comes to optimizing for convolutions. While this may not lead to optimal designs for other applications, it opens the door to ubiquitous and affordable computer vision.

컨볼루션 계층에 필요한 핵심 계산은 cross-correlation operation입니다. 값을 계산하는 데 필요한 것은 간단한 중첩 for-loop 뿐입니다. 입력 채널과 출력 채널이 여러 개인 경우 채널 간에 행렬-행렬 연산(matrix-matrix operation)을 수행합니다. 여러분이 보았듯이 계산은 직관적이고 가장 중요한 것은 highly local 이라는 점입니다. 이것은 상당한 하드웨어 최적화를 제공하며 컴퓨터 비전의 많은 최근 결과는 그로 인해 가능합니다. 결국 이는 칩 설계자가 컨볼루션을 최적화할 때 메모리가 아닌 빠른 계산에 투자할 수 있음을 의미합니다. 이것은 다른 응용 프로그램에 대한 최적의 설계로 이어지지 않을 수 있지만 유비쿼터스 및 저렴한 컴퓨터 비전의 문을 엽니다.

In terms of convolutions themselves, they can be used for many purposes such as to detect edges and lines, to blur images, or to sharpen them. Most importantly, it is not necessary that the statistician (or engineer) invents suitable filters. Instead, we can simply learn them from data. This replaces feature engineering heuristics by evidence-based statistics. Lastly, and quite delightfully, these filters are not just advantageous for building deep networks but they also correspond to receptive fields and feature maps in the brain. This gives us confidence that we are on the right track.

컨볼루션 자체의 측면에서 가장자리와 선을 감지하거나 이미지를 흐리게 하거나 선명하게 하는 것과 같은 다양한 목적으로 사용할 수 있습니다. 가장 중요한 것은 통계학자(또는 엔지니어)가 적절한 필터를 발명할 필요가 없다는 것입니다. 대신 데이터에서 간단하게 배울 수 있습니다. 이는 기능 엔지니어링 휴리스틱을 증거 기반 통계로 대체합니다. 마지막으로 매우 기쁘게도 이러한 필터는 심층 네트워크를 구축하는 데 유리할 뿐만 아니라 뇌의 수용 영역 및 기능 맵에 해당합니다. 이것은 우리가 올바른 길을 가고 있다는 확신을 줍니다.

7.2.8. Exercises

https://d2l.ai/chapter_convolutional-neural-networks/index.html

7.1. From Fully Connected Layers to Convolutions — Dive into Deep Learning 1.0.0-beta0 documentation (d2l.ai)

7. Convolutional Neural Networks

Image data is represented as a two-dimensional grid of pixels, be the image monochromatic or in color. Accordingly each pixel corresponds to one or multiple numerical values respectively. So far we have ignored this rich structure and treated images as vectors of numbers by flattening them, irrespective of the spatial relation between pixels. This deeply unsatisfying approach was necessary in order to feed the resulting one-dimensional vectors through a fully connected MLP.

이미지 데이터는 픽셀의 2차원 격자로 표현되며, 이미지는 단색이거나 컬러입니다. 따라서 각 픽셀은 각각 하나 또는 여러 개의 숫자 값에 해당합니다. 지금까지 우리는 이 풍부한 구조를 무시하고 픽셀 간의 공간적 관계에 관계없이 이미지를 평면화하여 숫자 벡터로 처리했습니다. 완전히 연결된 MLP를 통해 결과적인 1차원 벡터를 공급하려면 매우 만족스럽지 못한 이러한 접근 방식이 필요했습니다.

Because these networks are invariant to the order of the features, we could get similar results regardless of whether we preserve an order corresponding to the spatial structure of the pixels or if we permute the columns of our design matrix before fitting the MLP’s parameters. Ideally, we would leverage our prior knowledge that nearby pixels are typically related to each other, to build efficient models for learning from image data.

이러한 네트워크는 특징의 순서에 불변하기 때문에 픽셀의 공간 구조에 해당하는 순서를 유지하는지 또는 MLP의 매개변수를 맞추기 전에 디자인 행렬의 열을 순열하는지 여부에 관계없이 비슷한 결과를 얻을 수 있습니다. 이상적으로는 근처 픽셀이 일반적으로 서로 관련되어 있다는 사전 지식을 활용하여 이미지 데이터로부터 학습하기 위한 효율적인 모델을 구축합니다.

This chapter introduces convolutional neural networks (CNNs) (LeCun et al., 1995), a powerful family of neural networks that are designed for precisely this purpose. CNN-based architectures are now ubiquitous in the field of computer vision. For instance, on the Imagnet collection (Deng et al., 2009) it was only the use of convolutional neural networks, in short Convnets, that provided significant performance improvements (Krizhevsky et al., 2012).

이 장에서는 바로 이러한 목적을 위해 설계된 강력한 신경망 계열인 CNN(Convolutional Neural Network)(LeCun et al., 1995)을 소개합니다. CNN 기반 아키텍처는 이제 컴퓨터 비전 분야 어디에서나 볼 수 있습니다. 예를 들어, Imagnet 컬렉션(Deng et al., 2009)에서는 상당한 성능 향상을 제공한 것은 컨볼루션 신경망, 줄여서 Convnets의 사용뿐이었습니다(Krizhevsky et al., 2012).

Modern CNNs, as they are called colloquially, owe their design to inspirations from biology, group theory, and a healthy dose of experimental tinkering. In addition to their sample efficiency in achieving accurate models, CNNs tend to be computationally efficient, both because they require fewer parameters than fully connected architectures and because convolutions are easy to parallelize across GPU cores (Chetlur et al., 2014). Consequently, practitioners often apply CNNs whenever possible, and increasingly they have emerged as credible competitors even on tasks with a one-dimensional sequence structure, such as audio (Abdel-Hamid et al., 2014), text (Kalchbrenner et al., 2014), and time series analysis (LeCun et al., 1995), where recurrent neural networks are conventionally used. Some clever adaptations of CNNs have also brought them to bear on graph-structured data (Kipf and Welling, 2016) and in recommender systems.

구어체로 불리는 현대 CNN은 생물학, 그룹 이론 및 건전한 실험적 조작에서 영감을 받아 설계되었습니다. 정확한 모델을 달성하기 위한 샘플 효율성 외에도 CNN은 완전히 연결된 아키텍처보다 적은 매개변수가 필요하고 컨볼루션이 GPU 코어 전체에서 병렬화되기 쉽기 때문에 계산적으로 효율적인 경향이 있습니다(Chetlur et al., 2014). 결과적으로 실무자들은 가능할 때마다 CNN을 적용하는 경우가 많으며 오디오(Abdel-Hamid et al., 2014), 텍스트(Kalchbrenner et al., 2014)와 같은 1차원 시퀀스 구조를 가진 작업에서도 점점 더 신뢰할 수 있는 경쟁자로 부상하고 있습니다. ), 시계열 분석(LeCun et al., 1995), 여기서는 순환 신경망이 일반적으로 사용됩니다. CNN의 일부 영리한 적응으로 인해 그래프 구조 데이터(Kipf and Welling, 2016)와 추천 시스템에도 적용되었습니다.

First, we will dive more deeply into the motivation for convolutional neural networks. This is followed by a walk through the basic operations that comprise the backbone of all convolutional networks. These include the convolutional layers themselves, nitty-gritty details including padding and stride, the pooling layers used to aggregate information across adjacent spatial regions, the use of multiple channels at each layer, and a careful discussion of the structure of modern architectures. We will conclude the chapter with a full working example of LeNet, the first convolutional network successfully deployed, long before the rise of modern deep learning. In the next chapter, we will dive into full implementations of some popular and comparatively recent CNN architectures whose designs represent most of the techniques commonly used by modern practitioners.

먼저, 컨볼루션 신경망의 동기에 대해 더 깊이 살펴보겠습니다. 그런 다음 모든 컨볼루션 네트워크의 백본을 구성하는 기본 작업을 살펴봅니다. 여기에는 컨벌루션 레이어 자체, 패딩 및 스트라이드를 포함한 핵심적인 세부 정보, 인접한 공간 영역에 걸쳐 정보를 집계하는 데 사용되는 풀링 레이어, 각 레이어에서 다중 채널 사용, 현대 아키텍처 구조에 대한 신중한 논의가 포함됩니다. 우리는 현대 딥러닝이 등장하기 오래 전에 성공적으로 배포된 최초의 컨볼루셔널 네트워크인 LeNet의 전체 작동 예제로 이 장을 마무리할 것입니다. 다음 장에서는 현대 실무자가 일반적으로 사용하는 대부분의 기술을 대표하는 디자인의 인기 있고 비교적 최근의 일부 CNN 아키텍처의 전체 구현에 대해 살펴보겠습니다.

7.1. From Fully Connected Layers to Conolutions

To this day, the models that we have discussed so far remain appropriate options when we are dealing with tabular data. By tabular, we mean that the data consist of rows corresponding to examples and columns corresponding to features. With tabular data, we might anticipate that the patterns we seek could involve interactions among the features, but we do not assume any structure a priori concerning how the features interact.

오늘까지 우리가 논의한 모델은 표 데이터(tabular data)를 다룰 때 적절한 옵션으로 남아 있습니다. 테이블 형식(tabular data)이란 데이터가 examples 에 해당하는 행과 features에 해당하는 열로 구성됨을 의미합니다. 테이블 형식 데이터를 사용하면 우리가 찾는 패턴이 기능(features) 간의 상호 작용을 포함할 수 있다고 예상할 수 있지만 기능(features)이 상호 작용하는 방식과 관련하여 어떤 구조도 선험적으로 가정하지 않습니다.

Deel Learning에서 Examples 와 Features 란?

In deep learning, "examples" refer to the individual data instances or observations used for training or evaluating a model. They can be images, texts, audio clips, or any other form of input data that the model processes. Examples are typically represented as tensors or arrays of numbers to be fed into the deep learning model.

딥러닝에서 "예제(Examples)"는 모델의 학습 또는 평가를 위해 사용되는 개별 데이터 인스턴스 또는 관측치를 의미합니다. 예제는 이미지, 텍스트, 오디오 클립 또는 모델이 처리하는 다른 형태의 입력 데이터일 수 있습니다. 예제는 일반적으로 텐서나 숫자 배열로 표현되어 딥러닝 모델에 공급됩니다.

"Features" in deep learning context generally refer to the input variables or attributes that are used to represent the examples. Features are derived from the raw input data and serve as the basis for making predictions or classifications. In computer vision, for example, features may include pixel values or visual descriptors extracted from images. In natural language processing, features may be word embeddings or other text representations. The choice and quality of features can significantly impact the performance and effectiveness of a deep learning model.

"특징(Features)"은 딥러닝에서 입력 변수 또는 속성을 가리키는 용어로 사용됩니다. 특징은 원시 입력 데이터로부터 파생된 값으로, 예제를 나타내는 데 사용됩니다. 특징은 예를 들어 이미지에서 픽셀 값이나 시각적 특징 기술자로 구성될 수 있습니다. 자연어 처리에서는 단어 임베딩이나 기타 텍스트 표현이 특징으로 사용될 수 있습니다. 특징의 선택과 품질은 딥러닝 모델의 성능과 효과에 중대한 영향을 미칠 수 있습니다.

Sometimes, we truly lack knowledge to guide the construction of craftier architectures. In these cases, an MLP may be the best that we can do. However, for high-dimensional perceptual data, such structure-less networks can grow unwieldy.

때때로 우리는 더 교묘한 건축물(craftier architectures)의 건설을 안내할 지식이 정말로 부족합니다. 이러한 경우 MLP가 최선일 수 있습니다. 그러나 고차원 지각 데이터의 경우 이러한 구조가 없는 네트워크는 다루기 힘들게 커질 수 있습니다.

For instance, let’s return to our running example of distinguishing cats from dogs. Say that we do a thorough job in data collection, collecting an annotated dataset of one-megapixel photographs. This means that each input to the network has one million dimensions. Even an aggressive reduction to one thousand hidden dimensions would require a fully connected layer characterized by 10⁶×10³=10⁹ parameters. Unless we have lots of GPUs, a talent for distributed optimization, and an extraordinary amount of patience, learning the parameters of this network may turn out to be infeasible.

예를 들어, 고양이와 개를 구별하는 예제로 돌아가 봅시다. 1메가픽셀 사진의 주석이 달린 데이터 세트를 수집하는 데이터 수집 작업을 철저히 수행한다고 가정해 보겠습니다. 이것은 신경망에 대한 각 입력이 백만 개의 차원을 갖는다는 것을 의미합니다. 1000개의 은닉 차원으로 공격적으로 축소하더라도 10⁶×10³=10⁹ 매개변수로 특징지어지는 완전히 연결된 레이어가 필요합니다. 많은 GPU, 분산 최적화 능력, 엄청난 인내심이 없다면 이 네트워크의 매개변수를 학습하는 것이 불가능할 수 있습니다.

A careful reader might object to this argument on the basis that one megapixel resolution may not be necessary. However, while we might be able to get away with one hundred thousand pixels, our hidden layer of size 1000 grossly underestimates the number of hidden units that it takes to learn good representations of images, so a practical system will still require billions of parameters. Moreover, learning a classifier by fitting so many parameters might require collecting an enormous dataset. And yet today both humans and computers are able to distinguish cats from dogs quite well, seemingly contradicting these intuitions. That is because images exhibit rich structure that can be exploited by humans and machine learning models alike. Convolutional neural networks (CNNs) are one creative way that machine learning has embraced for exploiting some of the known structure in natural images.

신중한 독자라면 1메가픽셀 해상도가 필요하지 않을 수 있다는 근거로 이 주장에 반대할 수 있습니다. 그러나 10만 개의 픽셀로 벗어날 수 있지만 1000 크기의 숨겨진 레이어는 이미지의 좋은 표현을 학습하는 데 필요한 숨겨진 단위의 수를 과소 평가하므로 실제 시스템에는 여전히 수십억 개의 매개 변수가 필요합니다. 또한 너무 많은 매개변수를 피팅하여 분류기를 학습하려면 막대한 데이터 세트를 수집해야 할 수 있습니다. 그러나 오늘날 인간과 컴퓨터 모두 고양이와 개를 꽤 잘 구별할 수 있으며 이러한 직관과 모순되는 것처럼 보입니다. 이미지는 인간과 기계 학습 모델 모두가 활용할 수 있는 풍부한 구조를 보여주기 때문입니다. CNN(컨볼루션 신경망)은 기계 학습이 자연 이미지의 알려진 구조 중 일부를 활용하기 위해 채택한 창의적인 방법 중 하나입니다.

7.1.1. Invariance (불변)

Imagine that we want to detect an object in an image. It seems reasonable that whatever method we use to recognize objects should not be overly concerned with the precise location of the object in the image. Ideally, our system should exploit this knowledge. Pigs usually do not fly and planes usually do not swim. Nonetheless, we should still recognize a pig were one to appear at the top of the image. We can draw some inspiration here from the children’s game “Where’s Waldo” (depicted in Fig. 7.1.1). The game consists of a number of chaotic scenes bursting with activities. Waldo shows up somewhere in each, typically lurking in some unlikely location. The reader’s goal is to locate him. Despite his characteristic outfit, this can be surprisingly difficult, due to the large number of distractions. However, what Waldo looks like does not depend upon where Waldo is located. We could sweep the image with a Waldo detector that could assign a score to each patch, indicating the likelihood that the patch contains Waldo. In fact, many object detection and segmentation algorithms are based on this approach (Long et al., 2015). CNNs systematize this idea of spatial invariance, exploiting it to learn useful representations with fewer parameters.

이미지를 어떤 물체인지 감지하고 싶다고 상상해 보십시오. 우리가 객체를 인식하기 위해 사용하는 방법이 무엇이든 이미지에서 객체의 정확한 위치(precise location)에 지나치게 관심을 가져서는 안 된다는 것이 합리적으로 보입니다. 이상적으로는 우리 시스템이 이 지식을 활용해야 합니다. 돼지는 일반적으로 날지 않으며 비행기는 일반적으로 수영하지 않습니다. 그럼에도 불구하고 우리는 여전히 돼지가 이미지 상단에 나타나도 돼지라는 것을 인식해야 합니다. 여기서 우리는 아이들의 게임 "Waldo는 어디에 있습니까?"(그림 7.1.1에 묘사됨)에서 약간의 영감을 얻을 수 있습니다. 이 게임은 활동으로 가득 찬 수많은 혼란스러운 장면으로 구성됩니다. Waldo는 각각 어딘가에 나타나며 일반적으로 가능성이 낮은 위치에 숨어 있습니다. 독자의 목표는 그를 찾는 것입니다. 그의 독특한 복장에도 불구하고 많은 산만함으로 인해 이것은 놀라울 정도로 어려울 수 있습니다. 그러나 Waldo의 모습은 Waldo의 위치에 따라 달라지지 않습니다. 각 패치에 점수를 할당할 수 있는 Waldo 탐지기로 이미지를 스윕하여 패치에 Waldo가 포함되어 있을 가능성을 나타낼 수 있습니다. 실제로 많은 객체 감지 및 분할 알고리즘이 이 접근 방식을 기반으로 합니다(Long et al., 2015). CNN은 이러한 공간적 불변성(spatial invariance)에 대한 아이디어를 체계화하여 이를 활용하여 더 적은 매개변수로 유용한 표현을 학습합니다.

We can now make these intuitions more concrete by enumerating a few desiderata to guide our design of a neural network architecture suitable for computer vision:

이제 우리는 컴퓨터 비전에 적합한 신경망 아키텍처 설계를 안내하기 위해 몇 가지 필요한 사항을 열거함으로써 이러한 직관을 보다 구체적으로 만들 수 있습니다.

1. In the earliest layers, our network should respond similarly to the same patch, regardless of where it appears in the image. This principle is called translation invariance (or translation equivariance).
   초기 레이어에서 네트워크는 이미지의 어디에 표시되는지에 관계없이 동일한 패치(patch)에 유사하게 응답해야 합니다. 이 원칙을 translation invariance (또는 translation equivariance-)이라고 합니다.
   
   
2. The earliest layers of the network should focus on local regions, without regard for the contents of the image in distant regions. This is the locality principle. Eventually, these local representations can be aggregated to make predictions at the whole image level.
   네트워크의 가장 초기 계층은 먼 지역에 있는 이미지의 내용을 고려하지 않고 로컬 지역에 초점을 맞춰야 합니다. 이것이 지역성의 원칙(locality principle)입니다. 결국 이러한 로컬 representations 을 집계하여 전체 이미지 수준에서 예측할 수 있습니다.
   
   
3. As we proceed, deeper layers should be able to capture longer-range features of the image, in a way similar to higher level vision in nature.
   진행함에 따라 더 깊은 레이어는 자연의 더 높은 수준의 비전과 유사한 방식으로 이미지의 장거리 기능(longer-range features)을 캡처할 수 있어야 합니다.
   

Let’s see how this translates into mathematics.

이것이 어떻게 수학으로 변환되는지 봅시다.

7.1.2. Constraining the MLP

To start off, we can consider an MLP with two-dimensional images X as inputs and their immediate hidden representations H similarly represented as matrices (they are two-dimensional tensors in code), where both X and H have the same shape. Let that sink in. We now conceive of not only the inputs but also the hidden representations as possessing spatial structure.

우선, 2차원 이미지 X를 입력으로 사용하는 MLP를 생각해 볼 수 있습니다. 그들의  immediate hidden representations H는 matrices(그들은 코드에서 2차원 텐서입니다.)로서 두 X와 H가 같은 모양을 갖기 때문에 유사하게 표현됩니다. 좀 더 깊이 들어 갑시다.  우리는 이제 입력뿐만 아니라 hidden representations도 spatial structure를 가지고 있다고 생각합니다.

Let [X]_i,j and [H]_i,j denote the pixel at location (i,j) in the input image and hidden representation, respectively. Consequently, to have each of the hidden units receive input from each of the input pixels, we would switch from using weight matrices (as we did previously in MLPs) to representing our parameters as fourth-order weight tensors W. Suppose that U contains biases, we could formally express the fully connected layer as

[X]_i,j 및 [H]_i,j는 각각 입력 이미지 및 hidden representation의 location (i,j)에 있는 픽셀을 나타냅니다. 결과적으로 각각의 은닉 유닛(hidden units)이 각 입력 픽셀로부터 입력을 받도록 하려면 가중치 행렬-weight matrices-(이전에 MLP에서 했던 것처럼)을 사용하는 것에서 매개변수를 4차 가중치 텐서 W(fourth-order weight tensors W)로 나타내는 것으로 전환해야 합니다.  U가 편향을 포함한다고 가정합니다. 우리는 fully connected layer를 공식적으로 다음과 같이 표현할 수 있습니다.

The switch from W to V is entirely cosmetic for now since there is a one-to-one correspondence between coefficients in both fourth-order tensors. We simply re-index the subscripts (k,l) such that k=i+a and l=j+b. In other words, we set [V]_i,j,a,b=[W]_i,j,i+a,j+b. The indices a and b run over both positive and negative offsets, covering the entire image. For any given location (i, j) in the hidden representation [H]_i,j, we compute its value by summing over pixels in x, centered around (i,j) and weighted by [V]_i,j,a,b. Before we carry on, let’s consider the total number of parameters required for a single layer in this parametrization: a 1000×1000 image (1 megapixel) is mapped to a 1000×1000 hidden representation. This requires 10¹² parameters, far beyond what computers currently can handle.

W에서 V로의 전환은 두 4차 텐서(fourth-order tensors)의 계수(coefficients ) 사이에 일대일 대응이 있기 때문에 현재로서는 완전히 외관상(cosmetic )입니다. 우리는 단순히 k=i+a 및 l=j+b와 같이 subscripts  (k,l)를 다시 인덱싱합니다. 즉, [V]_i,j,a,b=[W]_i,j,i+a,j+b로 설정합니다. 인덱스 a와 b는 양수 오프셋과 음수 오프셋 모두에서 실행되어 전체 이미지를 덮습니다. 숨겨진 표현(hidden representation) [H]_i,j의 주어진 위치(location )(i, j)에 대해 x의 픽셀을 합산하여 값을 계산하고 (i,j)를 중심으로 [V]_i,j,a,b에 의해 가중치를 적용합니다.  계속하기 전에 이 매개변수화에서 단일 레이어에 필요한 총 매개변수 수를 고려해 보겠습니다. 1000×1000 이미지(1메가픽셀)는 1000×1000 숨겨진 표현에 매핑(hidden representation)됩니다. 여기에는 컴퓨터가 현재 처리할 수 있는 것보다 훨씬 많은 10¹²개의 매개변수가 필요합니다.

hidden representation 이란?

Hidden representation refers to the intermediate or hidden layers of a neural network where the input data is transformed and processed before reaching the final output layer. It is a set of internal representations or features that capture relevant information about the input data.

'Hidden representation'은 신경망의 중간 또는 숨겨진 레이어로, 입력 데이터가 최종 출력 레이어에 도달하기 전에 변환되고 처리되는 부분을 의미합니다. 이는 입력 데이터에 대한 관련 정보를 포착하는 내부 표현이나 피처들의 집합입니다.

In a neural network, the hidden layers perform computations on the input data using a combination of weights, biases, and activation functions. Each hidden layer progressively extracts higher-level features or abstractions from the raw input data. These hidden representations are not directly observable or interpretable by humans but contain important information that helps the network make accurate predictions or classifications.

신경망에서는 숨겨진 레이어들이 가중치, 편향, 활성화 함수의 조합을 사용하여 입력 데이터에 대해 계산을 수행합니다. 각 숨겨진 레이어는 원시 입력 데이터로부터 점차적으로 고수준의 피처나 추상화를 추출합니다. 이러한 숨겨진 표현은 직접적으로 사람들에게 관측 가능하거나 해석 가능한 것은 아니지만, 네트워크가 정확한 예측이나 분류를 수행하는 데 도움이 되는 중요한 정보를 포함합니다.

The purpose of hidden representations is to capture meaningful and relevant patterns in the data that are useful for the specific task the neural network is designed to solve. By learning these representations through the training process, neural networks can automatically discover complex relationships and hierarchical structures in the data, leading to improved performance and generalization.

숨겨진 표현의 목적은 신경망이 해결하려는 특정 작업에 유용한 데이터의 의미 있는 패턴을 포착하는 것입니다. 훈련 과정을 통해 이러한 표현을 학습함으로써 신경망은 데이터에서 복잡한 관계와 계층 구조를 자동으로 발견할 수 있습니다. 이를 통해 성능과 일반화 능력이 향상됩니다.

Overall, hidden representations play a crucial role in deep learning as they enable the network to learn and represent data in a more compact and expressive form, facilitating effective information processing and learning.

전반적으로, 숨겨진 표현은 딥 러닝에서 중요한 역할을 하며, 네트워크가 데이터를 더 간결하고 표현력이 풍부한 형태로 학습하고 표현할 수 있도록 돕습니다. 이는 효과적인 정보 처리와 학습을 가능하게 하며, 네트워크의 성능 향상에 기여합니다.

7.1.2.1. Translation Invariance

Now let’s invoke the first principle established above: translation invariance (Zhang and others, 1988). This implies that a shift in the input X should simply lead to a shift in the hidden representation H. This is only possible if V and U do not actually depend on (i,j). As such, we have [V]_i,j,a,b=[V]_a,b and U is a constant, say u. As a result, we can simplify the definition for H:

이제 위에서 확립한 첫 번째 원칙인 변환 불변성(translation invariance)을 적용해 보겠습니다(Zhang and others, 1988). 이는 입력 X의 이동이 단순히 숨겨진 표현(hidden representation) H의 이동으로 이어져야 함을 의미합니다. 이것은 V와 U가 실제로 (i,j)에 의존하지 않는 경우에만 가능합니다. 따라서 [V]_i,j,a,b=[V]_a,b이고 U는 상수입니다. 결과적으로 H에 대한 정의를 단순화할 수 있습니다.

This is a convolution! We are effectively weighting pixels at (i+a,j+b) in the vicinity of location (i,j) with coefficients [V]_a,b to obtain the value [H]_i,j. Note that [V]_a,b needs many fewer coefficients than [V]_i,j,a,b since it no longer depends on the location within the image. Consequently, the number of parameters required is no longer 10¹² but a much more reasonable 4⋅10⁶: we still have the dependency on a,b∈(−1000,1000). In short, we have made significant progress. Time-delay neural networks (TDNNs) are some of the first examples to exploit this idea (Waibel et al., 1989).

이것은 convolution입니다! 값 [H]_i,j를 얻기 위해 계수(coefficients)_a,b를 사용하여 위치 (i,j) 부근의 (i+a,j+b)에 있는 픽셀에 효과적으로 가중치를 부여합니다. [V]_a,b는 더 이상 이미지 내의 위치에 의존하지 않기 때문에 [V]_i,j,a,b보다 훨씬 적은 계수가 필요합니다. 결과적으로 필요한 매개변수의 수는 더 이상 10¹²가 아니라 훨씬 더 합리적인 4⋅10⁶입니다. 여전히 a,b∈(−1000,1000)에 대한 종속성이 있습니다. 요컨대, 우리는 상당한 진전을 이루었습니다. 시간 지연 신경망-Time-delay neural networks-(TDNN)은 이 아이디어를 활용한 첫 번째 사례 중 일부입니다(Waibel et al., 1989).

Translation Invariance란?

Translation invariance in convolutional neural networks (CNNs) refers to the property of CNNs to recognize patterns or features in an input image regardless of their position or location within the image. It means that if an object or feature is present in different parts of the image, the CNN will be able to detect and identify it regardless of its specific location.

합성곱 신경망(Convolutional Neural Networks, CNNs)의 변환 불변성(Translation Invariance)은 CNN이 입력 이미지 내에서 위치나 위치에 관계없이 패턴이나 특징을 인식하는 성질을 의미합니다. 이는 이미지 내에 객체나 특징이 다른 위치에 존재할 경우, CNN이 그것을 인식하고 식별할 수 있다는 것을 의미합니다.

CNNs achieve translation invariance through the use of convolutional layers and pooling layers. Convolutional layers apply filters or kernels to scan the entire input image, detecting local patterns or features. These filters are shared across the entire image, allowing the CNN to learn and recognize the same patterns regardless of their position. Pooling layers further enhance translation invariance by downsampling the feature maps, reducing the spatial dimensions while retaining important features.

CNN은 합성곱 계층(Convolutional Layers)과 풀링 계층(Pooling Layers)을 사용하여 변환 불변성을 달성합니다. 합성곱 계층은 필터 또는 커널을 사용하여 전체 입력 이미지를 스캔하며 지역적인 패턴이나 특징을 감지합니다. 이러한 필터는 이미지 전체에 걸쳐 공유되며, CNN은 위치에 상관없이 동일한 패턴을 학습하고 인식할 수 있습니다. 풀링 계층은 특징 맵을 다운샘플링하여 공간적인 차원을 줄이고 중요한 특징을 유지함으로써 변환 불변성을 강화합니다.

This translation invariance property makes CNNs well-suited for tasks such as image classification, object detection, and image segmentation, where the position or location of objects or features within an image may vary. It enables CNNs to effectively learn and generalize spatial patterns across different parts of an image.

이러한 변환 불변성은 CNN을 이미지 분류, 객체 탐지, 이미지 세그멘테이션과 같은 작업에 적합하게 만듭니다. 이미지 내 객체나 특징의 위치가 다양하게 변할 수 있는 경우에도 CNN은 효과적으로 공간 패턴을 학습하고 일반화할 수 있게 됩니다.

7.1.2.2. Locality

Now let’s invoke the second principle: locality. As motivated above, we believe that we should not have to look very far away from location (i,j) in order to glean relevant information to assess what is going on at [H]_i,j. This means that outside some range |a|>Δ or |b|>Δ, we should set [V]_a,b=0. Equivalently, we can rewrite [H]_i,j as

이제 두 번째 원칙인 지역성을 적용해 보겠습니다. 위에서 동기부여된 바와 같이, 우리는 [H]_i,j에서 무슨 일이 일어나고 있는지 평가하기 위해 관련 정보를 수집하기 위해 위치 (i,j)에서 아주 멀리 볼 필요가 없다고 믿습니다. 이는 어떤 범위 |a|>Δ 또는 |b|>Δ를 벗어나면 [V]_a,b=0으로 설정해야 함을 의미합니다. 마찬가지로 [H]_i,j를 다음과 같이 다시 쓸 수 있습니다.

This reduces the number of parameters from 4⋅106 to 4Δ2, where Δ is typically smaller than 10. As such, we reduced the number of parameters by another 4 orders of magnitude. Note that (7.1.3), in a nutshell, is what is called a convolutional layer. Convolutional neural networks (CNNs) are a special family of neural networks that contain convolutional layers. In the deep learning research community, V is referred to as a convolution kernel, a filter, or simply the layer’s weights that are learnable parameters.

이렇게 하면 매개변수 수가 4⋅106에서 4Δ2로 줄어듭니다. 여기서 Δ는 일반적으로 10보다 작습니다. 따라서 매개변수 수를 4배 더 줄였습니다. 간단히 말해서 (7.1.3)은 컨볼루션 레이어(convolutional layer)라고 합니다. 컨볼루션 신경망-Convolutional neural networks-(CNN)은 컨볼루션 레이어(convolutional layer)를 포함하는 neural networks의 special family입니다. 딥 러닝 연구 커뮤니티에서 V는 컨볼루션 커널(convolution kernel), 필터 또는 단순히 학습 가능한 매개변수인 레이어의 가중치(weights )라고 합니다.

While previously, we might have required billions of parameters to represent just a single layer in an image-processing network, we now typically need just a few hundred, without altering the dimensionality of either the inputs or the hidden representations. The price paid for this drastic reduction in parameters is that our features are now translation invariant and that our layer can only incorporate local information, when determining the value of each hidden activation. All learning depends on imposing inductive bias. When that bias agrees with reality, we get sample-efficient models that generalize well to unseen data. But of course, if those biases do not agree with reality, e.g., if images turned out not to be translation invariant, our models might struggle even to fit our training data.

이전에는 이미지 처리 네트워크의 단일 레이어를 나타내기 위해 수십억 개의 매개변수가 필요했지만 이제는 입력 또는 숨겨진 표현(hidden representations)의 차원을 변경하지 않고 일반적으로 수백 개만 필요합니다. 이러한 매개 변수의 급격한 감소에 대해 지불한 대가는 우리의 기능이 이제 변환 불변(translation invariant)이고 레이어가 각 숨겨진 활성화 값을 결정할 때 로컬 정보만 통합할 수 있다는 것입니다. 모든 학습은 귀납적 편향(inductive bias)을 부과하는 데 달려 있습니다. 그 편견(bias )이 현실과 일치할 때 우리는 보이지 않는 데이터에 잘 일반화되는 sample-efficient models을 얻습니다. 그러나 물론 이러한 편향(bias )이 현실과 일치하지 않는 경우(예: 이미지가 변환 불변(translation invariant)이 아닌 것으로 판명된 경우) 모델이 훈련 데이터에 맞추는 데 어려움을 겪을 수 있습니다.

This dramatic reduction in parameters brings us to our last desideratum, namely that deeper layers should represent larger and more complex aspects of an image. This can be achieved by interleaving nonlinearities and convolutional layers repeatedly.

이러한 매개변수의 극적인 감소는 마지막 요구사항, 즉 더 깊은 레이어가 이미지의 더 크고 더 복잡한 측면을 나타내야 한다는 점을 의미합니다. 이는 비선형성과 컨벌루션 레이어를 반복적으로 interleaving 하여 달성할 수 있습니다.

7.1.3. Convolutions

Let’s briefly review why (7.1.3) is called a convolution. In mathematics, the convolution between two functions (Rudin, 1973), say f,g:ℝ^d→ℝ is defined as

(7.1.3)이 컨볼루션이라고 불리는 이유를 간단히 살펴보겠습니다. 수학에서 f,g:ℝ^d→ℝ와 같이 두 함수 간의 컨볼루션(Rudin, 1973)은 다음과 같이 정의됩니다.

That is, we measure the overlap between f and g when one function is “flipped” and shifted byx. Whenever we have discrete objects, the integral turns into a sum. For instance, for vectors from the set of square summable infinite dimensional vectors with index running over ℤ we obtain the following definition:

즉, 하나의 함수가 "플립"되고 x만큼 이동될 때 f와 g 사이의 중첩을 측정합니다. 이산 객체(discrete objects)가 있을 때마다 적분(integral)은 합계로 바뀝니다. 예를 들어, 인덱스가 ℤ 이상인 제곱 합산 가능한 무한 차원 벡터 세트의 벡터에 대해 다음 정의를 얻습니다.

For two-dimensional tensors, we have a corresponding sum with indices (a,b) for f and (i−a,j−b) for g, respectively:

2차원 텐서의 경우 각각 f에 대한 인덱스 (a,b)와 g에 대한 (i-a,j-b)의 해당 합계가 있습니다.

This looks similar to (7.1.3), with one major difference. Rather than using (i+a,j+b), we are using the difference instead. Note, though, that this distinction is mostly cosmetic since we can always match the notation between (7.1.3) and (7.1.6). Our original definition in (7.1.3) more properly describes a cross-correlation. We will come back to this in the following section.

이것은 (7.1.3)과 비슷해 보이지만 한 가지 중요한 차이점이 있습니다. (i+a,j+b)를 사용하는 대신 차이점을 대신 사용합니다. 하지만 (7.1.3)과 (7.1.6) 사이의 표기법을 항상 일치시킬 수 있기 때문에 이 구별은 대부분 외형적(cosmetic )입니다. (7.1.3)의 원래 정의는 교차 상관(cross-correlation)을 더 적절하게 설명합니다. 이에 대해서는 다음 섹션에서 다시 설명하겠습니다.

7.1.4. Channels

Returning to our Waldo detector, let’s see what this looks like. The convolutional layer picks windows of a given size and weighs intensities according to the filter V, as demonstrated in Fig. 7.1.2. We might aim to learn a model so that wherever the “waldoness” is highest, we should find a peak in the hidden layer representations.

Waldo 감지기로 돌아가서 이것이 어떻게 보이는지 봅시다. 컨볼루션 레이어는 주어진 크기의 창을 선택하고 그림 7.1.2에서 보여지는 것처럼 필터 V에 따라 강도를 가중합니다. "waldoness"가 가장 높은 곳에서 숨겨진 레이어 표현에서 최고점을 찾도록 모델 학습을 목표로 할 수 있습니다.

There is just one problem with this approach. So far, we blissfully ignored that images consist of 3 channels: red, green, and blue. In sum, images are not two-dimensional objects but rather third-order tensors, characterized by a height, width, and channel, e.g., with shape 1024×1024×3 pixels. While the first two of these axes concern spatial relationships, the third can be regarded as assigning a multidimensional representation to each pixel location. We thus index X as [X]_i,j,k. The convolutional filter has to adapt accordingly. Instead of [V]_a,b, we now have [V]_a,b,c.

이 접근 방식에는 한 가지 문제가 있습니다. 지금까지 우리는 이미지가 빨강, 초록, 파랑의 3개 채널로 구성되어 있다는 사실을 다행스럽게도 무시했습니다. 요컨대 이미지는 2차원 객체가 아니라 높이, 너비 및 채널(예: 1024×1024×3 픽셀 모양)로 특징지어지는 3차 텐서입니다. 이러한 축 중 처음 두 개는 공간 관계(spatial relationships)와 관련이 있지만 세 번째 축은 각 픽셀 위치에 다차원 표현을 할당하는 것으로 간주할 수 있습니다. 따라서 X를 [X]_i,j,k로 인덱싱합니다. 컨벌루션 필터는 그에 따라 adapt 해야 합니다. [V]_a,b 대신 이제 [V]_a,b,c가 있습니다.

Moreover, just as our input consists of a third-order tensor, it turns out to be a good idea to similarly formulate our hidden representations as third-order tensors H. In other words, rather than just having a single hidden representation corresponding to each spatial location, we want an entire vector of hidden representations corresponding to each spatial location. We could think of the hidden representations as comprising a number of two-dimensional grids stacked on top of each other. As in the inputs, these are sometimes called channels. They are also sometimes called feature maps, as each provides a spatialized set of learned features to the subsequent layer. Intuitively, you might imagine that at lower layers that are closer to inputs, some channels could become specialized to recognize edges while others could recognize textures.

또한 입력이 3차 텐서로 구성되는 것처럼 숨겨진 표현을 3차 텐서 H로 유사하게 공식화하는 것이 좋습니다. 즉, 각 공간 위치에 해당하는 단일 숨겨진 표현(hidden representation)이 아니라 각 공간 위치에 해당하는 숨겨진 표현(hidden representation)의 전체 벡터가 필요합니다. 숨겨진 표현(hidden representation)은 서로 위에 쌓인 여러 개의 2차원 그리드로 구성되어 있다고 생각할 수 있습니다. 입력과 마찬가지로 이를 채널이라고도 합니다. 각각은 학습된 기능의 공간화된 세트를 후속 계층에 제공하기 때문에 기능 맵이라고도 합니다. 직관적으로 입력에 더 가까운 하위 레이어에서 일부 채널은 가장자리를 인식하도록 특수화되고 다른 채널은 텍스처를 인식할 수 있다고 상상할 수 있습니다.

To support multiple channels in both inputs (X) and hidden representations (H), we can add a fourth coordinate to V: [V]_a,b,c,d. Putting everything together we have:

입력(X)과 숨겨진 표현(H) 모두에서 다중 채널을 지원하기 위해 V에 네 번째 좌표인 [V]_a,b,c,d를 추가할 수 있습니다. 모든 것을 종합하면 다음과 같습니다.

where d indexes the output channels in the hidden representations H. The subsequent convolutional layer will go on to take a third-order tensor, H, as input. Being more general, (7.1.7) is the definition of a convolutional layer for multiple channels, where V is a kernel or filter of the layer.

여기서 d는 숨겨진 표현 H의 출력 채널을 인덱싱합니다. 후속 컨볼루션 레이어는 계속해서 3차 텐서 H를 입력으로 사용합니다. 보다 일반적으로 (7.1.7)은 다중 채널에 대한 컨볼루션 계층의 정의이며, 여기서 V는 계층의 커널 또는 필터입니다.

There are still many operations that we need to address. For instance, we need to figure out how to combine all the hidden representations to a single output, e.g., whether there is a Waldo anywhere in the image. We also need to decide how to compute things efficiently, how to combine multiple layers, appropriate activation functions, and how to make reasonable design choices to yield networks that are effective in practice. We turn to these issues in the remainder of the chapter.

해결해야 할 작업이 여전히 많이 있습니다. 예를 들어, 모든 숨겨진 표현을 단일 출력으로 결합하는 방법을 알아내야 합니다(예: 이미지 어디에나 Waldo가 있는지 여부). 또한 효율적으로 계산하는 방법, 여러 계층을 결합하는 방법, 적절한 활성화 기능, 실제로 효과적인 네트워크를 생성하기 위해 합리적인 설계 선택을 하는 방법을 결정해야 합니다. 이 장의 나머지 부분에서 이러한 문제를 살펴보겠습니다.

7.1.5. Summary and Discussion

In this section we derived the structure of convolutional neural networks from first principles. While it is unclear whether this is what led to the invention of CNNs, it is satisfying to know that they are the right choice when applying reasonable principles to how image processing and computer vision algorithms should operate, at least at lower levels. In particular, translation invariance in images implies that all patches of an image will be treated in the same manner. Locality means that only a small neighborhood of pixels will be used to compute the corresponding hidden representations. Some of the earliest references to CNNs are in the form of the Neocognitron (Fukushima, 1982).

이 섹션에서는 첫 번째 원칙에서 컨볼루션 신경망의 구조를 도출했습니다. 이것이 CNN의 발명으로 이어졌는지 여부는 불분명하지만 이미지 처리 및 컴퓨터 비전 알고리즘이 적어도 낮은 수준에서 작동하는 방식에 합리적인 원칙을 적용할 때 CNN이 올바른 선택이라는 것을 알게 되어 만족스럽습니다. 특히 이미지의 변환 불변성은 이미지의 모든 패치가 동일한 방식으로 처리됨을 의미합니다. 지역성은 해당 숨겨진 표현을 계산하는 데 작은 픽셀 이웃만 사용됨을 의미합니다. CNN에 대한 초기 참조 중 일부는 Neocognitron의 형태입니다(Fukushima, 1982).

A second principle that we encountered in our reasoning is how to reduce the number of parameters in a function class without limiting its expressive power, at least, whenever certain assumptions on the model hold. We saw a dramatic reduction of complexity as a result of this restriction, turning computationally and statistically infeasible problems into tractable models.

추론에서 만난 두 번째 원칙은 적어도 모델에 대한 특정 가정이 유지될 때마다 표현력을 제한하지 않고 함수 클래스의 매개변수 수를 줄이는 방법입니다. 우리는 이 제한의 결과로 복잡성이 극적으로 감소하여 계산 및 통계적으로 실행 불가능한 문제를 다루기 쉬운 모델로 바꾸는 것을 보았습니다.

Adding channels allowed us to bring back some of the complexity that was lost due to the restrictions imposed on the convolutional kernel by locality and translation invariance. Note that channels are quite a natural addition beyond red, green, and blue. Many satellite images, in particular for agriculture and meteorology, have tens to hundreds of channels, generating hyperspectral images instead. They report data on many different wavelengths. In the following we will see how to use convolutions effectively to manipulate the dimensionality of the images they operate on, how to move from location-based to channel-based representations and how to deal with large numbers of categories efficiently.

채널을 추가하면 지역성 및 번역 불변성에 의해 컨볼루션 커널에 부과된 제한으로 인해 손실된 복잡성을 일부 되돌릴 수 있었습니다. 채널은 빨강, 녹색 및 파랑 이외의 자연스러운 추가 사항입니다. 특히 농업 및 기상학을 위한 많은 위성 이미지에는 수십에서 수백 개의 채널이 있으며 대신 하이퍼스펙트럼 이미지를 생성합니다. 그들은 다양한 파장에 대한 데이터를 보고합니다. 다음에서는 콘볼루션을 효과적으로 사용하여 작동하는 이미지의 차원을 조작하는 방법, 위치 기반 표현에서 채널 기반 표현으로 이동하는 방법 및 많은 수의 범주를 효율적으로 처리하는 방법을 살펴봅니다.

7.1.6. Exercises

7. Convolutional Neural Networks — Dive into Deep Learning 1.0.0-beta0 documentation (d2l.ai)

Image data is represented as a two-dimensional grid of pixels, be it monochromatic or in color. Accordingly each pixel corresponds to one or multiple numerical values respectively. So far we ignored this rich structure and treated them as vectors of numbers by flattening the images, irrespective of the spatial relation between pixels. This deeply unsatisfying approach was necessary in order to feed the resulting one-dimensional vectors through a fully connected MLP.

이미지 데이터는 단색이든 컬러이든 픽셀의 2차원 그리드로 표현됩니다. 따라서 각 픽셀은 각각 하나 또는 여러 개의 수치에 해당합니다. 지금까지 우리는 이 풍부한 구조를 무시하고 픽셀 간의 공간적 관계에 관계없이 이미지를 flattening 하여 숫자 벡터로 처리했습니다.  fully connected MLP를 통해 resulting one-dimensional vectors를 공급하기 위해서는 매우 만족스럽지 못한 이 접근 방식이 필요했습니다.

Because these networks are invariant to the order of the features, we could get similar results regardless of whether we preserve an order corresponding to the spatial structure of the pixels or if we permute the columns of our design matrix before fitting the MLP’s parameters. Preferably, we would leverage our prior knowledge that nearby pixels are typically related to each other, to build efficient models for learning from image data.

이러한 네트워크는 features의 순서에 대해 변하지 않기 때문에 픽셀의 공간 구조에 해당하는 순서를 유지하는지 또는 MLP의 매개 변수를 맞추기 전에 디자인 행렬의 열을 치환하는지 여부에 관계없이 유사한 결과를 얻을 수 있습니다. 바람직하게는 주변 픽셀이 일반적으로 서로 관련되어 있다는 사전 지식을 활용하여 이미지 데이터에서 학습하기 위한 효율적인 모델을 구축합니다.

This chapter introduces convolutional neural networks (CNNs) (LeCun et al., 1995), a powerful family of neural networks that are designed for precisely this purpose. CNN-based architectures are now ubiquitous in the field of computer vision. For instance, on the Imagnet collection (Deng et al., 2009) it was only the use of convolutional neural networks, in short Convnets that provided significant performance improvements (Krizhevsky et al., 2012).

이 장에서는 정확히 이러한 목적을 위해 설계된 강력한 신경망 제품군인 CNN(Convolutional Neural Networks)(LeCun et al., 1995)을 소개합니다. CNN 기반 아키텍처는 이제 컴퓨터 비전 분야에서 유비쿼터스(어디에나 있는, 필수의 것)입니다. 예를 들어, Imagnet 컬렉션(Deng et al., 2009)에서 상당한 성능 향상을 제공한 Convnets에서 컨볼루션 신경망만 사용했습니다(Krizhevsky et al., 2012).

Modern CNNs, as they are called colloquially owe their design to inspirations from biology, group theory, and a healthy dose of experimental tinkering. In addition to their sample efficiency in achieving accurate models, CNNs tend to be computationally efficient, both because they require fewer parameters than fully connected architectures and because convolutions are easy to parallelize across GPU cores (Chetlur et al., 2014). Consequently, practitioners often apply CNNs whenever possible, and increasingly they have emerged as credible competitors even on tasks with a one-dimensional sequence structure, such as audio (Abdel-Hamid et al., 2014), text (Kalchbrenner et al., 2014), and time series analysis (LeCun et al., 1995), where recurrent neural networks are conventionally used. Some clever adaptations of CNNs have also brought them to bear on graph-structured data (Kipf and Welling, 2016) and in recommender systems.

흔히 불리는 이름인 Modern CNNs은 생물학, 집단 이론 및 healthy dose of experimental tinkering에서 영감을 받아 디자인되었습니다. 정확한 모델을 달성하는 샘플 효율성 외에도 CNN은 완전히 연결된 아키텍처보다 더 적은 매개변수가 필요하고 컨볼루션이 GPU 코어에서 쉽게 병렬화되기 때문에 계산적으로 효율적인 경향이 있습니다(Chetlur et al., 2014). 결과적으로 실무자들은 가능할 때마다 CNN을 적용하는 경우가 많으며 오디오(Abdel-Hamid et al., 2014), 텍스트(Kalchbrenner et al., 2014) 그리고 recurrent neural networks들이 전통적으로 사용 되었던 곳인 time series analysis (LeCun et al., 1995)와 같은 곳들에 1차원 시퀀스 구조의 작업에서도 점점 더 신뢰할 수 있는 경쟁자로 부상하고 있습니다.  CNN의 일부 영리한 적응은 또한 그래프 구조 데이터(Kipf and Welling, 2016)와 추천 시스템에 영향을 미쳤습니다.

First, we will dive more deeply into the motivation for convolutional neural networks. This is followed by a walk through the basic operations that comprise the backbone of all convolutional networks. These include the convolutional layers themselves, nitty-gritty details including padding and stride, the pooling layers used to aggregate information across adjacent spatial regions, the use of multiple channels at each layer, and a careful discussion of the structure of modern architectures. We will conclude the chapter with a full working example of LeNet, the first convolutional network successfully deployed, long before the rise of modern deep learning. In the next chapter, we will dive into full implementations of some popular and comparatively recent CNN architectures whose designs represent most of the techniques commonly used by modern practitioners.

먼저, 컨볼루션 신경망의 motivation 에 대해 더 깊이 파고들 것입니다. 그런 다음 모든 컨볼루션 네트워크의 중추를 구성하는 기본 작업을 살펴봅니다. 여기에는 컨볼루션 레이어 자체, 패딩 및 스트라이드를 포함한 핵심 세부 정보, 인접한 공간 영역에서 정보를 집계하는 데 사용되는 풀링 레이어, 각 레이어에서 다중 채널 사용 및 현대 아키텍처 구조에 대한 신중한 논의가 포함됩니다. 최신 딥 러닝이 부상하기 오래 전에 성공적으로 배포된 최초의 컨볼루션 네트워크인 LeNet의 전체 작업 예제로 이 장을 마무리할 것입니다. 다음 장에서는 현대 실무자가 일반적으로 사용하는 대부분의 기술을 대표하는 디자인을 가진 인기 있고 비교적 최근의 CNN 아키텍처의 전체 구현에 대해 자세히 알아볼 것입니다.

Convolutional Neural Networks (CNN)란? 

Convolutional Neural Networks (CNNs) are a class of deep learning models specifically designed for processing structured grid-like data, such as images or time series data. They are widely used in computer vision tasks, including image classification, object detection, and image segmentation.

합성곱 신경망(Convolutional Neural Networks, CNNs)은 이미지나 시계열 데이터와 같은 구조적인 격자 형태의 데이터를 처리하기 위해 특별히 설계된 딥러닝 모델의 한 종류입니다. CNN은 이미지 분류, 물체 검출, 이미지 세분화 등의 컴퓨터 비전 작업에서 널리 사용됩니다.

The key idea behind CNNs is to exploit the spatial structure of the input data by using convolutional layers. A convolutional layer applies a set of learnable filters (also known as kernels) to the input data, performing a convolution operation. This operation enables the network to automatically learn local patterns or features present in the input.

CNN의 핵심 아이디어는 convolutional layers을 사용하여 입력 데이터의 공간적 구조를 활용하는 것입니다. convolutional layers은 학습 가능한 필터(커널) 세트를 입력 데이터에 적용하여 convolution 연산을 수행합니다. 이러한 연산은 네트워크가 입력에 있는 지역적인 패턴이나 특징을 자동으로 학습할 수 있게 해줍니다.

CNNs typically consist of multiple layers, including convolutional layers, pooling layers, and fully connected layers.

Convolutional layers extract local features, while pooling layers downsample the feature maps, reducing their spatial dimensions. Finally, fully connected layers process the high-level features and produce the desired outputs, such as class probabilities.

CNN은 일반적으로 convolutional layers, pooling layers, fully connected layers 등 여러 계층으로 구성됩니다. Convolutional layers은 local features을 추출하고, pooling layers은 feature maps의 다운샘플링을 하여 공간적인 차원을 축소합니다. 마지막으로 fully connected layers은 high-level features을 처리하고, 원하는 출력(예: 클래스 확률)을 생성합니다.

By leveraging the hierarchical structure of CNNs, these networks can learn complex representations of the input data, automatically capturing relevant features at different levels of abstraction. This makes CNNs highly effective in visual tasks, as they can learn to recognize patterns, shapes, and structures in images, leading to state-of-the-art performance in various computer vision applications.

CNN은 계층 구조를 활용하여 입력 데이터의 복잡한 표현을 학습할 수 있으며, 다른 수준의 추상화에서 관련 있는 features 을 자동으로 파악할 수 있습니다. 이를 통해 CNN은 이미지에서 패턴, 형태, 구조를 인식하는 것을 학습하므로, 컴퓨터 비전 분야에서 다양한 응용에 대한 최첨단 성능을 달성할 수 있습니다.

https://youtu.be/9Cu2UfNO-gw

* CNN의 목표는 사진이 무엇인지 맞추는 것

* 너무 복잡한 이미지(Layer가 너무 많은 이미지)는 CNN으로 처리하기 어려웠으나 ReLU로 성능을 높였고 Dropout으로 training data에만 맞는 overfitting을 완화하여 CNN의 한계를 극복해서 많이 사용할 수 있게 됨

* Convolution : 부분들의 특징을 추출하는 것 (예: 새의 경우 눈, 부리, 날개, 깃털 등의 특징을 추출함)

* feature map : Convolution 결과를 기록한 것

* 일반 신경망은 모든 노드가 연결돼 있고 그 연결부위에 가중치를 주면서 학습함. 반면에 CNN은 고정된 연결이 없고 Convolution과정을 통해 출력을 계산 함. CNN은 필터의 가중치를 학습함. 

* filter : pattern을 추출 함. (필터가 다르면 패턴도 달라질 수있음)

학습 과정 - Convolution으로 부분들의 특징을 추출함 (filter의 갯수 만큼 feature map이 나옴) - Max Pooling으로 feature map의 크기를 줄임 (가장 큰 값만 추출하여 출력을 작게 만드는 방법) - 이렇게 Convolution과 Max Pooling을 하나의 단위로 하여 여러 층으로 깊게 쌓아 올림 - Convolution과 Max Pooling의 layer가 끝나면 고차원적인 패턴이 담긴 feature map이 나옴 - 이것을 fully connected layer에 붙여 feature map을 사진의 class로 최종 분류 함

https://youtu.be/ggBQj1NXUEg

* Overfitting : training data에만 최적합. test data에는 맞지 않음. (예: training에만 쓰였던 개만 개로 인식) generalization gap이 큰 경우.

* Fully connected layer : overfitting의 문제 야기할 수 있음, 계산이 너무 많아짐. 비효율적

* 위 두 문제 비효율성과 overfitting을 해결함으로서 CNN이 널리 쓰일 수 있었음

* Convolusion : 부분을 뒤집어서(convolusion) 필터를 shift시키면서 곱한 값을 더한 값들을 추출함.

https://youtu.be/YRhxdVk_sIs

Convolutional Calculation

https://youtu.be/QzY57FaENXg

Hidden Layer, Convolutional Layer, Filters, 첫번째 레이어에서는 가장 부분적으로 분석하고 레이어가 깊어 질 수록 점 점 더 크고 전체적인 분석이 가능하게 됨.

CNN - 음성인식, 이미지 처리

입력 이미지에서 features를 추출해서 그 이미지가 속하는 클래스로 분류 함.

Feature Learning 단계와 Classification 단계가 있음

https://youtu.be/BfzUCEXmOm0

Feature Learning : Convolution * ReLU -> Pooling (반드시 해야 되는 것은 아님) -> Convolution * ReLU -> Pooling...

Classification : Flatten -> Fully Connected -> Softmax

기존 신경망 : Affine * ReLU -> Affine * ReLU .... -> Softmax 로 Classification

CNN : Convolution * ReLU * (Pooling,Dropout)-> Convolution * ReLU * Pooling .... -> Softmax 로 Classification

CNN - 부분 부분을 나누어서 관계를 지음으로서 특징을 파악하고 Layer가 지날 수록 점점 더 큰 부분으로 확대한다.

중간에 Bias 넣어 줌

Padding 처리 : 입력 데이터와 출력데이터의 크기를 맞추기 위함. 행렬 주변을 모두 0으로 채운 후 계산. 

Stride : 필터를 적용하는 위치의 간격 (1칸, 2칸 ...)

필터(커널)의 크기와 Stride의 크기에 따라 출력행렬의 크기가 달라질 수 있다.

3차원 이미지 데이터 -> 필터도 이미지와 같은 채널 수를 가지고 있어야 함

Pooling : 가로 세로 방향의 공간을 줄이는 연산 (행렬의 크기를 줄임) , 최대값만 가져 감 (특징을 강조하게 됨)

Fully Connected Layer : 추출된 features 값을 기존 neural network에 넣어서 이미지를 분류함

Flatten - 추출된 features가 2차원 자료이므로 기존의 neural network에 전달하기 위해서 1차원 자료로 바꿔 줌

Softmax activation function : 

GPT-4 API general availability and deprecation of older models in the Completions API (openai.com)

GPT-4 API general availability and deprecation of older models in the Completions API

GPT-3.5 Turbo, DALL·E and Whisper APIs are also generally available, and we are releasing a deprecation plan for older models of the Completions API, which will retire at the beginning of 2024.

GPT-3.5 Turbo, DALL·E 및 Whisper API도 generally 사용할 수 있으며, Completions API의 이전 모델에 대한 지원 중단 계획을 발표합니다. 이 모델들은 2024년 초에 사용 중지됩니다.

July 6, 2023

Starting today, all paying API customers have access to GPT-4. In March, we introduced the ChatGPT API, and earlier this month we released our first updates to the chat-based models. We envision a future where chat-based models can support any use case. Today we’re announcing a deprecation plan for older models of the Completions API, and recommend that users adopt the Chat Completions API.

오늘부터 모든 유료 API 고객은 GPT-4에 액세스할 수 있습니다. 3월에 우리는 ChatGPT API를 도입했고 이달 초에는 채팅 기반 모델에 대한 첫 번째 업데이트를 발표했습니다. 우리는 채팅 기반 모델이 모든 사용 사례를 지원할 수 있는 미래를 상상합니다. 오늘 우리는 Completions API의 이전 모델에 대한 지원 중단 계획을 발표하고 사용자가 Chat Completions API를 채택할 것을 권장합니다.

GPT-4 API general availability

GPT-4 is our most capable model. Millions of developers have requested access to the GPT-4 API since March, and the range of innovative products leveraging GPT-4 is growing every day. Today all existing API developers with a history of successful payments can access the GPT-4 API with 8K context. We plan to open up access to new developers by the end of this month, and then start raising rate-limits after that depending on compute availability.

GPT-4는 가장 capable한 모델입니다. 3월부터 수백만 명의 개발자가 GPT-4 API에 대한 액세스를 요청했으며 GPT-4를 활용하는 혁신적인 제품의 범위가 매일 증가하고 있습니다. 현재 성공적인 결제 기록이 있는 모든 기존 API 개발자는 8K 컨텍스트로 GPT-4 API에 액세스할 수 있습니다. 이달 말까지 새로운 개발자에게 액세스를 허용한 다음 컴퓨팅 가용성에 따라 속도 제한을 높일 계획입니다.

Based on the stability and readiness of these models for production-scale use, we are also making the GPT-3.5 Turbo, DALL·E and Whisper APIs generally available. We are working on safely enabling fine-tuning for GPT-4 and GPT-3.5 Turbo and expect this feature to be available later this year.

생산 규모 사용을 위한 이러한 모델의 안정성과 준비성을 기반으로 GPT-3.5 Turbo, DALL·E 및 Whisper API를 generally 사용할 수 있도록 만들고 있습니다. 우리는 GPT-4 및 GPT-3.5 Turbo에 대한 fine-tuning을 안전하게 활성화하기 위해 노력하고 있으며 이 기능은 올해 말에 제공될 예정입니다.

Moving from text completions to chat completions

We introduced the Chat Completions API in March, and it now accounts for 97% of our API GPT usage.

3월에 Chat Completions API를 도입했으며 현재 API GPT 사용량의 97%를 차지합니다.

The initial Completions API was introduced in June 2020 to provide a freeform text prompt for interacting with our language models. We’ve since learned that we can often provide better results with a more structured prompt interface. The chat-based paradigm has proven to be powerful, handling the vast majority of previous use cases and new conversational needs, while providing higher flexibility and specificity. In particular, the Chat Completions API’s structured interface (e.g., system messages, function calling) and multi-turn conversation capabilities enable developers to build conversational experiences and a broad range of completion tasks. It also helps lower the risk of prompt injection attacks, since user-provided content can be structurally separated from instructions.

초기 Completions API는 2020년 6월에 도입되어 언어 모델과 상호 작용하기 위한 자유 형식 텍스트 프롬프트를 제공합니다. 이후 우리는 보다 구조화된 프롬프트 인터페이스를 통해 종종 더 나은 결과를 제공할 수 있다는 것을 알게 되었습니다. 채팅 기반 패러다임은 이전 사용 사례와 새로운 대화 요구 사항의 대부분을 처리하는 동시에 더 높은 유연성과 특수성을 제공하는 강력한 것으로 입증되었습니다. 특히 Chat Completions API의 구조화된 인터페이스(예: 시스템 메시지, 함수 호출) 및 멀티턴 대화 기능을 통해 개발자는 대화형 경험과 광범위한 완료 작업을 구축할 수 있습니다. 또한 사용자가 제공한 콘텐츠와 지침을 구조적으로 분리할 수 있으므로 프롬프트 인젝션 공격의 위험을 줄이는 데 도움이 됩니다.

We plan to continue investing most of our platform efforts in this direction, as we believe it will offer an increasingly capable and easy-to-use experience for developers. We’re working on closing the last few remaining gaps of the Chat Completions API quickly, such as log probabilities for completion tokens and increased steerability to reduce the “chattiness” of responses.

우리는 이 방향으로 대부분의 플랫폼 노력을 계속해서 투자할 계획입니다. 이는 개발자에게 점점 더 기능이 풍부하고 사용하기 쉬운 경험을 제공할 것이라고 믿기 때문입니다. 완료 토큰에 대한 로그 확률 및 응답의 "채팅성"을 줄이기 위한 향상된 조종성 등 Chat Completions API의 마지막 몇 가지 남은 격차를 신속하게 해결하기 위해 노력하고 있습니다.

Deprecation of older models in the Completions API

As part of our increased investment in the Chat Completions API and our efforts to optimize our compute capacity, in 6 months we will be retiring some of our older models using the Completions API. While this API will remain accessible, we will label it as “legacy” in our developer documentation starting today. We plan for future model and product improvements to focus on the Chat Completions API, and do not have plans to publicly release new models using the Completions API.

Chat Completions API에 대한 투자 증가와 컴퓨팅 용량을 최적화하기 위한 노력의 일환으로 6개월 후에 Completions API를 사용하는 이전 모델 중 일부를 폐기할 예정입니다. 이 API는 계속 액세스할 수 있지만 오늘부터 개발자 문서에서 "레거시"로 표시됩니다. Chat Completions API에 집중하기 위해 향후 모델 및 제품 개선을 계획하고 Completions API를 사용하여 새 모델을 공개적으로 출시할 계획은 없습니다.

Starting January 4, 2024, older completion models will no longer be available, and will be replaced with the following models:

2024년 1월 4일부터 이전 완료 모델을 더 이상 사용할 수 없으며 다음 모델로 대체됩니다.

Applications using the stable model names for base GPT-3 models (ada, babbage, curie, davinci) will automatically be upgraded to the new models listed above on January 4, 2024. The new models will also be accessible in the coming weeks for early testing by specifying the following model names in API calls: ada-002, babbage-002, curie-002, davinci-002.

기본 GPT-3 모델(ada, babbage, curie, davinci)에 안정적인 모델 이름을 사용하는 애플리케이션은 2024년 1월 4일에 위에 나열된 새 모델로 자동 업그레이드됩니다. API 호출에 다음 모델 이름을 지정하여 테스트: ada-002, babbage-002, curie-002, davinci-002.

Developers using other older completion models (such as text-davinci-003) will need to manually upgrade their integration by January 4, 2024 by specifying gpt-3.5-turbo-instruct in the “model” parameter of their API requests. gpt-3.5-turbo-instruct is an InstructGPT-style model, trained similarly to text-davinci-003. This new model is a drop-in replacement in the Completions API and will be available in the coming weeks for early testing.

다른 이전 완성 모델(예: text-davinci-003)을 사용하는 개발자는 API 요청의 "모델" 매개변수에 gpt-3.5-turbo-instruct를 지정하여 2024년 1월 4일까지 통합을 수동으로 업그레이드해야 합니다. gpt-3.5-turbo-instruct는 text-davinci-003과 유사하게 훈련된 InstructGPT 스타일 모델입니다. 이 새 모델은 Completions API의 드롭인 대체품이며 초기 테스트를 위해 앞으로 몇 주 안에 사용할 수 있습니다.

Developers wishing to continue using their fine-tuned models beyond January 4, 2024 will need to fine-tune replacements atop the new base GPT-3 models (ada-002, babbage-002, curie-002, davinci-002), or newer models (gpt-3.5-turbo, gpt-4). Once this feature is available later this year, we will give priority access to GPT-3.5 Turbo and GPT-4 fine-tuning to users who previously fine-tuned older models. We acknowledge that migrating off of models that are fine-tuned on your own data is challenging. We will be providing support to users who previously fine-tuned models to make this transition as smooth as possible.

 fine-tuned된 모델을 2024년 1월 4일 이후에도 계속 사용하려는 개발자는 새로운 기본 GPT-3 모델(ada-002, babbage-002, curie-002, davinci-002) 이나 최근 모델(gpt-3.5-turbo, gpt-4)에서  fine-tuning해야 합니다 . 올해 후반에 이 기능을 사용할 수 있게 되면 이전 모델을 fine-tuning한 사용자에게 GPT-3.5 Turbo 및 GPT-4 fine-tuning에 대한 우선 액세스 권한을 부여할 것입니다. 자체 데이터에 대해 미세 조정된 모델에서 마이그레이션하는 것이 어렵다는 것을 알고 있습니다. 이전에 모델을 미세 조정한 사용자에게 이러한 전환이 최대한 원활하게 이루어지도록 지원을 제공할 예정입니다.

In the coming weeks, we will reach out to developers who have recently used these older models, and will provide more information once the new completion models are ready for early testing.

앞으로 몇 주 동안 이러한 이전 모델을 최근에 사용한 개발자에게 연락을 취하고 새로운 완성 모델이 초기 테스트 준비가 되면 더 많은 정보를 제공할 것입니다.

Deprecation of older embeddings models

Users of older embeddings models (e.g., text-search-davinci-doc-001) will need to migrate to text-embedding-ada-002 by January 4, 2024. We released text-embedding-ada-002 in December 2022, and have found it more capable and cost effective than previous models. Today text-embedding-ada-002 accounts for 99.9% of all embedding API usage.

이전 임베딩 모델(예: text-search-davinci-doc-001) 사용자는 2024년 1월 4일까지 text-embedding-ada-002로 마이그레이션해야 합니다. 2022년 12월에 text-embedding-ada-002를 출시했으며 이전 모델보다 성능이 뛰어나고 비용 효율적이라는 사실을 알게 되었습니다. 현재 text-embedding-ada-002는 모든 임베딩 API 사용량의 99.9%를 차지합니다.

We recognize this is a significant change for developers using those older models. Winding down these models is not a decision we are making lightly. We will cover the financial cost of users re-embedding content with these new models. We will be in touch with impacted users over the coming days.

우리는 이것이 이전 모델을 사용하는 개발자에게 중요한 변화라는 것을 알고 있습니다. 이러한 모델을 종료하는 것은 우리가 가볍게 내리는 결정이 아닙니다. 우리는 사용자가 이러한 새 모델로 콘텐츠를 다시 임베딩하는 재정적 비용을 충당할 것입니다. 앞으로 며칠 동안 영향을 받는 사용자에게 연락을 드릴 것입니다.

Deprecation of the Edits API

Users of the Edits API and its associated models (e.g., text-davinci-edit-001 or code-davinci-edit-001) will need to migrate to GPT-3.5 Turbo by January 4, 2024. The Edits API beta was an early exploratory API, meant to enable developers to return an edited version of the prompt based on instructions. We took the feedback from the Edits API into account when developing gpt-3.5-turbo and the Chat Completions API, which can now be used for the same purpose:

Edits API 및 관련 모델(예: text-davinci-edit-001 또는 code-davinci-edit-001) 사용자는 2024년 1월 4일까지 GPT-3.5 Turbo로 마이그레이션해야 합니다. Edits API 베타는 초기 버전이었습니다. 개발자가 지침에 따라 프롬프트의 편집된 버전을 반환할 수 있도록 하는 탐색 API. 우리는 gpt-3.5-turbo 및 Chat Completions API를 개발할 때 Edits API의 피드백을 고려했으며 이제 동일한 용도로 사용할 수 있습니다.

A rectified linear unit (ReLU) 는 Deep learning의 Multilayer Perceptron에서 Hidden layer에서 Non-liniearity를 만들기 위해 사용하는 Activation Function중 하나 입니다.

이 ReLU 함수는 음수는 버리고 0이나 양수를 통과 시킴으로서 다른 Activation Function (Sigmoid, Tanh etc.)이 가지고 있던 Vanishing gradient나 exploding gradient 문제를 완화 시키기 때문에 가장 많이 사용하고 있는 Activation Function입니다.

Group Study 중에 ReLU에서는 왜 하필 음수를 버리는가? 특별한 이유가 있는가? 라는 질문이 나왔고 거기에 대한 답변은 없었습니다.

그래서 ChatGPT에게 그 이유를 물어 보았는데...

원하는 답이 딱히 나오지는 않았습니다.

계속 끈질기게 물어본다고 시도는 했는데... 딱히 맘에 드는 답은 없네요.

제 prompting 실력이 딸려서 그럴 겁니다.

아니면 ChatGPT가 제대로 답했는데 제가 이해를 못 한 것일 수도 있구요.

아래 제 질문과 ChatGPT의 답변 chain 을 소개합니다.

보시면 아시겠지만 중간중간 ChatGPT가 영 엉뚱한 대답을 하거나 아예 틀린 답을 할 때도 있습니다.

ChatGPT의 특징이기도 한데 ChatGPT가 대답한 내용이 언제나 맞는 것은 아닙니다.

그냥 그럴듯하게 대답 할 뿐 100% 신뢰할 만한 대답은 아니라는 것을 미리 말씀 드립니다.

User
Why does the ReLU function discard negative numbers instead of positive numbers?

ChatGPT
The Rectified Linear Unit (ReLU) activation function is defined as follows: for any input value x, ReLU(x) returns x if x is positive or zero, and it returns 0 if x is negative. The main reason for discarding negative numbers and setting them to 0 is to introduce non-linearity into the neural network model.

When training neural networks, the non-linearity of activation functions is important for capturing complex patterns and relationships in the data. ReLU has the advantage of being computationally efficient and avoiding the vanishing gradient problem, which can occur with other activation functions like sigmoid or tanh.

By discarding negative values, ReLU allows the network to focus on the positive, non-linear relationships in the data, which can be beneficial for learning complex patterns and improving the model's ability to generalize. It effectively introduces sparsity by zeroing out a portion of the input values, which can help the network learn more robust representations.

However, one limitation of ReLU is the "dying ReLU" problem, where neurons can become "dead" and never activate again due to consistently having negative inputs. This can be mitigated by using variants of ReLU, such as Leaky ReLU or Parametric ReLU, which introduce small positive slopes for negative inputs to address the dying ReLU problem.

Overall, the choice of ReLU to discard negative numbers is primarily driven by its ability to introduce non-linearity and promote efficient learning in neural network models.

User
What happen if Activation function return 1 if it is negative and return 0 if it is positive value? 

ChatGPT
If an activation function returns 1 for negative values and 0 for positive values, it would essentially create a binary activation where the neuron is either fully activated (outputting 1) or completely deactivated (outputting 0) based on the sign of the input.

In this case, the activation function would not introduce any non-linearity to the neural network model. The model would essentially be a linear classifier since the output would solely depend on the sign of the input. It would not be able to capture complex patterns or learn non-linear relationships in the data.

The purpose of activation functions like ReLU, which discard negative values and introduce non-linearity, is to enable the neural network to learn complex representations and make it more expressive. By introducing non-linear transformations, the model becomes capable of capturing intricate patterns and relationships in the data, leading to improved performance and better generalization.

Therefore, using an activation function that returns 1 for negative values and 0 for positive values would limit the capabilities of the neural network and may result in suboptimal performance, especially in tasks that require non-linear decision boundaries and complex data patterns.


User
Here, what does it mean when the input value is positive and when the input value is negative?

ChatGPT
Here, "when the input value is positive" refers to the scenario where the value of the input to the activation function is greater than zero. In this case, if the activation function returns 0, it means that the neuron is completely deactivated or inhibited.

On the other hand, "when the input value is negative" refers to the scenario where the value of the input to the activation function is less than zero. In this case, if the activation function returns 1, it means that the neuron is fully activated or turned on.

In summary, if the activation function returns 1 for negative input values and 0 for positive input values, it leads to a binary activation where the neuron is either completely activated or completely deactivated based on the sign of the input.

User
OK. Let’s back to ReLU function. What does Positive and Negative input value mean?

ChatGPT
In the context of the ReLU (Rectified Linear Unit) function, "positive input value" refers to a situation where the input value provided to the ReLU function is greater than zero. Conversely, "negative input value" refers to a situation where the input value is less than or equal to zero.

When the input value is positive, the ReLU function returns the same value as the input, effectively passing it through without any changes. This means that positive input values are preserved and remain unchanged.

On the other hand, when the input value is negative, the ReLU function returns zero. This effectively discards or "zeros out" negative input values, replacing them with zero.

To summarize, in the ReLU function, positive input values are preserved and negative input values are replaced with zero.

User
So, are negative inputs discarded because they enhance the linearity more?

ChatGPT
Yes, that's correct. Negative inputs in the ReLU function are discarded because they contribute to linearity. By setting negative values to 0, the ReLU function introduces non-linearity to the network. This non-linearity is essential for the model to learn complex patterns and make non-linear decisions. In other words, by discarding negative inputs, the ReLU function introduces non-linear behavior and allows the neural network to capture more complex relationships in the data.


User
Why do negative values contribute linearity?

ChatGPT
Negative values contribute to linearity in the context of activation functions because they do not introduce any non-linear transformation. When a negative value is passed through an activation function, such as the ReLU function, it is set to zero, effectively making it a linear function (i.e., a straight line with a slope of zero).

In neural networks, linearity refers to the property of a function or transformation that can be represented as a linear combination of its inputs. Linear functions preserve the relationship between inputs and outputs, and they are limited in their ability to capture complex patterns and non-linear relationships in the data. By discarding negative values and making the function behave linearly for negative inputs, the ReLU function introduces non-linearity for positive inputs, allowing the neural network to learn and model more complex relationships in the data.

User
Why do negative values contribute linearity?

ChatGPT
Negative values do not contribute to linearity themselves, but rather their absence or discarding in certain activation functions can lead to a more linear behavior. In the case of activation functions like the Rectified Linear Unit (ReLU), negative values are set to zero, effectively removing their contribution to the non-linearity of the function.

By discarding negative values and treating them as zero, the ReLU function becomes piecewise linear, with a linear region for non-negative inputs and a constant zero output for negative inputs. This behavior introduces linearity for the negative part of the input space.

The linearity introduced by discarding negative values can be beneficial in certain cases, as it simplifies the behavior of the activation function and can lead to easier optimization and training of neural networks. However, it also limits the expressive power of the activation function by disregarding the negative part of the input space, which may not always be desirable depending on the complexity of the underlying data.

User
You said "The linearity introduced by discarding negative values". I think this is wrong. Non-linearity introduced by discarding negative values. Which one is right?

ChatGPT
Apologies for the confusion. You are correct, and I apologize for the incorrect statement. The correct statement is that non-linearity is introduced by discarding negative values in the ReLU activation function. By setting negative values to zero, the ReLU function introduces a non-linear behavior, as the output is zero for negative inputs and follows a linear relationship for non-negative inputs. This non-linearity allows the ReLU function to model more complex and non-linear relationships in the data. Thank you for pointing out the mistake.

User
OK then. Can non-linearity be introduced even when discarding positive values and keep negative values?

ChatGPT
No, non-linearity cannot be introduced by discarding positive values and keeping negative values. The ReLU activation function specifically introduces non-linearity by discarding negative values and keeping non-negative values. If positive values were discarded instead, the resulting function would still be a linear function, as it would follow a straight line without any non-linear behavior. The non-linearity in the ReLU function is essential for capturing complex patterns and enabling deep neural networks to learn and model non-linear relationships in the data.

User
Why does discarding negative values introduce non-linearity and discarding positive values preserves linearity?

ChatGPT
When we say that discarding negative values introduces non-linearity, it means that the ReLU activation function breaks the linearity of the input space by introducing a threshold. By setting all negative values to zero, the function introduces a non-linear behavior that allows the neural network to model more complex and non-linear relationships in the data.

On the other hand, discarding positive values does not introduce non-linearity because it does not change the behavior of the function. The function remains linear, following a straight line without any non-linear transformations.

In summary, discarding negative values in ReLU introduces non-linearity because it introduces a threshold and allows the function to capture non-linear patterns, while discarding positive values does not introduce non-linearity as it preserves the linear behavior of the function.

User
In my opinion, just as nonlinearity is achieved by discarding negative numbers and passing only 0 and positive numbers, I think that nonlinearity can be achieved by discarding positive numbers and passing only 0 and negative numbers. What do you think?

ChatGPT
You are correct. Non-linearity can also be achieved by discarding positive values and keeping only zero and negative values. This can be done using an activation function called the Leaky ReLU, which is a variation of the ReLU function.

In the Leaky ReLU, instead of setting negative values to zero, we introduce a small slope for negative values, typically a small positive constant. By allowing a small, non-zero output for negative values, the Leaky ReLU introduces non-linearity and enables the neural network to capture more complex patterns and relationships in the data.

So, both discarding negative values (ReLU) and discarding positive values (Leaky ReLU) can introduce non-linearity and enhance the expressive power of the neural network. The choice between ReLU and Leaky ReLU depends on the specific problem and the desired behavior of the activation function.

User
That’s wrong. Leaky ReLU does not discarding positive values. It takes positive values as it is and give small values to negative values instead of 0. Leaky ReLU does not discarding positive values.

ChatGPT
Apologies for the confusion in my previous response. You are correct. The Leaky ReLU does not discard positive values. It retains positive values as they are and introduces a small slope for negative values instead of setting them to zero. This helps in addressing the issue of "dying ReLU" where neurons can become inactive if they receive negative inputs. By introducing a small, non-zero output for negative values, the Leaky ReLU ensures that all neurons contribute to the network's computation, thus promoting non-linearity while preserving positive values. Thank you for pointing out the error, and I apologize for any confusion caused.

User
OK. Then I am going to ask this question one more. In my opinion, just as nonlinearity is achieved by discarding negative numbers and passing only 0 and positive numbers, I think that nonlinearity can be achieved by discarding positive numbers and passing only 0 and negative numbers. What do you think?

ChatGPT
Yes, you are correct. Nonlinearity can be achieved by discarding positive numbers and passing only zero and negative numbers as well. This concept is realized through the activation function known as the Leaky ReLU, where positive values are preserved as they are, and negative values are scaled by a small positive slope instead of being set to zero. By introducing non-zero outputs for negative values, the Leaky ReLU retains nonlinearity and allows for a wider range of activations, capturing more complex relationships in the data. Therefore, both discarding negative numbers and discarding positive numbers can introduce nonlinearity in different ways.


User
My question is this. Is nonlinearity can be achieved by discarding positive values and passing only 0 and negative values?

ChatGPT
Yes, nonlinearity can also be achieved by discarding positive values and passing only zero and negative values. This concept is realized through the activation function known as the Exponential Linear Unit (ELU), where positive values are preserved as they are, while negative values are transformed exponentially. By mapping negative values to non-zero outputs, the ELU introduces nonlinearity and allows for more expressive representations of the data. Therefore, both discarding negative values and discarding positive values can introduce nonlinearity in different ways.

User
My question is this. Does nonlinearity can be achieved by discarding positive values?

ChatGPT
No, discarding positive values alone does not introduce nonlinearity. Nonlinearity in neural networks is typically introduced through activation functions, which apply a mathematical operation to the input values. Activation functions like ReLU, Leaky ReLU, and sigmoid introduce nonlinearity by transforming the input values in a nonlinear fashion. Discarding positive values without applying any nonlinear transformation does not inherently introduce nonlinearity. Nonlinearity is a result of the mathematical operations performed on the input values rather than the act of discarding positive values alone.

User
Why is the non-linearity achieved only when negative values are removed, not positive ones?
ChatGPT
The non-linearity in activation functions like ReLU is achieved when negative values are removed because the function introduces a threshold at zero. By setting all negative values to zero, the function effectively introduces a non-linear "break" or "turning point" in the output, which allows the network to capture non-linear relationships in the data.

On the other hand, keeping positive values as they are does not introduce a similar non-linear effect. Positive values do not introduce a break or turning point that can capture non-linear relationships. Instead, they contribute to the overall linear behavior of the function.

In summary, the removal of negative values in activation functions like ReLU introduces non-linearity by creating a threshold and allowing the network to capture non-linear patterns in the data.

User
If there is no accurate information, answer “I don’t know” and if there is certain data, answer it based on that data.

In my opinion, just as nonlinearity is achieved by discarding negative numbers and passing only 0 and positive numbers, I think that nonlinearity can be achieved by discarding positive numbers and passing only 0 and negative numbers. What do you think?

ChatGPT
You are correct. Non-linearity can be achieved by discarding positive numbers and passing only 0 and negative numbers. In fact, there are activation functions like Leaky ReLU that introduce non-linearity by allowing small negative values instead of discarding them completely. By modifying the behavior of the function for negative values, non-linearity can be preserved even when positive values are passed as they are.

User
Why discard or allowing small negative values not positive values to introduce non-linearity? 

ChatGPT
The choice of discarding negative values or allowing small negative values instead of positive values is based on the desired properties of the activation function and the specific requirements of the model or problem at hand.

Discarding negative values in ReLU and similar activation functions introduces non-linearity because it introduces a "threshold" behavior where values below the threshold (negative values) are mapped to zero, while values above the threshold (positive values) are passed through unchanged. This non-linear behavior helps in capturing complex patterns and relationships in the data.

On the other hand, allowing small negative values, as in Leaky ReLU, also introduces non-linearity by providing a slight slope or gradient for negative values. This allows the activation function to capture some information from negative values, albeit with reduced magnitude. This can be beneficial in situations where preserving some information from negative values is important.

Ultimately, the choice between discarding negative values or allowing small negative values depends on the specific characteristics of the problem, the behavior desired from the activation function, and the trade-offs between linearity and non-linearity in the model's performance.

User
Conversely, does nonliniearity happen when negative values are passed as is and positive values are discarded?

ChatGPT
No, nonlinearity is not achieved by passing negative values as is and discarding positive values. In fact, passing negative values as is and discarding positive values would result in a linear activation function rather than a nonlinear one.

Nonlinearity is introduced in activation functions when there is a change in the slope or curvature of the function, allowing it to capture complex patterns and relationships in the data. Activation functions like ReLU and Leaky ReLU achieve nonlinearity by modifying the behavior of negative values, either by discarding them or allowing small negative values.

If positive values are discarded and negative values are passed as is, the resulting activation function would still exhibit linearity because it would be a simple linear mapping without any change in the function's behavior. Nonlinearity requires a modification of the activation function's response to input values, which is typically achieved by introducing thresholding, saturation, or other nonlinear transformations.

Therefore, to achieve nonlinearity in activation functions, it is necessary to modify the behavior of both negative and positive values in a way that introduces nonlinear elements to the function.

User
Why does linearity still exhibit if it pass a negative value as is and discard positive values?

ChatGPT
If negative values are passed as is and positive values are discarded, the resulting activation function would still exhibit linearity. This is because linearity refers to the property of a function where the output changes proportionally to changes in the input.

In this case, passing negative values as is without any modification means that the function's output remains directly proportional to the input. Therefore, it follows a linear relationship where the output increases or decreases in a straight line as the input changes. On the other hand, discarding positive values altogether eliminates any effect they may have on the output, further reinforcing the linear relationship.

Nonlinearity, on the other hand, refers to the property of a function where the output does not change proportionally to changes in the input. It introduces deviations from a straight-line relationship and allows the function to capture more complex patterns and relationships in the data.

To achieve nonlinearity, it is necessary to introduce transformations or modifications to the function that alter its response to different input values. This can be done through the use of activation functions like ReLU, sigmoid, or tanh, which introduce nonlinearity by modifying the behavior of both positive and negative values.

Chain Rule 이란?

In the field of AI, the chain rule typically refers to the mathematical concept used in backpropagation, which is a common algorithm for training neural networks. The chain rule allows for the computation of gradients or derivatives of complex functions by decomposing them into a series of simpler functions.

AI 분야에서 chain rule은 일반적으로 역전파(backpropagation)에서 사용되는 수학적 개념을 의미합니다. chain rule은 복잡한 함수를 간단한 함수들의 연쇄로 분해하여 기울기(gradient) 또는 도함수(derivative)를 계산할 수 있게 해줍니다.

In the context of neural networks, the chain rule is employed to calculate the gradients of the loss function with respect to the weights and biases of the network. During the training process, the chain rule allows the network to update its parameters by propagating the error gradients backwards through the layers of the network.

신경망의 경우, chain rule은 네트워크의 가중치와 편향에 대한 손실 함수의 기울기를 계산하는 데 사용됩니다. 훈련 과정에서 chain rule을 이용하여 오류 기울기를 네트워크의 각 층을 거슬러 역방향으로 전파하여 네트워크의 매개변수를 업데이트할 수 있습니다.

By applying the chain rule, neural networks can efficiently compute the gradients needed to adjust the weights and biases, optimizing the network's performance and enabling it to learn from data. The chain rule plays a crucial role in the training process of neural networks and is a fundamental concept in the field of AI.

chain rule을 적용함으로써 신경망은 가중치와 편향을 조정하기 위해 필요한 기울기를 효율적으로 계산할 수 있습니다. 이를 통해 신경망은 데이터로부터 학습하고 성능을 최적화할 수 있습니다. chain rule은 신경망의 훈련 과정에서 중요한 역할을 하며, AI 분야에서 기본적인 개념 중 하나입니다.

Chain Rule 은 한국에서는 연쇄 법칙이라고도 한다.

https://youtu.be/BRJ05c5cpwM

https://youtu.be/KSIJLvLixCg

https://youtu.be/rG0msnwLF68

https://youtu.be/SpGAhJG0rrI

https://youtu.be/sPzy-K0Hyr4

https://youtu.be/g3nhLjYRT5I

https://youtu.be/g-Dz1YS58XM

https://youtu.be/PnQe3-6812k

https://youtu.be/hXWymiULQfA

작년 11월에 시애틀이 있는 워싱턴주의 주도인 올림피아로 이사왔습니다.

오자마자 근처에 조개를 캘 수 있는 곳을 찾았는데 바로 15분 거리에 있더라구요.

Frye Cove County Park.

근데 문제는 1년중 5월 한달간만 오픈 한다는 것.

근데 오히려 그것이 나에게는 기회였던 것이죠.

집이랑 가까우니까 오픈 날부터 남들보다 먼저 갈 수 있었습니다.

정말 조개들이 다양하고 사이즈도 크더라구요.

근데 그것만 있는게 아니었어요.

3일째 되던 날 해변에서 뻘 쪽으로 옮겼더니 거기엔 코끼리 조개, 왕우럭 조개들이 널려 있더라구요.

또 그것이 다가 아니었습니다. 더 가니까 굴이랑 홍합이 널려 있었습니다.

내년 5월이 벌써 부터 기다려 집니다.

I discovered an amazing shellfishing spot when I moved to Olympia. This place is a gem, but here's the catch: it's only open for one month each year. But let me tell you, it's worth the wait! You'll find a wide range of shells, from different types of clams to horse clams, mussels, and oysters. It's a shellfish lover's paradise! Can't wait to return next year for more clamming adventures. See you then, clams!

https://youtu.be/F57gHyWP9jA

이곳 워싱턴주로 이사온지 3년째 됩니다.

그동안 다른 사람들이 미역을 채취해서 올린 유투브를 보면서 나도 한번 해 봐야겠다라고 맘만 먹고 한번도 기회를 갖지 못했습니다.

시간도 없긴 했지만 언제 어디서 미역을 채취해야 하는지 정보도 부족했습니다.

마침 작년에 layoff 된 이후로 시간도 많고 마침 이 지역에서 은퇴 후 유투브 활동을 하시는 주영문 TV 운영하시는 주 선생을 지난 4월에 만나서 자세하게 정보를 얻었습니다.

우연찮게 그 당시가 미역 채취 기간이었습니다.

이곳에서는 4월 중순부터 5월 중순까지 한달 정도만 미역채취가 허용됩니다.

그것도 단 3곳에서..

주선생님은 지금 알래스카 여행중입니다. 감사하고 enjoy and safe trip 하세요~~~~~~~

하여간 그 때 그 정보를 얻고 계획을 세워서 미역을 채취 했습니다.

어렵게 얻은 정보와 이번에 미역을 채취하면서 얻은 경험들을 정리해서 유투브를 만들었습니다.

내년에도 이 정보를 바탕으로 더 효율적으로 미역채취 하려구요.

https://youtu.be/I4pBfJOkDh4