😶 초록 (Abstract)

- ImageNet에서 120만개의 고해상도 image를 대상으로 1000개의 클래스를 분류하는 문제에 대해 좋은 결과를 내었음

- 6000만개의 parameter와 650,000여개의 뉴런 [5개의 CONV 층(maxpool), 3개의 FullyConnected 층(마지막은 1000개 클래스를 구분하는 softmax층)]으로 구성
- training을 빨리 하기 위해 포화되지 않은(non-saturating) 뉴런들과 효과적인 GPU를 사용
- overfitting을 줄이기(reduce)위해 dropout(매우 효과적으로 증명된 regularized method)을 사용

- ILSVRC-2012 대회에서 2등인 26.2%에 비해 15.3%의 error rate를 성취하였음
(Imagenet Large-scale Visual Recognition Challenge)

 

 

 

1. 서론 (Introduction)

- 현재 사물인식에서 기계학습(machine learning)방식의 사용은 필수적이다.
- 이를 위해 다음과 같은 방법으로 향상을 시키는데, 더 많은 데이터셋, 강력한 모델 및 더 좋은 과적합을 막는 기술등이 있다.
과거, MNIST와 같은 데이터들은 적은 양으로도 가능하였지만 현실에서는 상당히 다양하며(considerable variablility) 따라서 더 많은 training set을 필요로 하는 것은 필수불가결한 사항이 되어버렸다.

- 수많은 사물을 구분하려면 많은 학습능력을 지녀야 한다.
하지만, 사물인식의 거대한 복잡도의 문제는 ImageNet같은 거대한 dataset에서 명시될 수 없다는 점이다.

- 학습능력은 depth와 breadth를 다양화하면서 조정할 수 있는데, feedforward neural network와 비교했을 때, CNN은 더 적은 연결과 parameter를 갖기에 train하기 쉽고 이론적으로 최상의 효과를 약간의 단점만으로 낼 수 있다.

 

 

 

2. The Dataset

- ImageNet을 이용했는데, ImageNet은 22,000개의 카테고리, 1500만개의 라벨링된 고해상도의 사진으로 이루어져 있다.
- 따라서 image를 down-sample하여 해상도를 256X256으로 맞춰 image를 rescale하였다.
- raw RGB의 pixel로 train을 진행하였다.

 

 

 

3. The Architecture

 

3.1 ReLU Nonlinearity

- Deep CNN에서 tanh unit의 사용보다 ReLU의 사용이 훨씬 빠르다는 것을 알 수 있다.
이런 빠른 학습은 큰 데이터셋을 갖는 large한 모델에 매우 훌륭한 영향을 준다.
위 그림에 대한 설명이다.
- 실선: 4개의 Conv층 (with relu), 6배 더 빠르다.
- 점선: 4개의 Conv층 (with tanh)
- ReLu는 지속적인 학습의 진행으로 saturating neuron보다 더 빠르게 학습한다.
우리는 여기서 미리 포화된(large neural net)뉴런 모델을 굳이 경험할 필요가 없음을 알 수 있다.

 

 

3.2 Training on Multiple GPUs

- single GTX 580 GPU 코어는 메모리가 3GB이기에 훈련가능한 신경망의 최대크기가 제한된다.
- 따라서 2개의 GPU에 신경망을 흩어뜨리는 GPU병렬화(parallelization scheme)를 이용한다.
- 이때, 2개의 GPU net이 1개의 GPU net보다 훈련에 더 적은 시간이 걸리고 오류율도 1.2~1.7%정도 감소시켰다.

 

 

3.3 Local Response Normalization

- ReLU는 포화(saturating)방지를 위한 입력 정규화를 필요로 하지 않는 바람직한 특성을 갖는다.
- ReLU는 local 정규화 일반화에 도움이 된다.

- 위의 식은 다음과 같이 해석된다.

 
kernel i의 위치 (x,y)를 적용해 계산된 뉴런의 activity이다.
여기에 ReLU의 비선형성을 적용한다.
 
이때, 합은 동일한 공간위치에서 n개의 '인접한(adjecent)' kernel map에 걸쳐 실행된다. (N은 layer의 총 kernel수)
kernel map의 순서는 training이 시작하기 전에 임의로(arbitrary) 결정된다.
이런 반응정규화(response normalization)의 종류는 영감을 받은(inspired) 측면억제(lateral inhibition)형태를 구현,
이를 통한 다른 커널의 사용으로 계산된 뉴런 출력간의 large activity에 대한 경쟁(competition)을 생성한다.

상수 k, n, α, β는 validation set을 사용하여 값이 결정되는 hyper-parameter로 각각 k = 2, n = 5, α = 10-4, β = 0.75를 사용하며 특정 layer에서 ReLU의 비선형성을 적용한 후 이 정규화를 적용했다(3.5 참조).

Jarrett의 local contrast normalization과 비슷하지만 mean activity를 빼지(subtract)않았기에
우리의 이 정규화를 'brightness normalization'이라 더 장확하게 부를 것이다. 

 

 

3.4 Overlapping Pooling

CNN에서의 pooling layer는 동일한 kernel map에서 '인접한(adjacent)' 뉴런 그룹의 output을 summarize한다.
보편적으로 adjacent pooling으로 요약되면 unit들이 겹치지 않는다.
즉, pooling layer는 픽셀들 사이에 s만큼의 간격을 둔 pooling unit들의 grid로 구성되며, 각각은 pooling unit의 위치를 중심으로 한 크기(zxz)의 neighbor를 요약한다.
만약 위에서의 s를 s = z로 설정하면 CNN에서 일반적으로 사용되는 보편적인 local pooling을 얻을 수 있으며, s < z를 설정하면 overlapping pooling을 얻을 수 있다.

이때문에 전반적인 신경망에서 s=2나 s=3으로 사용하는 것이다.
또한 일반적인 training에서는 overlapping pooling이 있는 모델이 모델을 과적합하기가 약간 더 어렵다는 것을 알 수 있다

 

 

 

