반응형

경사 하강법(Gradient descent)이란?

  • 1차 미분 계수를 이용하여 함수의 최소값을 찾아가는 반복적인 방법이다.
  • 함수의 기울기를 구하고 경사의 반대 방향으로 계속 이동시켜 극값에 이를때 까지 반복하여 제시된
    함수의 기울기로 최소값을 찾아내는 머신러닝의 알고리즘이다. 
  • 인공지능 모델이 데이터를 잘 표현 하도록 기울기를 사용해 모델을 조금씩 조정하여 최적화 하는 방법이다.

 

경사 하강법을 사용하는 이유

  • 미분 계수를 구하는 과정을 컴퓨터가 구현하는 상황에서는 경사하강법으로 비교적으로 쉽게 구현할 수 있다.
  • 데이터 양이 큰 경우에는 경사하강법과 같은 반복적인 방법을 통하여 값을 구하면 더 효율적으로 구할 수 있다.

 

경사 하강법 수식 표현

  • 기울기가 양수면 \(x\) 값이 커질 수록 함수 값이 커진다는 것을 의미한다.
  • 기울기가 음수면 \(x\) 값이 커질수록 함수의 값이 작아진다는 것을 의미한다.
  • 기울기 값이 큰 것은 기울기가 가파르다는것을 의미한다.
    하지만, \(x\)의 위치가 최소/최대값에 해당되는 \(x\) 좌표에서 멀리 떨어져 있다는 것을 의미한다.

y = x² 그래프

반응형

'AI > AI math' 카테고리의 다른 글

Lecture Notes - Gauss Elimination  (0) 2022.12.15
Lecture notes - Linear system (coding)  (0) 2022.12.14
Lecture notes - Linear system  (0) 2022.12.14
반응형
활성화 함수 (Activation Function)는 신경망의 출력을 결정하는 식이다.

 

기존 Perceptron 수식

$$ y= \begin{cases} 0 \quad (w_1x_1 + w_2x_2 \leq \theta) \\ 1 \quad (w_1x_1 + w_2x_2 > \theta) \end{cases} $$

 

변형된 Perceptron 수식

 

$$ X = w_1x_1 + w_2x_2 + b $$

$$ h(x) = \begin{cases} 0 \quad x \leq 0 \\ 1 \quad x>0 \end{cases} $$

 

  • 입력 신호의 합 \(h(x)\)를 거쳐 변환되어 \(y\)를 출력.
  • \(h(x)\) 함수는 입력 값이 0을 초과하면 1을 리턴하고, 0을 초과하지 않으면 0을 리턴한다.

\(X\) : Perceptron 결과

\(y\) : 출력 값

\(h(x)\) : 활성화 함수

 

 

 

Step Function

Step Function

$$ h(x) = \begin{cases} 0 \quad x \leq 0 \\ 1 \quad x>0 \end{cases} $$

import numpy as np
import matplotlib.pyplot as plt

def step_function1(x):
	if x <= 0:
		return 0
	else x > 0:
		return 1

def step_function2(x):
	y = x > 0
	return y.astype(np.int)
  • 임계치를 기준으로 출력해주는 함수이며, Perceptron algorithm에서 Activation function으로 사용한다.
  • 다중 분류 문제 같은 문제에서 다중 출력이 불가하다.
  • 신경 세포의 전달 방법을 묘사한 기법이며, 출력되는 결과값이 갖는 정보가 희석된다는 단점이 존재한다.

Linear Function

$$ h(x) = cx \quad(c: 상수) $$

Linear Function

def Linearfunction(x, c):
	return c*x

장점

  • 다중 출력이 가능하다.

단점

  • 역전파 (Backpropagation) 사용이 불가하다.
역전파는 활성화 함수를 미분하여 이것을 이용해서 손실값을 줄이기 위한 과정이다.
선형함수의 미분값은 상수이기에 입력값과 상관없는 결과를 얻는다.
  • 은닉층을 무시하고 얻을 수 있는 정보를 제한한다.