3.5 Overall Architecture

총 8개의 weight를 갖는 layer로 구성되어 있다.
5개의 CONV (convolution layer)
- 3개의 FC (Fully-connected layer) + 마지막은 1000개의 클래스를 구분하는 softmax층

이 모델은 다항식 logistic regression 분석목표를 최대화 하는데, 이는 예측분포(prediction distribution)하에서 올바른 label의 log확률(log-probability)의 training cases에 대한 평균(average)을 최대화하는 것과 같다.

2, 4, 5번째의 CONV의 kernel은 동일한 GPU에 있는 이전 layer의 kernel map에만 연결된다. (아래그림 참조)
3번째 CONV는 2번째 CONV의 모든 kernel map들과 연결되며 완전히 연결된 층의 뉴런은 이전 층의 모든뉴런들과 연결된다.

response-normalization층들은 1, 2번째 CONV를 따르며 3.4절에 기술된 종류의 MaxPooling은 response-normalization layer와 5번째 CONV layer를 모두 따른다.

ReLU의 비선형성은 모든 CONV와 FC의 출력에 적용되며 첫 번째 CONV은 11×11×3의 96개의 kernel을 가지며
224×224×3(150,528 차원)의 input image를  stride=4로 filtering을 진행한다.
(신경망의 뉴런수는 다음과 같다. 150,528-253,440–186,624–64,896–64,896–43,264–4096–1000)

2번째 CONV는 첫번째 CONV의 출력을 입력으로 받아 5×5×48의 256개의 kernel로 filtering을 진행하며
3번째 CONV는 3×3×256의 384개의 kernel을 두번째 CONV output과 연결하고
4번째 CONV는 3×3×192의 384개의 kernel로,
5번째 CONV는 3×3×192의 256개의 kernel로 filtering하며
3, 4, 5번째 CONV는 어떠한 간섭(intervening)pooling과 normalization layer없이 서로 연결된다.

또한 FC (Fully-Connected layer)는 각각 4096개의 뉴런을 갖는다.

 

 

 

 

 

 

4. Reducing Overfitting

4.1 Data Augmentation

① image translation. &. horizontal reflection
- image translation:
한 도메인의 입력 이미지를 다른 도메인의 해당 이미지로 변환하는 것
- 이 방법을 통해 train에 상호의존적일 수 있고 이런 scheme이 없었다면 overfitting의 어려움을 겪었을 것이다.

② altering intensities of the RGB channels
- ImageNet의 training set 전체의 RGB픽셀값에 PCA를 수행
- 각 train image에 해당 eigenvalues(고유값)에 비례하는 크기와 평균 0, 표준편차 0.1을 갖는 zero-mean Gaussian 분포(정규분포)에서 도출된 random변수를 곱해 나온 주요 구성요소의 배수를 추가한다.

- 따라서 RGB 픽셀 Ixy =[IR , IG , IB ]T에 아래 값을 추가한다. 
- 이때, pi와 yi는 각각 RGB pixel의 3x3 covariance(공분산)행렬의 i번째 eigenvector와 eigenvalue이며 αi는 이전에 설명한  random 변수이다. 각 αi는 해당 이미지가 다시 훈련에 사용될 때까지 특정 훈련 이미지의 모든 픽셀에 대해 한 번만 그려지며, 이 시점에서 다시 그려진다.

 

 

4.2 Dropout

- Dropout은 전진의 기여도를 없애고 역전파를 관여하지 못하게 하는 방식으로 많고 다른 뉴런들의 부분집합을 random하게 결합시키는데 유용하다.
- 0.5의 비율로 FC의 처음 2개의 layer에 적용하였으며 dropout이 없으면 상당한 과적합을 보여주었다.

 

 

 

 

 

5. Details of Learning

- Optimizer: SGD (Stochastic  Gradient  Descent), momentum = 0.9,  weight decay = 0.0005
- Batch size: 128

i는 반복횟수, v는 momentum변수, ε은 Learning rate(학습율),

<-- wi에서 평가된 w의 미분(derivative)의 i번째 batch Di의 평균으로 Loss function의 기울기을 의미한다.


<초기화>
표준편차가 0.01인 zero-mean Gaussian 분포로 각 층의 weight를 초기화
2,4,5 CONV층과 FC층은 상수 1로 , 나머지 층은 0으로 bias를 초기화

validation error가 개선되지 않으면 학습율을 10으로 나눔 (0.01로 초기화 하였으며 종료전에 3배정도 감소하였음)

 

 

6. Results

- ILSVRC-2010에 대한 결과의 요약은 다음과 같다.

신경망은 37.5%와 17.0%5의 상위 1위와 상위 5위의 테스트 세트 오류율을 달성하는 것을 볼 수 있다.

ILSVRC-2010 경쟁에서 달성된 최고의 성능은 서로 다른 기능에 대해 훈련된 6개의 spase coding 모델에서 생성된 예측을 평균화하는 접근 방식으로 47.1%와 28.2%였다.
그 이후 가장 잘 발표된 결과는 Fisher Vectors (FVS)에 대해 훈련된 두 분류기의 예측을 평균화하는 접근 방식으로 45.7%와 25.7%였으며 두 가지 유형의 조밀하게 샘플링된 특징으로부터 계산되었다.

- 또한  ILSVRC-2012 대회에서의 결과는 다음과 같다.

단락(paragraph)의 나머지 부분에서는 검증 및 테스트 오류율이 0.1% 이상 차이가 나지 않기 때문에 서로 교환하여 사용한다.


이 논문에서 설명한 CNN은 다음과 같은 성과를 거두었다
상위 5위 이내의 오류율 18.2%. 5개의 유사한 CNN의 예측을 평균하면 16.4%의 오류율을 얻었다.

- 마지막 pooling layer에서 추가적으로 6차 컨볼루션 레이어가 있는 CNN 하나를 교육하여 ImageNet Fall 2011 release (15M images, 22K categories)를 분류한 다음 ILSVRC-2012에서 "미세 조정(fine-tuning)"하면 16.6%의 오류율을 얻을 수 있다. 앞서 언급한 5개의 CNN으로 2011년 가을 전체 릴리스에서 사전 훈련된 2개의 CNN의 예측을 평균하면 15.3%의 오류율을 얻을 수 있다. 두 번째로 우수한 콘테스트 항목은 다양한 유형의 조밀하게 샘플링된 기능에서 계산된 FV에 대해 훈련된 여러 분류기의 예측을 평균화하는 접근 방식으로 26.2%의 오류율을 달성했다.

- 마지막으로, 우리는 또한 10,184개의 범주를 가진 Fall 2009 version of ImageNet에 대한 오류율을 보고한다
그리고 890만 장의 이미지가 있는데, 이 dataset에서 우리는 학습을 위해 이미지의 절반을 사용하고 테스트를 위해 이미지의 절반을 사용하는 문헌의 관례를 따른다.
확립된 testset이 없기 때문에, 우리의 분할은 반드시 이전 저자들이 사용한 분할과 다르지만, 이것은 결과에 크게 영향을 미치지 않으며 이 dataset에서 상위 1위와 상위 5위의 오류율은 67.4%와 40.9%이며, 위에서 설명한 순으로 달성되나 마지막 pooling layer에 비해 6번째 컨볼루션 계층이 추가된다. 이 데이터 세트에 대한 가장 잘 알려진 결과는 78.1%와 60.9%이다.

 

6.1 Qualitative Evaluations

이 그림은 신경망의 두 data-connected layer에 의해 학습된 Convolution kernel을 보여준다.
신경망은 다양한 frequency 및 orientation-selective kernels 뿐만 아니라 다양한 색상 blob들을 사용한 것 또한 알 수 있다.

3.5에서 설명한 제한된 연결의 결과로 두 GPU가 보여주는 전문화에 주목한다. GPU 1의 커널은 대부분 색상에 구애받지 않는 반면 GPU 2의 커널은 대부분 색상에 따라 다르기에 이러한 종류의 전문화는 모든 실행 중에 발생하며 특정 random weight 초기화(GPU의 모듈로 번호 변경)와 무관하다.


위 사진의 왼쪽은 다음과 같다.
- 8개의 테스트 이미지에 대한 상위 5개 예측을 계산하여 신경망이 무엇을 배웠는지 정성적으로 평가(qualitatively assess)한다.
- 이때, 진드기(mite)같이 중심을 벗어난 물체도 net로 인식할 수 있다는 점을 유의해야 한다.
(상위 5개의 label은 대부분 합리적인 것으로 보인다.)

위 사진의 오른쪽 첫 번째 열에 5개의 ILSVRC-2010 테스트 영상으로 나머지 열은 테스트 이미지의 특징 벡터로부터 유클리드 거리(Euclidean distance)가 가장 작은 마지막 숨겨진 레이어에서 특징 벡터를 생성하는 6개의 훈련 이미지를 보여준다.

- 두 이미지가 작은 Euclidean separation으로 특징 활성화 벡터(feature activation vectors)를 생성할 때, 신경망의 고수준이 유사하다 간주한다고 할 수 있다.

- 그림은 testset의 5개 이미지와 이 측정에 따라 각 이미지와 가장 유사한 training set의 6개 이미지를 보여주는데, 픽셀 수준에서 검색된 교육 이미지는 일반적으로 첫 번째 열의 query image의 L2에서 가깝지 않다.
예를 들어, 회수된 개들과 코끼리들은 다양한 포즈로 나타나며 우리는 보충 자료에서 더 많은 train image에 대한 결과를 제시한다.

- 두 개의 4096차원 실제 값 벡터 사이의 Euclidean distance 사용하여 유사성을 계산하는 것은 비효율적이지만, 이러한 벡터를 짧은 이진 코드로 압축하도록 auto-encoder를 훈련시킴으로써 효율적으로 만들 수 있다.
이는 image label을 사용하지 않기에 의미적으로(semantically) 유사한지 여부에 관계없이 edge들과의 유사한 패턴을 가진 이미지를 검색하는 경향이 있는 raw-pixel에 auto-encoder를 적용하는 것보다 훨씬 나은 이미지 검색 방법을 생성해야 한다.

 

 

 

 

 

 

7. Discussion

- 크고 깊은 CNN이 기록을 깨는 좋은 결과를 내는 것을 알 수 있다.
- 또한 중간층을 일부 삭제하더라도 성능이 떨어지는 것을 알 수 있듯, 깊이가 정말로 우리의 결과를 이룩하는데 중요하다는 것을 알 수 있다.

- 실험을 단순화하기 위해, 특히 label이 지정된 데이터의 양에서 그에 상응하는 증가를 얻지 않고 신경망의 크기를 크게 늘릴 수 있는 충분한 계산 능력을 얻는 경우에 도움이 될 것으로 예상했음에도 불구하고 unsupervised pre-training을 사용하지 않았다.

 

 

 

 

 

 

🧐 논문 감상_중요개념 핵심 요약

"ImageNet Classification with Deep Convolutional Neural Networks"
Alex Krizhevsky, Ilya Sutskever 및 Geoffrey Hinton이 2012년에 발표한 연구 논문으로 이 논문은 2012년 ILSVRC(ImageNet Large Scale Visual Recognition Challenge)에서 최첨단 성능을 달성한 AlexNet이라는 심층 합성곱 신경망을 제안한다.

 

[핵심 개념]

1. Convolutional Neural Networks
Convolutional 및 Subsampling 층의 여러 layer로 구성된 Deep CNN Architecture와 Fully-Connected layer를 제안한다.

2. Rectified Linear Units(ReLU)
이 논문은 Sigmoid 및 tanh와 같은 기존 활성화 함수보다 더 간단하고 효율적인 ReLU 활성화 함수의 소개 및 활용을 진행한 최초의 논문이기에 더욱 중요하다고 볼 수 있다.