활성화 함수를 여러 층을 통하여 얻고자 하는 것은 필요한 정보를 얻기 위함이다.
선형 함수를 여러번 사용하는 것은 마지막에 선형 함수를 한번 쓰는것과 같다.
\( h(x) = cx \) 일 때, \( h(h(h(x))) = c'x \) 이기 때문이다. 

 

반응형

'AI > Notions' 카테고리의 다른 글

Perceptron  (0) 2022.12.27
Quantization  (0) 2022.12.26
CNN (Convolutional Neural Network) 개념 정리  (0) 2022.12.14
반응형

Perceptron 개념

  • 인간의 신경 세포를 알고리즘화 한 것, 딥러닝의 기본 개념
  • N개의 입력을 받아 1개의 신호를 출력한다
  • 신호가 임계값보다 크면 1을 출력, 임계값보다 작으면 0을 출력한다.
    (정보 전달 기능은 없음)

  • 위위 그림에서 원은 Node or Neuron 라 지칭하며, 선은 Edge라고 지칭한다.
  • Node에서 다음 Node로 정보가 전달될 때 가중치 /(w_1 \ w_2/)가 곱해져 전달된다.
  • 전달되는 값과 가중치가 곱해진 값  /(w_1 \ x_1/)의 합  /(w_1 \ x_1 +w_2 \ x_2/)이 임계값 \(\theta\)보다 크면 1, 작으면 0이 출력된다.

퍼셉트론 수식 표현 

$$ y= \begin{cases} 0 \quad (w_1x_1 + w_2x_2 \leq \theta) \\ 1 \quad (w_1x_1 + w_2x_2 > \theta) \end{cases} $$

 

Perceptron Python Code

def perceptron(x1, x2, w1, w2, theta):
	y = w1*x1 + w2*x2
        
	if y > theta:
		return 1
	elif y <= theta:
		return 0
반응형

'AI > Notions' 카테고리의 다른 글

Activation Function : Step/Linear Function  (0) 2022.12.27
Quantization  (0) 2022.12.26
CNN (Convolutional Neural Network) 개념 정리  (0) 2022.12.14
반응형
원문 출처

 

  • 양자화는 연속 데이터를 이산 숫자로 변환하는 과정이다.
  • 신경망 훈련 계산은 일반적으로 Floating point type (16bit, 32bit)를 사용하여 수행된다.
  • 딥러닝에서 양자화는 일반적으로 부동 소수점에서 고정 소수점 정수로 변환하는 것을 말한다.
  • 딥러닝에서 사용되는 양자화 기술은 Dynamic Quantization, Static Quantization 등이 존재한다.

 


Quantization Mapping

  • 양자화는 부동 소수점 값 \(x ∈ [ \alpha, \beta ]\)를 b-bit 정수 \(x_q ∈ [\alpha_q, \beta_q]\)에 맵핑한다.

de-Quantization 프로세스 수학적 정의

$$ x = c(x_q + d) $$

Quantization 프로세스 수학적 정의

$$ x_q = round(\frac{1}{c} x - d) $$

 

c, d : 변수(variables)

 

c 및 d를 유도하기 위하여 α가 αq에 대한 맵과 β가 βq 맵에 대한 맵을 확인하야하고, 선형 시스템 문제를 해결해야 한다.

 

\(\beta = c(\beta_q+d)\)

\(\alpha= c(\alpha_q+d)\)

 

솔루션은 다음과 같다.

\(c = \frac{\beta-\alpha}{\beta_q - \alpha_q}\)

\(d = \frac{\alpha\beta_q-\beta\alpha_q}{\beta - \alpha}\)

 

실제로, 양자화 후 에러 없이 Floating point "0"이 정확하게 표현되도록 해야 한다.

 

수학적 증명 : 

\(x_q = round(\frac{1}{c}0 -d)\)

\(= round(-d)\)

\(= -round(d)\)

\(= -d   \)

 

위 수식의 의미는 아래와 같다

\(d = round(d)\)

\(   = round(\frac{\alpha\beta_q-\beta\alpha_q}{\beta-\alpha})\)

 

컨벤션에 의해서 c를 스케일 s로 , -d를 zero point z로 표시한다.

 

요약

  • Quantization

$$ x = s(x_q -z) $$

  • de-quantization

$$ x_q = round(\frac{1}{s}x +z) $$

  • 스케일 's' , Zero point 'z'의 값

\(s = \frac{\beta-\alpha}{\beta_q - \alpha_q}\)

\(z = round(\frac{\beta\alpha_q - \alpha\beta_q}{\beta-\alpha})\)

 

'z'는 정수, 's'는 부동 소수점이다.   

  

Value Clipping

  • 실제로, 양자화 과정은 \( [\alpha, \beta]\)의 범위를 벗어난 \(x\) 를 가질 가능성이 있으며, 양자화 된 값 \(x_q\) 또한 \( [\alpha, \beta]\)의 범위를 벗어난다. 
  • Integer type이 INTb 및 \( (alpha_q, \beta_q) = (-2^{b-1}, 2^{b-1} -1) \) 또는 unsigned UINTb \( (\alpha_q, \beta_q) = (0,2^b -1)\) 인 경우
    유형 정밀도가 범위를 벗어난 값을 클리핑 한다.
  • 구체적으로, 양자화 진행에서는 추가 클립 단계가 있다.

$$ x_q = clip (round(\frac{1}{s}x+z), \alpha_q,\beta_q) $$

 

여기서 \(clip(x,l,u)\) 함수는 다음과 같이 정의 된다.

$$ clip(x,l,u) = \begin{cases} l\quad if\;x<1\\ x\quad if\;l\leq x\leq u\\ u\quad if\;x>u \end{cases} $$

 

Affine Quantization Mapping

  • 위에서 설명한 Quantization Mapping을 Affine Quantization Mapping이라고도 한다.

Scale Quantization Mapping

  • 정수형이 INTb로 부호화되면 \((\alpha_q, \beta_q) \ = \ (-2^{b-1}|1, \ 2^{b-1} -1)\) 이고, \(z \ = \ 0\) 을 강제 한다.
  • 수학적으로는 아래와 같다

\(\alpha_q \ = \ -\beta_q\)

\(round(\frac{\beta\alpha_q-\alpha\beta_q}{\beta-\alpha} \ = \ 0)\)

 

  • 위 결과 \( \alpha = -\beta\)가 생성 된다.
  • 따라서, 부동 소수점 범위인 \([\alpha, -\alpha]\) 와 정수 범위 \([\alpha_q - \beta_q]\) 사이에서 매핑된다.
  • 0을 중심으로 정확히 대칭이기 때문에, Symmetric Quantization Mapping 이라고도 한다.
  • Scale Quantization Mapping은 Affine Quantization Mapping의 특수한 경우일 뿐이고, 정수 범위에 사용되지 않는 비트가 존재한다.

요약 (Summary)

  • Quantization function

$$ f_q(x,s,z) \ = \ clip(round(\frac{1}{s}x + z),\alpha_q,\beta_q)$$

  • de-Quantization function

$$ f_d(x_q,s,z)\ = \ s(x_q -z)$$


Quantized Matrix Multiplication

: 추후 작성

 


Quantized Deep Learning Layers

  • 딥러닝 모델에서는 행렬 곱셈 외에도 ReLU와 같은 비선형 활성화 계층과 배치 정규화 같은 특수 계층이 존재한다.
  • 실제로 양자화 된 딥러닝 모델에서 이러한 계층을 어떻게 처리할 것인가가 가장 중요한 문제이다.

간단한 솔루션

  • 양자화 된 입력 텐서를 레이어로 역 양자화 하고, 일반적인 부동 소수점 계산을 사용하여 출력 텐서를 양자화 하는 것.
  • 모델에 이러한 계층이 몇개만 존재하거나, 계층을 양자화된 방식으로 처리하기 위한 특별한 구현이 없는 경우에 작동한다.

대부분 딥러닝 모델에서 계층의 수는 무시 할 수 없으며, 위와 같은 간단한 솔루션을 사용하면 추론이 느려질 가능성이 크다.

 

Quantized ReLU

  • 활성화 함수 ReLU를 아래와 같이 정의한다.
  • 기존 ReLU 정의와 다르지만, 더 일반화 되어 양자화 된 ReLU 구현에 편리하다.

$$ ReLU(x,z_x,z_y,k)\ = \ \begin{cases} z_y  \quad if \; x \leq z_x \\ z_y + k(x-z_x) \quad if \; x \geq z_x \end{cases} $$

 

  • 딥러닝 모델에서 일반적으로 사용되는 ReLU는 \(z_x=0,\quad z_y=0, \quad k=1\)일 때 위 정의의 특수한 경우입니다.

$$ ReLU(x,0,0,1)\ = \ \begin{cases} 0  \quad if \; x \leq 0 \\ x \quad if \; x \geq 0 \end{cases} $$

 

  • ReLU가 수학적으로 어떻게 양자화되었는지 증명해 보겠습니다.

출처 : Lei Mao Github

따라서 부동 소수점 \(y= ReLU(x,0,0,1)\)에 해당하는 양자화된 ReLU를 수행하려면 \(y_q=ReLU(x_q,z_x,z_y,\frac{s_x}{s_y})\)만 하면 된다.

 

양자화된 ReLU 레이어에 대한 소스 코드

import numpy as np


def quantization(x, s, z, alpha_q, beta_q):

    x_q = np.round(1 / s * x + z, decimals=0)
    x_q = np.clip(x_q, a_min=alpha_q, a_max=beta_q)

    return x_q


def quantization_int8(x, s, z):

    x_q = quantization(x, s, z, alpha_q=-128, beta_q=127)
    x_q = x_q.astype(np.int8)

    return x_q


def quantization_uint8(x, s, z):

    x_q = quantization(x, s, z, alpha_q=0, beta_q=255)
    x_q = x_q.astype(np.uint8)

    return x_q


def dequantization(x_q, s, z):

    # x_q - z might go outside the quantization range
    x_q = x_q.astype(np.int32)
    x = s * (x_q - z)
    x = x.astype(np.float32)

    return x


def generate_quantization_constants(alpha, beta, alpha_q, beta_q):

    # Affine quantization mapping
    s = (beta - alpha) / (beta_q - alpha_q)
    z = int((beta * alpha_q - alpha * beta_q) / (beta - alpha))

    return s, z


def generate_quantization_int8_constants(alpha, beta):

    b = 8
    alpha_q = -2**(b - 1)
    beta_q = 2**(b - 1) - 1

    s, z = generate_quantization_constants(alpha=alpha,
                                           beta=beta,
                                           alpha_q=alpha_q,
                                           beta_q=beta_q)

    return s, z


def generate_quantization_uint8_constants(alpha, beta):

    b = 8
    alpha_q = 0
    beta_q = 2**(b) - 1

    s, z = generate_quantization_constants(alpha=alpha,
                                           beta=beta,
                                           alpha_q=alpha_q,
                                           beta_q=beta_q)

    return s, z


def relu(x, z_x, z_y, k):

    x = np.clip(x, a_min=z_x, a_max=None)
    y = z_y + k * (x - z_x)

    return y


def quantization_relu_uint8(x_q, s_x, z_x, s_y, z_y):

    y = relu(x=x_q.astype(np.int32), z_x=z_x, z_y=z_y, k=s_x / s_y)
    y = np.round(y, decimals=0)
    y = np.clip(y, a_min=0, a_max=255)
    y = y.astype(np.uint8)

    return y


if __name__ == "__main__":

    # Set random seed for reproducibility
    random_seed = 0
    np.random.seed(random_seed)

    # Random matrices
    m = 2
    n = 4

    alpha_X = -60.0
    beta_X = 60.0
    s_X, z_X = generate_quantization_int8_constants(alpha=alpha_X, beta=beta_X)
    X = np.random.uniform(low=alpha_X, high=beta_X,
                          size=(m, n)).astype(np.float32)
    X_q = quantization_int8(x=X, s=s_X, z=z_X)
    X_q_dq = dequantization(x_q=X_q, s=s_X, z=z_X)

    alpha_Y = 0.0
    beta_Y = 200.0
    s_Y, z_Y = generate_quantization_uint8_constants(alpha=alpha_Y,
                                                     beta=beta_Y)
    Y_expected = relu(x=X, z_x=0, z_y=0, k=1)
    Y_q_expected = quantization_uint8(x=Y_expected, s=s_Y, z=z_Y)

    Y_expected_prime = relu(x=X_q_dq, z_x=0, z_y=0, k=1)
    Y_expected_prime_q = quantization_uint8(x=Y_expected_prime, s=s_Y, z=z_Y)
    Y_expected_prime_q_dq = dequantization(x_q=Y_expected_prime_q,
                                           s=s_Y,
                                           z=z_Y)

    print("X:")
    print(X)
    print("X_q:")
    print(X_q)

    print("Expected FP32 Y:")
    print(Y_expected)
    print("Expected FP32 Y Quantized:")
    print(Y_q_expected)

    Y_q_simulated = quantization_relu_uint8(x_q=X_q,
                                            s_x=s_X,
                                            z_x=z_X,
                                            s_y=s_Y,
                                            z_y=z_Y)
    Y_simulated = dequantization(x_q=Y_q_simulated, s=s_Y, z=z_Y)

    print("Expected Quantized Y_q from Quantized ReLU:")
    print(Y_q_simulated)
    print("Expected Quantized Y_q from Quantized ReLU Dequantized:")
    print(Y_simulated)

    # Ensure the algorithm implementation is correct
    assert (np.array_equal(Y_simulated, Y_expected_prime_q_dq))
    assert (np.array_equal(Y_q_simulated, Y_expected_prime_q))
  • 결과 값
$ python relu.py 
X:
[[ 5.8576202 25.822723  12.331605   5.385982 ]
 [-9.161424  17.507294  -7.489535  47.01276  ]]
X_q:
[[ 12  55  26  11]
 [-19  37 -16 100]]
Expected FP32 Y:
[[ 5.8576202 25.822723  12.331605   5.385982 ]
 [ 0.        17.507294   0.        47.01276  ]]
Expected FP32 Y Quantized:
[[ 7 33 16  7]
 [ 0 22  0 60]]
Expected Quantized Y_q from Quantized ReLU:
[[ 7 33 16  7]
 [ 0 22  0 60]]
Expected Quantized Y_q from Quantized ReLU Dequantized:
[[ 5.490196 25.882353 12.54902   5.490196]
 [ 0.       17.254902  0.       47.058823]]

Quantization Steps

  • Layer fusions
    : 레이어들을 하나로 묶어주는 단계
    : Conv-BatchNorm-ReLU 가 가장 많이 사용되고 있는 layer fusions 이다.
  • Formula Definition : 양자화를 할 때 사용하는 수식을 정의
    : Floating point type ☞ Integer point type (Float32 to Int8) , Quantization
    : Integer point type ☞ Floating point type (Int8 to Float32) , Dequantization
  • HW Deployment
    : Depending on the hardware (Calibration)
  • Dataset Calibration
    : 가중치를 변경하기 위한 파라미터를 데이터셋을 이용하여 계산한다.
  • Weight Conversion
    : 가중치를 Floating point type에서 Integer point type으로 변환한다.
  • Dequantization
    : 추론을 통하여 얻은 결과값을 역 양자화를 통해서 다시 Floating point type으로 변경함.

Layer fusions 

JINSOL KIM blog 참조 https://gaussian37.github.io/

  • 빨간색은 첫번째 Layer , 파란색은 두번째 Layer를 뜻한다.
  • 첫 줄은 각각 떨어져 있는 Layer들은 Conv2D, BatchNorm, ReLU 3항목 각각 Quantization 적용을 의미한다.
  • 둘째 줄은 Conv2D-BatchNorm-ReLU 한꺼번에 Quantization 적용을 의미한다.

모든 Layer에 Quantization을 적용하지 않는 이유

  • 양자화 횟수를 감소 시키면, 추론 시간과 정밀도와 재현율을 개선할 수 있다.
횟수를 대폭 줄이면 양자화 목적이 사라질 수 있기에 어떤 부분을 Layer Fusions을 할 지를 연구해야 한다.

신경망 정수형 양자화 종류

  • 신경망 양자화에는 3가지 종류가 있다.
  1. Integer Quantization
  2. Dynamic Quantization
  3. Static Quantization
Static Quantization 과 Quantization aware training은 위 항목 중 가장 빠르기 때문에 가장 흔하게 볼 수 있다.

 

Quantization Modes Data Requirements Inference Latency Inference Accuracy Loss
Dynamic Quantization None Usually Faster Smallest
Static Quantization Unlabled Fastest Smaller
Quantization Aware Training Labeled Fastest Smallest

출처 : Lei Mao blog

Dynamic Quantization

  • Dynamic Quantization을 사용하는 신경망 추론에서는 최대한 많은 integer ops를 사용한다.
  • 가중치는 런타임 이전에 정수로 양자화 되었다.
  • Output or Activation Tensor : 부동소수점 텐서
    :: Scales 과 Zero points 를 모르기 때문
  • 부동소수점 텐서를 구하면 /( (\alpha, \beta)\)를 찾을 수 있다.
  • tensor의 경우 Scale과 zero point를 계산하고 런타임 동안 부동소수점 텐서를 동적 정수 텐서로 양자화 한다.
예를 들면, Matrix Multiplication in Dynamic Quantization 의 경우 \(X_q\)를 이용하여 \(Y_{q,i,j}\) 대신 부동 소수점인 \(Y_{i,j}\)를 계산한다.

$$ Y_{i,j} = s_b(b_{q,j} - z_b) + s_X s_W \left[ (\sum _{k=1} ^{p} {X_{q,i,k}W_{q,k,j}})\ - \ (z_W \sum _{k=1} ^{p} {X_{q,i,k}}) \ - \ (z_X \sum {k=1} ^{p} {W_{q,k,j}}) \ + \ pz_Xz_W        \right] $$ 

  • 대부분의 경우 부동 소수점 활성화 텐서를 계산하기 위해 빠른 정수 ops에서 성능을 얻을 수 있다.
  • 위의 표에서 요약한 것처럼 Dynamic Quantization의 장점은 추론에 앞서 어떤 종류의 보정을 수행하기 위해
    어떠한 데이터도 필요하지 않다는 것이다.

 

Static Quantization

  • Clipping range가 사전에 미리 계산이 되어서 inference 시에는 고정된 값으로 사용되는 방법을 의미한다.
  • 고정된 Clipping range를 사용하기 때문에 이 방법은 추가적인 계산 비용이 발생하지 않지만 Dynamic Quantization
    방법에 비해 낮은 성능을 보이곤 한다.
  • Static Quantization의 Clipping range를 사전에 정하는 대표적인 방법은 샘플 입력 데이터를 준비하여 range를
    정해보는 것이다. 이 방법을 Calibration이라고 부른다.

 

 

 

 

 

참조자료 링크

  • https://kaixih.github.io/fused-batch-norm-activation #(Conv-BachNorm-ReLU)
  • https://www.youtube.com/playlist?list=PLC89UNusI0eSBZhwHlGauwNqVQWTquWqp
  • https://gaussian37.github.io 
  • https://leimao.github.io/article/Neural-Networks-Quantization/#Introduction
  • 대학원 강의 자료
반응형

'AI > Notions' 카테고리의 다른 글

Activation Function : Step/Linear Function  (0) 2022.12.27
Perceptron  (0) 2022.12.27
CNN (Convolutional Neural Network) 개념 정리  (0) 2022.12.14
반응형

▶ OpenCV Python 관련 글은 황선규 박사님의 강의내용을 정리하였음.

Github 소스

영상의 속성과 픽셀 값 참조

  • OpenCV는 영상 데이터를 numpy.ndarray로 표현한다.
import cv2

img1 = cv2.imread('cat.bmp', cv2.IMREAD_GRAYSCALE)
img2 = cv2.imread('cat.bmp', cv2.IMREAD_COLOR)

numpy.ndarray

  • ndim : 차원 수, len(img.shape)과 같음.
  • shape : 각 차원의 크기 (h, w) Gray scale or (h, w, 3) Color  
                 → (h,w,n) : n 값이 2이면 graysclae , 3이면 color 라고 생각해도 문제 없다.
  • size : 전체 원소 개수
  • dtype : 원소의 데이터 타입. 영상 데이터는 unit8

OpenCV 영상 데이터 자료형과 Numpy 자료형

OpenCV 자료형 Numpy 자료형 구분
cv2.CV_8U numpy.uint8 8비트 부호없는 정수
cv2.CV_8S numpy.int8 8비트 부호있는 정수
cv2.CV_16U numpy.uint16 16비트 부호없는 정수
cv2.CV_16S numpy.int816 16비트 부호있는 정수
cv2.CV_32S numpy.int32 32비트 부호있는 정수
cv2.CV_32F numpy.float32 32비트 부동소수형
cv2.CV_64F numpy.float64 64비트 부동소수형
cv2.CV_16F numpy.float16 16비트 부동소수형
  • 그레이스케일 영상 : cv2.CV_8UC1 → numpy.uint8, shape = (h, w)
  • 컬러 영상 : cv2.CV_8UC3 → numpy.uint8, shape = (h, w, 3)

영상의 속성 참조 예제 코드

img1 = cv2.imread('cat.bmp', cv2.IMREAD_GRAYSCALE)
img2 = cv2.imread('cat.bmp', cv2.IMREAD_COLOR)

print('type(img1):', type(img1)) # type(img1): <class 'numpy.ndarray'>
print('img1.shape:', img1.shape) # img1.shape: (480, 640)
print('img2.shape:', img2.shape) # img2.shape: (480, 640, 3)
print('img2.dtype:', img2.dtype) # img2.dtype: uint8

h, w = img2.shape[:2] # h: 480, w: 640
print('img2 size: {} x {}'.format(w, h))

if len(img1.shape) == 2:
	print('img1 is a grayscale image')
elif len(img1.shape) == 3:
	print('img1 is a truecolor image')
img1 = cv2.imread('cat.bmp', cv2.IMREAD_GRAYSCALE)
img2 = cv2.imread('cat.bmp', cv2.IMREAD_COLOR)

for y in range(h):
	for x in range(w):
		img1[y, x] = 255
		img2[y, x] = [0, 0, 255]   #for문은 절대 사용 금지
        
        
# img1[:,:] = 255
# img2[:,:] = (0, 0, 255)

 

반응형

'스터디 > Computer Vision' 카테고리의 다른 글

OpenCV :: Mat Class (1)  (0) 2023.01.10
OpenCV :: 기본 자료형 클래스  (0) 2023.01.09
영상의 밝기 조절 과 산술 연산  (0) 2023.01.05
히스토그램 (Histogram)  (2) 2022.12.28
반응형

가우스 소거법

선형시스템의 해를 구하는 방법


가장 단순한 형태의 선형시스템은 아래와 같다. 이 선형시스템의 해는 무엇인가?

$$ ax = b $$ 

해가 하나인 경우 

$$ 3x=6 $$

 

해가 없는 경우 

$$ 0x =y $$

 

해가 여러개인 경우

$$ 0x = 0 $$

 

  • a = 0 이면 특이하다.
    • ax = b의 해가 곧장 나오지 않는다.
    • a의 역수 (inverse)가 존재하지 않는 경우, a가 특이(singular)하다고 한다.
  • 해가 있으면 선형시스템이 "consistent"
  • 해가 없으면 선형시스템이 "inconsistent"

 

 

$$ Ax = b $$

 

가우스 소거법 (Gauss elimination)

  • 가우스 소거법은 임의의 m x n 선형시스템의 해를 구하는 대표적인 방법이다.
  • 아래 두단계로 수행된다.
  1. Forward elimination (전방소거법)
    주어진 선형시스템을 아래로 갈수록 더 단순한 형태의 선형방정식을 가지도록 변형한다.
  2. Back-substitution (후방대입법)
    아래에서부터 위로 미지수를 실제값으로 대체한다.

 

가우스 소거법 실제로 해보기

 

 $$ \begin{bmatrix}
        1 & 2 & 1\\
        1 & 2 & 3\\
        2 & 3 & -1\\
       \end{bmatrix}
       \begin{bmatrix}x_1\\x_2\\x_3\end{bmatrix} =
       \begin{bmatrix}1 \\3 \\-3 \end{bmatrix} $$

 

  1. 1행 1열을 기준으로 잡기
  2. r2 ← r2 - r1
  3. r3 ← r3 - 2r1
  4. 2행 2열을 기준으로 잡기
  5. r2 ↔ r3
  6. r2 ← −r2
  7. 3행 3열을 기준(pivot)으로 잡기
  8. r3 ← 1/2 r3

 

가우스 소거법에서 전방소거법은
주어진 선형 시스템의 rank를 알려주고, 선형시스템이 해가 있는지 아니면 없는지 알려준다.
반응형

'AI > AI math' 카테고리의 다른 글

경사 하강법 (Gradient decsent)  (0) 2022.12.27
Lecture notes - Linear system (coding)  (0) 2022.12.14
Lecture notes - Linear system  (0) 2022.12.14
반응형

Rich feature hierarchies for accurate object detection and semantic segmentation

  • R-CNN : Object detection algorithm
    • 입력 이미지에 Selective Search 알고리즘을 적용하여 박스 추출한다. ( = 2,000 ea)
    • 모든 박스를 227 x 227 크기로 리사이즈 한다.
    • 미리 학습시킨 데이터를 (Image Net) 통하여 CNN을 통과시켜 4096 특징 벡터를 추출한다.
    • 추출된 벡터로 각각의 클래스마다 학습시켜놓은 SVM Classifier를 통과 시킨다.
    • Bounding box regression을 적용하여 Box 위치를 조정한다.
    • ImageNet : 대규모(large-scale) 데이터 셋
  • Selective serach algorithm
    • 주변 픽셀간 유사도를 기준으로 오브젝트가 있을 법한 영역만 찾는 방법이다. ( = region proposal)
  • Region proposal
    • 주어진 이미지에서 물체가 있을법한 위치를 찾는 것.
    • Selective search는 주변 픽셀간의 유사도를 기준으로 세그멘테이션을 생성하고, 이를 기준으로
      물체가 있을법한 Box를 추론한다.
  • Feature extraction
    • 미리 ImageNet으로 학습된 CNN을 가져와서 Object detection 용 데이터셋으로 Fine tuning 한 뒤
      Selective search 결과로 뽑힌 이미지들로부터 특징 벡터를 추출한다.
    • Fine tuning : CNN 층에서 추출된 벡터로 SVM 분류 학습을 시켜서 얻은 mAP 을 비교하는 것
  • mAP (mean average precision)
    • 합성곱 신경망의 모델 성능 평가를 할 때 mAP을 이용한다.
    • Precision-recall 곡선과 Average Precision은 CV에서 Object dection 알고리즘 성능 평가를 위해 사용.

                                   1. 2개의 알고리즘이 존재한다고 가정한다.  
                                   2. 첫번째 알고리즘은 사람 인식 검출율이 99% 이지만, 한장당 10건 정도의 오검출이 발생한다.  
                                   3. 두번째 알고리즘은 사람 인식 검출율이 50% 이지만, 오검출이 미발생한다.  
                                       → 성능 평가를 위해서는 검출율과 정확도를 동시에 고려해야 한다.

  • Classification
    • CNN을 통해 추출한 벡터를 가지고 각각의 클래스를 SVM Classifier 학습.
    • 주어진 벡터를 놓고 해당 물체가 맞는지 아닌지를 구분하는 Classifier 모델을 학습시키는 것.

이미 학습된 CNN Classifier을 두고 왜 SVM을 별도로 학습 시킬까?

CNN Classifier를 쓰는 것이 SVM을 사용할 때보다 mAP 성능이 4%정도 낮아진다.
이것은 아마도 fine tuning 과정에서 물체의 위치 정보가 유실되고 무작위로 추출된 샘플을 학습하여
발생한것으로 보인다. (일부 저자들의 의견) → SVM을 붙여서 학습시키는 기법은 현재 사용되지 않음.

  • Bounding box regression

물체 위치를 찾고, 물체 종류를 판별할 수 있는 Classification 모델을 학습 시켜서 찾아낸 박스 위치를
교정해줘서 성능을 끌어올리게 하는 행위이다.

  • Box 표기법

$$ P^i=(P^i_x,P^i_y,P^i_w,P^i_h) $$

  • Ground Truth에 해당하는 Box 표기법

$$ G = (G_x,G_y,G_w,G_h) $$

      -. x, y는 점이기 때문에 이미지의 크기에 상관없이 위치만 이동시켜주면 된다.

      -. 너비와 높이는 이미지의 크기에 비례하여 조정해야 함.

      -. 위 두가지 특성을 반영하여 P를 이동시키는 함수의 식을 작성하면 아래와 같다.

 

$$ G_x = P_wdx(P)+Px $$

$$ G_y = P_hdy(P)+Py $$

$$ G_w = P_wexp(dw(P) $$

$$ G_h=P_hexp(dh(P)) $$

 

       우리가 학습을 통해서 얻고자 하는 함수는 'd 함수'

  1. 저자들은 이 d 함수를 구하기 위해 CNN을 통과할 때 pool5 레이어에서 얻어낸 특징 벡터를 사용하고,
    함수에 학습 가능한 웨이트 벡터를 주어 계산한다.

$$ d_x(P) = w^t_x\phi_5(P) $$

  1. 웨이트를 학습 시킬 Loss Function을 세워보면 다음과 같다.
  2. 일반적인 MSE Error Function에 L2 normalization을 추가한 형태다. (람다 1000으로 설정)

$$ w_x = argmin\sum_{i}^{N}(t^i_x - w^T_x\phi_5(P^i))^2+\lambda||w_x||^2 $$

  1. t는 P를 G로 이동시키기 위해서 이동량을 의미한다. 식은 아래와 같다.

$$ t_x=(G_x - P_x)/P_w \\ t_y=(G_y-P_y)/P_h\\ t_w=log(G_w/P_w)\\ t_h=log(G_h/P_h) $$

  • CNN을 통과하여 추출된 벡터와 x,y w,h를 조정하는 함수의 웨이트를 곱해서 Bounding Box를 조정해주는
    선형 회귀를 학습시키는 것이다.

 

  • R-CNN 학습
    1. Image Net으로 이미 학습된 모델을 가져와 Fine tuing 하는 부분
    2. SVM Calssifier를 학습시키는 부분
    3. Bounding Box Regression
    속도 및 정확도
  • 속도 저하의 가장 큰 병목 구간은 Selective Search를 통한 2000개의 영역을 모두 CNN infenrence를 진행하기 때문임.
  • R-CNN은 Image 1개당 GPU에서 약 13초, CPU에서 약 50초가 소요됨.
반응형
반응형

시리얼 통신

UART(Universal Asynchronous Receiver / Transmitter) : 비동기식 시리얼 통신

  • 병렬 데이터를 직렬 데이터로 바꿔 전송하는 통신
  • 1:1
  • 전이중(Full Duplex) 통신 : RX, TX 송/수신선 각각 존재
  • 송신부와 수신부의 통신속도인 buadrate를 일치시켜서 전송하는 비동기식 통신 방식이다.

SPI(Serial Peripheral Interface) : 동기식 시리얼 통신

  • 하나의 마스터가 여러 슬레이브와 연결할 수 있다는 점에서 UART보다는 I2C와 유사하다.
  • 1:N
  • 전이중(Full Duplex) 통신 : SCK, MOSI, MISO, SS
  • SPI는 풀업 저항이 필요 없다.

I2C(Inter-Integrated Circut) : 동기식 시리얼 통신

  • 다수의 하드웨어와 연결이 가능하다.
  • N:N
  • 반이중(Half Duplex) 통신
  • 통신 속도가 느리기 때문에 제어 용도로 많이 활용한다.
  • 풀업 저항 필요
    • SDL, SCL이 Open-Drain

UART , USART 비교

UART

  • 범용 비동기화 송수신 (전이중)
  • 속도가 빠르지만, 데이터의 시작과 끝을 알기 위해 Start/Stop bit가 필요하다.
  • 오류 검출을 위한 Parity bit가 있음.

USART

  • 범용 동기/비동기화 송수신 (반이중)
  • 동기 모드 USART에서는 데이터 동기화를 위해 별도의 Clock pulse를 전송한다.
  • 데이터 송수신 효율이 높다 (데이터를 구분하지 않고 Clock 유무만 확인)
  • 데이터와 타이머가 모두 필요하고, 데이터를 고정 속도로 전송한다.
  • 데이터를 일반적으로 블록화하여 전송한다.

TCP, UDP 그리고 OSI 7 Layer

TCP (TCP : 패킷 추적 및 관리 / IP : 데이터의 전송 처리)

  • 신뢰성 있는 데이터 전송을 지원하는 연결 지향형 프로토콜
  • 3-way handshaking 과정을 통하여 연결 후 통신을 시작한다.
  • 흐름 제어와 혼잡 제어를 지원하고 데이터의 순서를 보장한다.
    • 흐름 제어 : 보내는 측과 받는 측의 데이터 처리속도 차이를 조절한다.
    • 혼잡 제어 : 네트워크 내의 패킷 수가 넘치게 증가하지 않도록 방지한다.

   특징

  • 연결형 서비스로 가상 회선 방식을 제공한다.
  • 데이터의 전송 순서 보장
  • 데이터의 경계를 구분하지 않는다
  • 신뢰성 있는 데이터 전송
  • UDP보다 전송속도가 느리다

연결 설정(3-way handshaking)과 해제(4-way handshaking)

 

UDP

  • 비연결형 프로토콜
  • 보내는 쪽에서 일방적으로 데이터를 전달하는 통신 프로토콜
  • TCP와는 다르게 연결 설정이 없으며, 혼잡 제어를 하지 않기 때문에 TCP보다 전송 속도가 빠르다.
  • 데이터 전송에 대한 보장을 하지 않기 때문에 패킷 손실이 발생할 수 있다.

   특징

  • 비연결형 서비스로 데이터그램 방식을 제공
  • 비신뢰성
  • 데이터의 경계를 구분
  • 패킷 오버해드가 적어 네트워크 부하 감소
  • 혼잡 제어를 하지 않기 때문에 TCP보다 빠름
  • TCP의 handshaking 같은 연결 설정이 없음

 

TCP vs UDP

반응형

'임베디드 개발 노트' 카테고리의 다른 글

SocketCAN  (0) 2024.04.22
ALSA  (0) 2023.12.21
Automotive SPICE (업데이트 中)  (0) 2023.06.20
CAN (업데이트 中)  (0) 2023.06.20
Analog /Digital Signal , Ground  (0) 2023.04.06
반응형

1. CNN 개요

  • Image는 2차원 데이터고, 2차원 데이터를 1차원 벡터로 평활화하여 신경망 모델에 학습시켜야 한다.
  • CNN의 특징은 Image Size를 줄이면서, 특징을 나타내는 이미지들을 추출 해낼 수 있다.
  • FC Layer에 도달하기 전까지 평활화 과정 없이 이미지 정보를 효과적으로 유지하며, 특징 픽셀들을 추출한다.
    위 과정에서 인접한 픽셀과의 관계를 효과적으로 인식 할 수 있고, 이미지의 특징을 모으거나 강화할 수 있다

CNN 주요 개념

  • 정사각형 행렬 모양의 Filter가 이미지를 순회하며 Convolution을 계산한다.
  • 계산 결과를 이용하여 Feature map을 만든다.
  • Feature map을 모아 한 이미지에서 활성화된 픽셀만을 모은 Activation map을 만든다.
  • 위 3가지 과정을 Convolution Layer라고 한다.
  • Convolution layer의 shape는 Filter 크기, Stride, Padding 등에 영향을 받는다.
  • 출력된 Convolution layer를 또 하나의 입력 데이터로 삼아, Pooling 과정을 거친다.
  • 위 두 과정을 반복하면 이미지의 크기는 줄어들고, 채널이 늘어난다.

이미지 데이터에 대한 이해

  • 우리가 눈으로 보는 컬러 이미지는 RGB 공간에 저장된다. (RED, GREEN, BLUE)

  • 흑백 이미지라면, 이미지는 RGB 공간이 아닌, Gray scale 공간에 저장된다.
  • Pixel 값은 흰색의 강도를 나타낸다.
  • 작을수록 검은색에 가깝고, 클수록 흰색에 가까움
  • 이미지가 어떤 색 공간에 저장되는지에 따라 이미지의 depth가 달라진다.
    • RGB 공간의 경우 이미지 depth는 " 3 "
    • Gray scale 공간의 경우 " 1 "
    • 이미지를 하나의 depth 별로 쪼개어 나타냈을때 각 한장의 이미지를 채널이라고 함.

입력 데이터

  • CNN 신경망에 입력되는 데이터는 (Height, Width, Channel) 형태의 이미지다.
  • 만약 CNN 신경망에 이미지 1장이 입력된다고 가정하면, 28 x 28 픽셀의 컬러 이미지라면,
    해당 입력 데이터의 shape는 (28, 28, 3) 이고, 흑백 이미지라면 (28, 28, 1)이 된다.

Convolution Layer

1. Filter ( = Kernel)

  • 이미지의 특징을 뽑아낼 거름망 역할을 수행한다.
  • 2차원 정사각 행렬 형태이다.
  • 자신의 크기 만큼 이미지를 확대하고, 해당하는 부분만 확인한다.
  • 해당하는 영역의 값들을 하나의 값으로 뽑아내기 위해, 합성곱 연산 수행한다.
  • Neural Network에서 Weight(가중치)라고 판단하면 된다.
  • 처음에는 임의의 값을 부여한 뒤, 학습을 통해 적절한 filter 값을 찾음

2. Channel

  • Convolution을 구성하는 레이어의 수를 의미한다.
  • 처음에는 이미지의 depth (color, gray 여부) 이지만, 이후에는 필터의 개수가 된다.
  • 이미지는 입력층을 지나 Convolution Layer를 지날 때 마다 값이 달라진다.

3. Convolution (합성곱)

  • Gray Scale의 픽셀값으로 나타내면 아래와 같다.

  • Filter를 가지고 합성곱 연산을 아래와 같이 수행해본다.

4. Stride (보폭)

  • Filter가 Convolution 연산을 수행하기 위해 이동하는 양.
  • Filter가 지정된 Stride만큼 오른쪽으로, 위에서 아래로 이동한다.

5. Feature map

  • 필터 설정한다.
  • 같은 값을 갖는 필터를 이용하여 입력된 이미지 데이터 탐색한다.
  • 필터가 계산하는 합성곱 연산 결과를 2차원 행렬에 저장한다.

  • 위 합성곱을 수행하면, 필터 가중치에 해당하는 이미지 특징들이 추출된다.
  • 아래와 같이 “ 5 “ 를 나타내는 이미지에서 맨 위 가로 부분을 뽑아서 인식하고 싶다면
    가로로 배열되어 있는 성분을 강조하는 3 x 3 크기의 필터를 적용할 수 있다.
  • 숫자가 없는 부분의 픽셀 값은 모두 0이라 하여,
    Convolution을 수행하면 오른쪽과 같이 기존 이미지에 비해 가로 성분이 강조된 Featured map이 출력된다. 
  • Feature map에서 한변의 길이가 중요하다. ⇒ 한변의 길이가 정수가 되도록 Stride를 설정하는 것이 중요함.
  • 5 x 5 이미지, 3 x 3 필터, 1 보폭 : Feature Map 사이즈 3 x 3
  • 5 x 5 이미지, 3 x 3 필터, 2 보폭 : Feature Map 사이즈 2 x 2

5. Padding

  • 위와 같이 필터를 적용해서 작업을 계속 하면, 이미지 사이즈가 작아지게 된다.
  • 이미지 사이즈가 작아지면 데이터 손실이 발생한다.
  • 이를 방지하기 위해 이미지 레이어 외부에 일정한 값의 레이어를 덧덴다.
    ⇒ 일반적으로 상하좌우 같은 크기의 값을 갖는 0을 덧대는 패딩을 사용함.

  • 패딩 효과
    • Convolution Layer 출력 데이터 크기가 과도하게 축소되는걸 방지한다.
    • Neural Network가 이미지 외곽을 인지할 수 있다.

Activation Map

  • Feature map 각 픽셀에 대해 활성화 함수를 적용한 결과
  • Convolution Layer 최종 출력 결과
  • 일반적으로 ReLU 함수 사용

Pooling Layer

  • Convolution Layer 출력인 Activation Map의 크기를 줄이는 과정
  • Activation Map에 인접한 부분에서 일정한 기준에 따라 픽셀 하나의 값을 뽑는다
  • 일정한 크기의 커널을 두고 Activation map을 슬라이딩 하며 가장 큰 값(Max Pooling)혹은
    가장 작은 값(Min Pooling) 혹은 평균값(Average Pooling)을 뽑는다
  • Pooling 커널이 슬라이딩하는 것은 [Filter ( = Kernel)]가 움직이는 것과 같은 원리이므로, 해당 커널 역시 Stride가 있다.
  • Kernel size : 2 x 2 , Stride : 2 일 때 Pooling 종류에 따라 Activation Map 변화

  • 커널 영역에서 상관성이 가장 높다고 판단하여 MAX POOLING을 제일 많이 사용
    • 단점 : 데이터 손실
    • 장점 : 연산량, 메모리 사용 ↓, 과적합 (Overfitting) 방지 및 데이터 특정 부분이 변형되어도 동일한 결과 출력

Fully Connected Layer

  • 위와 같은 과정이 반복되면 기존 이미지는 추상화되어 특징들만 남게 된다.
  • 이런 결과를 평탄화(flatten)하여, 1차원 벡터로 Fully Connected Layer에 전달한다.

Fully Connected Layer가 하는일

  1. 활성화 함수를 적용하여 원하는 작업을 수행한 뒤, 최종 결과 추출
  2. Optimizer는 Convolution Layer와 Fully Connected Layer의 가중치에 오류들을 역전파하며 각 가중치들을 조정해 나간다.

Model Architecture

  • 3차원 이미지로 R,G,B 채널로 구성
  • 4 x 4 필터 적용 depth : 3 (RGB 공간에 존재) ⇒ shape (4, 4, 3)
  • 필터는 12개의 값으로 구성된 육면체이다.
  • 이 상태에서 합성곱 연산을 하기 때문에 12개의 값을 모두 더한것이 Feture map 한칸에 저장됨.
  • Stride 값은 2 이고, 패딩을 적용 안하면 Feature map 한 변의 길이는 9 가 된다.
  • 이제 이미지에 각각 다른 필터 6개를 적용한다고 하자. 6개의 서로 다른 특징들을 추출하겠다는 의미다.
  • 예컨대 하나의 필터는 고양이의 귀를, 하나는 고양이의 눈을, 또 다른 하나는 고양이 수염을 인식하는 방식이다.
  • 서로 다른 부분을 추출하므로 각각의 필터가 가지고 있는 가중치는 모두 다르다.
  • 그렇다면 6개의 필터를 활용해 Convolution을 적용한 결과로 모두 9x9짜리의 Feature Map 6개를 결과로 얻게 된다.
  • 각각의 Feature Map에 ReLU 활성화 함수를 적용하여 Activation Map을 만든다.
  • 따라서 Convolution Layer에서 얻게 되는 데이터의 shape은 (9, 9, 6)이 된다.
  • 위의 과정을 통해 Convolution 출력 레이어의 최종 결과의 채널은 필터의 개수와 같아 진다는 것을 알 수 있다.
  • 특히 위에서 말했듯 필터가 추출하고 싶은 이미지 특징을 나타낸다는 점을 고려한다면, 추출하고 싶은 특징의 수를 설정한 뒤,
    이것을 모두 필터로 설정해 버리면 된다.
  • 그 결과, Convolution Layer의 채널 수로 추출하고자 하는 특성의 수 만큼을 가지게 된다.
  • 위의 Activation Map에 커널 사이즈를 3 x 3, stride를 2로 하여 Max Pooling을 적용하자.
  • 그러면 각각의 Activation Map이 3 x 3 사이즈로 축소된다.
  • 이렇게 모든 Convolution과 Pooling의 과정을 거친 후, 모든 데이터를 평활화한다.
  • 그러면 (3, 3, 6) shape의 데이터가 (54, ) shape의 1차원 벡터가 된다.
  • 이 벡터를 Fully Connected Layer에 주입하고, 활성화 함수로 Sigmoid 함수를 사용하여 이진 분류 문제를 풀면 되는 것이다.
  • 한 장의 이미지를 주입할 때 CNN 모델의 아키텍쳐는 위와 같다.
  • 이제 위와 같은 이미지가 여러 장 있다면, 데이터의 shape이 4차원이 될 것이다.
  • 기존의 3차원 구조에 이미지의 개수가 한 차원으로 더 추가되는 것이다. 다음 실습에서 살펴 볼 Tensorflow에서는
    이미지 데이터를 (입력 이미지 개수, 이미지 높이, 이미지 너비, 채널 수), 즉, (Num, Height, Width, Channels)로 표현한다.
  • 차원이 한 차원 더 더해지는 것일 뿐, 뒤의 과정은 동일하다.
  • 이렇게 여러 장의 이미지에 Convolution과 Pooling을 여러 번 적용하고(여러 층을 만든다는 의미이다.),
    학습을 통해 특징을 추출해낸 뒤 Fully Connected Layer에 주입하여 원하는 작업을 수행하는 것이 CNN 알고리즘의 원리이다.
반응형

'AI > Notions' 카테고리의 다른 글

Activation Function : Step/Linear Function  (0) 2022.12.27
Perceptron  (0) 2022.12.27
Quantization  (0) 2022.12.26
반응형

1. 다음 3 x 3 행렬 A를 정의하는 numpy 코드를 작성하세요.

 

$$ A = \begin{pmatrix} 1&2&1 \\ 1&2&3 \\ 2&3&-1 \end{pmatrix} $$

import numpy as np

A = np.array(([1, 2, 1], [1, 2, 3], [2, 3, -1]))

print(A)
print(np.shape(A))

 

2. 다음 3-Vector b를 정의하는 numpy 코드를 작성하세요.

 

$$ A = \begin{pmatrix} 1\\ 3\\ -3\end{pmatrix} $$

import numpy as np

b = np.array([1, 3, 3])

print(b)
print(np.shape(b))

 

3. 위 행렬 A를 구하는 역행렬 코드를 numpy linalg 서브모듈의 inv() 함수를 이용해 작성하세요.

A_inv = np.linalg.inv(A) # A의 역행렬 

print(A_inv)
print(np.shape(A_inv))

 

4. 선형시스템 Ax=b 의 해를 구하는 코드를 작성하세요.

 

$$ \begin{pmatrix}
1&2&1\\
1&2&3\\
2&3&-1\end{pmatrix}
\begin{pmatrix}
x_1\\
x_2\\
x_3\end{pmatrix} 
=
\begin{pmatrix}
1\\
3\\
-3\end{pmatrix} $$

x = A_inv @ b

print(x)
print(np.shape(x))

 

5. 4번의 식을 검증하는 코드를 작성하세요.

x = A_inv @ b

print(x)
print(np.shape(x))
반응형

'AI > AI math' 카테고리의 다른 글

경사 하강법 (Gradient decsent)  (0) 2022.12.27
Lecture Notes - Gauss Elimination  (0) 2022.12.15
Lecture notes - Linear system  (0) 2022.12.14

+ Recent posts