3. Local Response Normalization(LRN)
이 논문은 일종의 측면 억제(lateral inhibition)를 제공하여 일반화 성능을 개선하는 데 도움이 되는 LRN이라는 정규화 유형을 제안한다.

4. Dropout
이 논문은 과적합을 방지하기 위해 훈련 중에 일부 뉴런을 무작위로 제거하는 드롭아웃이라는 정규화 기술을 소개하였다.

5. Data Augmentation
이 논문은 training set의 크기를 늘리고 model의 견고성을 늘ㄹ리기 위해 random crop, vertical flip같은 기술을 사용했다.

6. State-of-the-Art Performance (최신 성능)
이 논문은 ILSVRC 2012 분류 작업에서 최신 성능을 달성하여 이전 방법보다 훨씬 뛰어난 성능을 보여준다.

전반적으로 이 논문은 Convolution신경망, ReLU 활성화 함수 및 데이터 증강의 사용과 같은 딥 러닝의 몇 가지 중요한 개념을 소개하고 까다로운 컴퓨터 비전 작업에서 최첨단 성능을 달성하는 데 있어 그 효과를 입증했다.

 

 

 

 

 

 

🧐  논문을 읽고 Architecture 생성 (with tensorflow)

import tensorflow as tf
from tensorflow.keras.layers import Input, Conv2D, MaxPooling2D, Flatten, Dense, Dropout

def AlexNet(input_shape, num_classes):
    input_layer = Input(shape=input_shape)
    
    # first convolutional layer
    x = Conv2D(96, kernel_size=(11,11), strides=(4,4), padding='valid', activation='relu')(input_layer)
    x = MaxPooling2D(pool_size=(3,3), strides=(2,2))(x)
    x = Dropout(0.25)(x)
    
    # second convolutional layer
    x = Conv2D(256, kernel_size=(5,5), strides=(1,1), padding='same', activation='relu')(x)
    x = MaxPooling2D(pool_size=(3,3), strides=(2,2))(x)
    x = Dropout(0.25)(x)
    
    # third convolutional layer
    x = Conv2D(384, kernel_size=(3,3), strides=(1,1), padding='same', activation='relu')(x)
    x = Dropout(0.25)(x)
    
    # fourth convolutional layer
    x = Conv2D(384, kernel_size=(3,3), strides=(1,1), padding='same', activation='relu')(x)
    x = Dropout(0.25)(x)
    
    # fifth convolutional layer
    x = Conv2D(256, kernel_size=(3,3), strides=(1,1), padding='same', activation='relu')(x)
    x = MaxPooling2D(pool_size=(3,3), strides=(2,2))(x)
    x = Dropout(0.25)(x)
    
    # flatten the output from the convolutional layers
    x = Flatten()(x)
    
    # first fully connected layer
    x = Dense(4096, activation='relu')(x)
    x = Dropout(0.5)(x)
    
    # second fully connected layer
    x = Dense(4096, activation='relu')(x)
    x = Dropout(0.5)(x)
    
    # output layer
    output_layer = Dense(num_classes, activation='softmax')(x)
    
    # define the model with input and output layers
    model = tf.keras.Model(inputs=input_layer, outputs=output_layer)
    
    return model
model = AlexNet(input_shape=(224,224,3), num_classes=1000)
model.summary()
Model: "model"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 input_12 (InputLayer)       [(None, 224, 224, 3)]     0         
                                                                 
 conv2d_281 (Conv2D)         (None, 54, 54, 96)        34944     
                                                                 
 max_pooling2d_59 (MaxPoolin  (None, 26, 26, 96)       0         
 g2D)                                                            
                                                                 
 dropout_21 (Dropout)        (None, 26, 26, 96)        0         
                                                                 
 conv2d_282 (Conv2D)         (None, 26, 26, 256)       614656    
                                                                 
 max_pooling2d_60 (MaxPoolin  (None, 12, 12, 256)      0         
 g2D)                                                            
                                                                 
 dropout_22 (Dropout)        (None, 12, 12, 256)       0         
                                                                 
 conv2d_283 (Conv2D)         (None, 12, 12, 384)       885120    
                                                                 
 dropout_23 (Dropout)        (None, 12, 12, 384)       0         
                                                                 
 conv2d_284 (Conv2D)         (None, 12, 12, 384)       1327488   
                                                                 
 dropout_24 (Dropout)        (None, 12, 12, 384)       0         
                                                                 
 conv2d_285 (Conv2D)         (None, 12, 12, 256)       884992    
                                                                 
 max_pooling2d_61 (MaxPoolin  (None, 5, 5, 256)        0         
 g2D)                                                            
                                                                 
 dropout_25 (Dropout)        (None, 5, 5, 256)         0         
                                                                 
 flatten_9 (Flatten)         (None, 6400)              0         
                                                                 
 dense_25 (Dense)            (None, 4096)              26218496  
                                                                 
 dropout_26 (Dropout)        (None, 4096)              0         
                                                                 
 dense_26 (Dense)            (None, 4096)              16781312  
                                                                 
 dropout_27 (Dropout)        (None, 4096)              0         
                                                                 
 dense_27 (Dense)            (None, 1000)              4097000   
                                                                 
=================================================================
Total params: 50,844,008
Trainable params: 50,844,008
Non-trainable params: 0
_________________________________________________________________

 

 

 

 

 

※ Filtering

image는 sequential information 즉, 상호 연관성이 있다.

 

[sliding window 기법]

- 큰 2차원 모집단에 대해 작은 크기의 표본집단을 뽑는다.

이때, window가 움직이면서 표본을 계속 뽑아 연산을 해 새로운 값을 도출하는 기법.
(sliding되는 것을 window(kernel) = filter라고도 부른다.)


- 또한, 상하좌우와 channel검사도 해야해서 3중for문으로 구현해야한다.
- 이때, filter로 인해 발생한 표본집단patch라고 한다.
- mean filter = patch와 kernel의 합성곱이 patch의 평균값이 되는 것

  이를 이용해 blurring이 가능하다. (average blurring)

if sharp한 image의 경우:
	(차이가 큰 value) mean filter의 사용은 sharpness를 없앤다.
	이때, 평균이 아닌 중앙값을 이용한 median filter를 사용하면?
      -> sharpness의 특성을 위보다 더 살릴 수 있다.
      
	단, 나머지 픽셀의 정보를 소실한다.
      -> 여러번 반복하면 소실이 반복, 남는 픽셀의 개수가 줄어든다.
	  -> 즉, 반복이 많아질수록 정보의 손실이 커진다.





 

 

 

 

 [실습] 

 Mean filter 

 

 

 Median Filter 

Similarity Transformation : 유사 변환

변환 시킨 후 원래의 모양과 유사하게 되는 변환을 유사 변환이라고 한다

수학적으로 보자면

1. scale을 전체적으로 크게 하거나 줄게 하는 것.
2. 이동, 회전을 하는 것 (Rigid Transform 강체변환 / 형태는 유지하고 회전과 이동)

을 만족하는 변환을 의미한다.

 

 

 

Linear transformation : 선형 변환 

f(x+y) = f(x) + f(y)

f(ax) = af(x)

만족하는 함수 f : V -> W 의 변환을 선형변환이라고 한다.

(다시 말해 선형성(Linearity)을 유지해주는 변환)

 

 

 

Affine Transformation : 아핀 변환

선형 변환과 유사 변환을 동시에 포함하는 변환을 아핀 변환이라고 한다.

 

 

 

🤔 transform

 rotation

 scale

 

 

 

🤔 transition

 

 

 

🧐 위의 3개의 행렬식을 하나로 합쳐보자.

1. 차원의 확장
   - rotation

  - scale



2. 행렬을 합침

case 1)

if scale 이후 transition 진행​

case 2)
if transition 이후 scale 진행


이 행렬식만 있으면, [즉, 원본 이미지의 2점만 있으면
h(rotation, transition, scale)를 구할 수 있다.]


이때, pseudo inverse(pinv)를 이용, least square approximation을 통해 h를 구한다.


match 3개 → Affine Transform
  - rotation, transition, scale으로는 설명할 수 없는 경우
  - shearing이 도입!

match 4개 Projective Transform
  - 뒤틀림(shearing)과 같이 차원이 늘어날 수록 구현이 더 추가된다.

 

 

 

 

 

 

 

 

[실습] 

transformation 

 

 

 

 Shearing_Affine transformation (2D) 

 

 

 

Projective Transformation  (4D) 

이번주의 image 주제

 image = A partial view of Space ! 

 즉, 공간의 "일부 시점"에 불과하다는 관점!

 

 

 

 

※ scaling 

Scale: 사진의 크기를 확대하거나 줄이는 것.

밝기값을 찾기 위해 원본 image를 vectorize하여 밝기값을 구하고 rasterize를 다시 시켜 scale을 진행한다.
pixel과 pixel사이를 채워주는 것을  의미.
• 예를 들어 a만큼 scale을 한다면
 (x, y) 위치의 값으로 들어간다. (new) ← (ax , ay) 의 값을(original)이를 rasterize시키면 된다.

 

 

 

 [실습] - vectorization을 위해 Bilinear interpolation 이용 

§ 확대하기

 

§ 축소하기

 

 

※ Rotate 실습

 

 

 

 

 

 

[과제]

과제 1) 크기 손상 없이 그대로 rotation 하기 - for i in range(H-1) 부분에서 1픽셀 잘림

과제 2) for문 대신 선형대수 식으로 변형해서 구현해보기

과제 3) bilinear 대신 bicubic 또는 triangulation 방식으로 해보기

 

※ interpolation (보간법) 

- pixel과 pixel사이를 채워주는 것을 의미.

• 지난 시간, image를 "number"와 "array", "information"의 관점에서 보았다.

• 이번 시간에는 image는 space 즉, 공간이라는 관점에서 보도록 하자.

이때 공간을 표현하기 위해서는 연속성이 중요한데, pixel은 discrete한 데이터이다.

 

우리가 배운 내용중 continuous한 데이터가 무엇이 있을까?

https://chan4im.tistory.com/74

 

[Computer Vision].prev_ pixel과 RGB, HSV

※ Computer Vision • Computer Vision -> 자연어 처리 -> 오디오 부분 순으로 발전하였기에 가장 발전된 분야 • 시각적 세계를 해석하고 이해하도록 컴퓨터에 학습시키는 인공지능 분야로 컴퓨터를 이

chan4im.tistory.com

처음 배웠던 vector를 이용하면 우리는 image를 소수점 단위로 이동시킬 수 있다.

즉, interpolation을 위해 vector가 필요하며 이를 위해 pixel을 vector로 근사시킬 수 있다.

이를 vectorize 즉, 벡터화 시키는 것이라 말한다.

vectorize: 픽셀을 벡터화 시키는 것

rasterize: 벡터를 픽셀화 시키는 것

 

 

 

 

 

 

 

🤔 Bilinear interpolation 

- linear interpolation을 2번한다는 의미로 예를 들어 꼬인위치의 선분으로 이루어진 점4개에 대해

 예를 들어 0.3, 0.75 이동시 AB, CD에서 0.3내분점선분을 이은 후 0.75만큼을 이동한다.
- 즉, 내분식을 2번 중첩하면 된다.


N = aB+(1-a)A
M = aD+(1-a)C
bN + (1-b)M


장점: 구현이 간단, 빠름
단점: 미분이 까다로움(곡면근사이기 때문)

 

 

 

 

🤔 Triangulation interpolation 

- 여러 점에 대해 3개의 점으로 삼각형을 만들어 평면상에 모두 mapping시키는 기법

M = (A+B+C+D)/4


밝기(z)가 주체이므로 평면의 방정식: z = ax+by+c로 정리 가능
i) A,B,M을 지나는 평면: z = (3 5 5)
                                      x = (0 0.5 1)
                                      y = (0 0.5 0)

if (0.5, 0.75)로 이동한다면 CMD평면이어서 위의 방정식을 사용할 수 없다.

 

장점: 미분이 쉽다.
단점: 매우 느리다.

 

[실습]: import

 

 

 

 

 

[실습] - Bilinear interpolation 

 

 

 

 

[실습] - Triangulation interpolation 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

※ image blending (이미지 합성)

• 지난 시간, image를 "number"와 "array"로 보는 관점을 알아보았다.

• 이번 시간에는 number와 array를 포함하여 이미지 = 여러 정보의 집합이라는 관점을 알아볼 것이다.

 지난 시간들에서의 관점에서는 이미지를 컨트롤하였기에 이를 상정하면?

우리는 이미지를 조작할 수 있다는 것이고 이미지 = 정보라는 관점(image = information)에서 보면?

즉, 이런 관점이면 우리는 이미지 정보를 조작할 수 있다는 것이다!

 

 

 

[실습] - blending 

<import 부분>

 

<찍은 2개의 사진 출력>

 

 

<frame1에 frame2를 blending>

이때,

crop = frame2[130:400, 150:400]

frame1[100:370, 200:450] = crop

plt.imshow(frame1)

에서 100:370에서 사이즈인 270이 동일해야 한다.

 

 

 

 

§ Alpha Blend (이미지가 있을 때, 이미지를 투명하게 만들어서 덮어씌움)

• 2개의 이미지가 있을 때, 한 이미지를 투명하게 만들어 덮어씌우는 것

• 위에서는 구역이 나뉘어져 있었지만 alpha blend의 경우, 같은 구역을 동시에 차지할 수 있다.

(정보를 일부 손실시키지만 공간을 효율적으로 쓸 수 있어 딥러닝에서 학습을 빠르게 하기위한 최적화시 사용)

구현방식 : alpha blending : frame1 x a  + frame2 x (1-a) 

 

 

 

 

 

 

[실습] - alpha blending 

 

 

 

 

 

 

 

 

 

 

 

 

 

※ image Masking (이미지 마스킹, 거름망)

Masking: 어떤 것을 막아주는, 걸러준다는 의미. , filter는 다른 의미. 우리가 익히아는 filter의 뜻 = masking

• image의 특정 부분을 까맣게 가리는 것.

• 원본source 이미지와 마스크 이미지가 존재

 

[실습] - Masking 

사각형 마스킹 구현방식 : 마스크 이미지[밝은 부분을 1, masking 부분을 0으로 만들어] 원본이미지와 곱한다.


 

[실습] - 원형 Masking

원형 마스킹 구현방식 : 사각형 마스킹 구현방식 + numpy 안의 meshgrid mgrid 이용

- np.mgrid[:H, :W] 을 이용

이진의 경우, plt는 1을 노란색, 0을 보라색으로 표현

- 따라서 H와 W는 다음과 같다.

이에 대한 코드는 아래와 같이 표현하여 출력할 수 있다.

 

 

 

 

 

 

 

 
-과제: gaussian 사용해보기 à 등고선처럼 화면의 밝기가 나옴
-과제: sigmoid 사용해보기 à 왼쪽을 밝고 오른쪽을 어둡게 와 같이 나옴

 

 

 

 

 

 

※ Finale _ 틀린그림 찾기

[실습] 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

• 지난 시간에는 image가 일종의 number로 생각하는 과정이었다.

https://chan4im.tistory.com/74

 

[Computer Vision].prev_ pixel과 RGB, HSV

※ Computer Vision • Computer Vision -> 자연어 처리 -> 오디오 부분 순으로 발전하였기에 가장 발전된 분야 • 시각적 세계를 해석하고 이해하도록 컴퓨터에 학습시키는 인공지능 분야로 컴퓨터를 이

chan4im.tistory.com

이번에는 image가 하나의 array라고 생각한다면 할 수 있는 방법들에 대해 배워볼 것이다.

 

 

※ image crop

• image는 일종의 "array"이므로 이런 image를 배열단위를 자르는 방식을 통해 자를 수 있다.

• 그렇다면 배열을 자르기 위해 어떤 방식을 사용할 수 있을까?

바로 slicing을 이용해 image 배열을 자를 수 있다.

구현방식: a = [1,2,3,4]  -->  a = [1, 4]로 만들려면?   =>   a[1:3]   (by. slicing) 

 

[실습] - crop

<import 부분>

 

 

 

 

 

 

 

 

※ image padding

원본 image의 바깥부분에 덧대는 방식으로 4가지 padding 기법을 소개한다.

zero-padding : 원본 image의 주위 값을 0으로 배치

mean-padding : 원본 image의 주위 값을 평균값으로 배치 (단, RGB는 R따로, G따로, B따로 평균)

reflect-padding : 데칼코마니 하듯이 뒤집어서 가져옴

symmetric-padding : 대칭되듯이 가져옴

1. zero-padding&nbsp; &nbsp;2. reflect-padding&nbsp; &nbsp; 3. symmetric-padding

 

구현방식 1: frame을 그대로 두고 이어 붙일 것을 concat 시킨다.

장점: memory 절약가능 (학습 시 많이 사용)

단점: 느리다.

 

구현방식 2: 새로 비어있는 큰 배열을 만들어 가운데 부분에 frame을 대입시킨다.

장점: 빠르다. (inference(추론), 즉 학습이 끝난 후 결과를 낼 때 많이 사용)

단점: memory가 비교적 많이 필요하다.

 

 

 

※ 배열의 축, axis이해하기.

배열에는 축이라는 개념이 있는데, 이 축이 헷갈리는 이유는 행렬개념과는 조금 다르게 받아들여야 하기 때문이다.

1차원 배열
먼저 1차원 배열의 경우, 축은 axis 0 하나뿐이다. (행열의 개념이 없음)
array([0, 1, 2, 3, 4 ,5])


2차원 배열
다음으로 2차원 배열의 경우, 축은 axis 0, axis 1 두 가지가 있다.
array([[0, 1, 2],
          [3, 4 ,5]])
위의 경우, 우리는 2행 3열로 배열을 해석하는데 행과 열에 대한 축의 매칭은 아래와 같다.
행: axis 0        열: axis 1
이때, 무작정 axis0을 행이라 외우는 것은 주의해야 한다. 고차원으로 갈수록 규칙이 깨지기 때문이다.


3차원 배열
다음으로 3차원 배열의 경우, 축은 axis 0, axis 1, axis 2  세 가지가 있다.
array([[[ 0, 1, 2, 3],
           [ 4 ,5, 6, 7],
           [ 8, 9, 10, 11]],

          [[12, 13, 14, 15],
           [16, 17, 18, 19],
           [20, 21, 22, 23]]]
)

위의 경우,  3행 4열의 행렬이 2층으로 배열을 해석하는데 행과 열, 높이에 대한 축의 매칭은 아래와 같다.
높이: axis 0        행: axis 1       열: axis 2
import numpy as np

arr1 = np.array([ [1, 2, 3], [10, 20, 30] ])
arr2 = np.array([ [4, 5, 6], [40, 50, 60] ])

np.concatenate((arr1, arr2), axis = 0)
array([[ 1,  2,  3],
       [10, 20, 30],
       [ 4,  5,  6],
       [40, 50, 60]])

np.concatenate((arr1, arr2), axis = 1)
array([[ 1,  2,  3,  4,  5,  6],
       [10, 20, 30, 40, 50, 60]])

 

 

 

 

 

[실습] - padding

 

 

 

 

 

 

※ translation

crop과 padding을 이용하여 사진을 옮길 수 있음 (정석적 방법은 아님)

• image를 100 pixel만큼 왼쪽으로 옮기고 싶다면?

-  frame을 slicing을 이용한 crop으로 자름 => [:, 100:]

- 그 후 padding

 

[실습] - translation

※ Computer Vision

• Computer Vision  -> 자연어 처리 -> 오디오 부분 순으로 발전하였기에 가장 발전된 분야

• 시각적 세계를 해석하고 이해하도록 컴퓨터에 학습시키는 인공지능 분야로 컴퓨터를 이용한 정보처리를 진행한다.

• 따라서 컴퓨터 비전은 정보를 데이터로 표현하기 매우 적절한 구조를 갖고 있다.

 

cf. 만약  It's late를 데이터로 표현하려면...?  (feat. 자연어 처리)
자연어의 경우, 자연어는 데이터로 표현하기 어려운데, (데이터를 많이 갖고 있기 때문)

예시에서 It's의 t와 late의 t가 똑같은 용도로 사용될까? 이런 저런 이유로 컴퓨터비전은 데이터를 표현하기 매우 좋다.

 

 

 

 

※ PASCAL VOC challenge 문제

초창기 이미지 dataset에 대해 인식성능을 겨루는 대회가 열렸고,

가장 대표적인 PASCAL VOC(Visual Object Classes) Challenge 로 이 대회를 기점으로 이미지 인식에서 다루는 문제들이 아래와 같이 정형화 되었다,

• Classification

• Detection

• Segmentation

 

 

Classification 

※ Classification 
특정 class에 해당하는 사물이 포함되어 있는지 여부를 분류하는 모델
classification은 Detection, Segmentation문제를 향한 출발점이기에 더더욱 중요하며 다음 2가지로 나눌 수 있다.

§ 단일 사물 분류 문제
- 모든 이미지가 반드시 하나의 사물만 존재
- 전체 class에 대한 confidence score  S를 비교, 가장 큰 confidence score를 지니는 class로 선정하는 방법

§ 복수 사물 분류 문제
- 이미지 상에 여러개의 사물들이 포함되어 있음
- 단순히 가장 큰 confidence score를 갖는 class 하나만을 선정하는 방법은 합리적이지 않게 된다.
- 방식이 조금씩은 다르나 class별 threshold를 정해놓고  S > threshold 일 때
==> "주어진 이미지 안에 해당 class가 포함되어 있을 것이다" 라고 결론지음

▶ 평가척도 
• accuracy  = 올바르게 분류한 이미지 수  /  전체 이미지 수
- accuracy는 classification문제에서 일반적으로 test를 위해 측정한다.
- 이 방법은 단일 사물 분류문제에서는 즉각사용해도 별 문제가 없다. 
- 하지만 복수 사물 분류문제에서는 곤란해질 수 있어서 아래와 같은 평가척도를 사용한다.

precision과 recall 은 class A에 대해 다음과 같이 측정한다.
precision = 올바르게 분류한 A 이미지 수  /  A로 예측한 이미지 수
recall = 올바르게 분류한 A 이미지 수  /  전체 A 이미지 수 

 

 

Detection

※ Detection 
image localization이라고도 불리며 classification에서 어느 위치에 포함되어 있는지 "박스형태"로 검출하는 모델을 만드는 것이 목표이다. 이 박스를 bounding box라 한다.



▶ 평가척도 IOU (Intersection Over Union)
• 사물의 Class와 위치의 예측결과를 동시에 평가해야해서 사물의 실제 위치를 나타내는 실제 bounding box (GT bounding box)정보와 예측 bounding box가 얼마나 "겹쳐지는지"를 평가한다.
Bp: 예측 bounding box
Bgt: GT bounding box
Bp와 Bgt의 IOU = Bp∩Bgt 영역넓이  /  Bp∪Bgt 영역넓이
보통 이에 대한 threshold를 0.5로 정해놓고 있으며 여러개의 bounding box가 모두 IOU를 50%를 넘겨 매칭되면
결과적으로 매칭에 실패한것으로 간주한다. (즉, 복수 개의 매칭이 되면 안된다.)

 

 

Segmentation

※ Segmentation 
어느 위치에 있는지를 "Pixel 단위로 분할"하는 것으로 Detection보다 더 자세하게 위치를 표시한다.
이미지 내 각 위치상의 Pixel들을 하나씩 조사, 조사대상 Pixel이 어느 Class에도 해당하지 않으면?
=> background Class로 규정하여 해당 위치에 0을 표기하고 이 결과물을 mask라 부른다.

§ Semantic Segmentation
- 분할의 기본단위: Class
- 동일한 Class에 해당하는 사물은 동일한 색상으로 예측하여 표시

§ Instance Segmentation
- 분할의 기본단위: 사물
- 동일한 Class에 해당하더라도 서로 다른 사물이면 다른 색상으로 예측하여 표시

▶ 평가척도 IOU (Intersection Over Union)
Ap: 예측 mask의 특정 Class 영역
Agt: GT(실제)  mask의 해당 Class 영역
Ap와 Agt의 IOU = Ap∩Agt 영역넓이  /  Ap∪Agt 영역넓이

 

 

 

 

 

※ Pixel (픽셀)이란?

• 픽셀을 이용해 정보를 표현하기에, 픽셀은 한 단위(unit)로 "인간이 정의한 것"이다. 

• 또한 pixel = brightness (밝기)를 이용해 표현하는데 이를 통해 알 수 있는 중요한 사실이 있다.

즉, 픽셀은 이미지의 최소단위이다! (픽셀이 나타내는 값 = 밝기.)

픽셀 함수에서 표현되는 데이터의 느낌과 정 반대가 있다.

vector(수학적 의미가 아닌, vision information 측면의 벡터), 벡터는 함수같은 형식


픽셀: noncontinuous (어떤 unit을 정해 vector의 특정 부분을 묶은 것)
벡터: continuous한 것


실제 존재하는 사물들은 vector자체로 저장하기는 너무 방대하고 연속적이기에

이를 grid로 모두 잘라 pixel로 하여 특정범위별밝기를 0.1, 0.9처럼 하여 그 값들을 data로 3, 23처럼 저장하는 것

이렇듯 pixel은 숫자여서 우리가 보고 있는 모든 것들을 숫자로 표현가능하기에 컴퓨터 비전이 발전할 수 있었다.

 

 

 

 

※ Pixel과 RGB

pixel은 숫자로 이루어져 있는데 그 크기가 1 Byte이다. (0~255의 숫자)
R(1 Byte)     G(1 Byte)     B(1 Byte) 이렇게 (1Byte)^3으로  총 1600만가지 색을 표현할 수 있다.


A(1 Byte): Alpha, 즉 투명도까지 이용한다면?

 

결과적으로 image는 4 Byte로 표현이 가능하며 이것이 바로 1 Pixel 이다.


 

[실습]

<import 부분>

import numpy as np
import cv2  # camera, image 등 conputer vision을 쓰기 위한 openCV
import numpy as np  # 빠른 계산을 위한 라이브러리
import matplotlib.pyplot as plt  # visualization을 위한 matplotlib
cap = cv2.VideoCapture(1)  # cap이라면 변수에 카메라 기능을 가져옴 0번이 전면 카메라
ret,frame = cap.read()  #ret은 성공, 실패, frame은 image frame
print(frame)

1번 카메라로 촬영한 사진을 데이터화한 것.

 

 

 

 

 

아래 사진처럼 frame[0][0][0]에 해당하는 숫자인 121이 uint8 즉, unsigned int 8bit값인 것을 알 수 있다.

따라서 정리하자면 frame이라는 변수는 uint 8bit의 집합 data로 이루어져있음을 알 수 있다.

( image type의  default 값은 uint8이다)

 

 

 

 

 

찍은 사진에 대해 출력을 해보자.

 

 

여기서 잠깐! 

실습을 하던 중 앞에서 배운 내용을 상기시켜보자.

image = 숫자라는 것이 중요하다 하였다.

 

Q. 그렇다면, 픽셀은 밝기를 대변하니까 frame x 2를 하면?

A. 밝기가 밝아진다!

다만, 기존의 255크기를 넘어설 수 있으며 (ex 150 * 2 = 300) 이때 overflow가 발생하기에

아래와 같은 방식을 사용한다.

 

 

 

 

 

 

 

※ Contrast와 Gamma

contrast: 대비, 밝은것을 더 밝게, 어두운것을 더 밝게! 2(frame-127)+127  (x절편 이하값은 손실 발생)

따라서 손실발생을 거의 없애주기 위해서 sigmoid 함수사용!

 

[과제]. sigmoid함수를 사용한 contrast해보기!

위 사진에서 보면 빨간색 부분이 손실되는 것을 알 수 있다.



Gamma (사진변수 / 255)^(감마)  x 255
감마가 높으면 변화량이 커지고 감마가 낮아지면 변화량이 낮아지는데, 선형 contrast보다 손실발생율이 거의 없어서 훨씬 사용에 유리하다.


cf. astype을 통해 형변환이 가능하다!

plt.imshow(frame에 대한 연산.astype(np.int32))

 

 

 

 

 

 

 

 

 

 

 

 

 

※ RGB와 HSV

RGB말고도 사용할 수 있는 색 공간이 있을까?


RGB의 color space: 정육면체형
HSV의 color space: 원뿔형이고, uint를 사용한다.

 - Hue: 0~179사이로 표현 ( pi값으로 value값 1당 2도를 의미 )

           모든 pixel이 색이 조금씩 바뀜 (각도의 이동)  /  hsv[..., 0]  , 0번 채널 즉, hue에 접근하는 것.

 - Saturation: 채도, 색의 농도, 클수록 진하다  /   plt.hsv[... , 1]  ,1이라는 것은 1번 채널만 본다는 뜻이다.

 - Value: 명도, 색의 밝기를 의미





[실습]







 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

[과제 해보기]

 

+ Recent posts