support vector machine

• 임의 dataset의 decision boundary 설정 시, boundary와 가장 가까운 data point와의 간격(margin)을 최대로 하는 선을 정의
• $\theta^T\vec{x}=w^T\vec{x}+b$
  • $\theta_0=b$로 해석
  • $w^T\vec{x}=\theta_1x_1+...+\theta_nx_n$
  • y = -1 or 1로 나타남(binary classification)
• 벡터 $\vec{p}=x_n-x$에 대해
  • $\frac{\vec{w}^T}{||w||}\vec{p}=\frac{1}{||w||}[\vec{w}^Tx_n+b-(wx^T+b)]=\frac{1}{||w||}$
  • $|\vec{w}^Tx_n+b|=1$인 조건 하에 $\frac{1}{||w||}$를 최대화
    • $|\vec{w}^Tx_n+b|=y_n(\vec{w}^Tx_n+b)$, $\vec{w}^Tx_n+b$의 부호에 의해 +1 혹은 -1로 값이 결정됨
    • 벡터 $\vec{w}$에 대해 $||\vec{w}||^2=w^Tw$
    • $\frac{1}{||w||}$의 최대화 = $||w||$의 최소화, 즉 미분값을 최소화하게 되므로 $||w||=\frac{1}{2}w^Tw$

Lagrange multiplier

• $f(x, y) = ax + by = k$, $g(x, y) = x^2+y^2 = r^2$인 함수 f, g를 가정
  • f와 g가 접하게 되면 gradient가 동일 : $\nabla f = \lambda\nabla g$
  • $\lambda$ : lagrange multiplier
  • $L(x,y,\lambda) = f(x,y) - \lambda(g(x,y) + c)$
• $\nabla L=\frac{\partial L}{\partial x} = \frac{\partial f}{\partial x} - \lambda\frac{\partial g}{\partial x} = 0$
  • $\frac{\partial f}{\partial x}=\lambda\frac{\partial g}{\partial x}$
• SVM 계산에 있어 $f=\frac{1}{2}w^Tw$, $g=y_n(x^Tx_n+b)-1\geq0$
  • $L(w,b,\lambda) = \frac{1}{2}w^Tw+\sum\lambda_i[-y_i(w^Tx_i+b)-1]$
  • $\frac{\nabla L}{\partial w}=0=w-\sum\lambda_iy_ix_i\\\rArr w=\sum\lambda_iy_ix_i$로 SVM weight w 계산
  • $\frac{\nabla L}{\partial b}=0=\sum\lambda_iy_i$
• $L(w,b,\lambda) = \frac{1}{2}w^Tw+\sum\lambda_i[-y_i(w^Tx_i+b)-1]$에서
  • $w=\sum\lambda_iy_ix_i$
  • $\sum\lambda_iy_i=0$
  • $L(w,b,\lambda)=\sum\lambda_i+\frac{1}{2}w^Tw-\sum\lambda_iy_iw^Tx_i\\=\sum\lambda_i-\frac{1}{2}w^Tw$

How to solve SVM

• SVM : $y(w^Tx_i+b)\geq1$일 때 $\frac{1}{2}w^Tw$의 최소값을 계산하는 것
• Lagre multiplier : $L(w, b, \lambda) = \frac{1}{2}w^Tw-\sum\lambda[y_i(w_i^Tx_i+b)-1]$
  • $sup_\lambda L(x, \lambda)$ : $\lambda$에 대해 가질 수 있는 L의 최댓값을 찾는 것
• SVM의 해 $p^*=inf_\lambda sup_\lambda L(x, \lambda)$ : L이 가질 수 있는 최댓값 중 하한선
  • $sup_\lambda L(x, \lambda)$는 $\sum$식이 음수일 땐 $\frac{1}{2}w^Tw$지만, 양수일 땐 무한으로 발산
  • sup값이 가질 수 있는 하한선은 즉 $\frac{1}{2}w^Tw$이 됨
• Lagrange dual function : $g(\lambda)=inf_{w,b}L(w,b,\lambda)$인 함수 g를 정의
  • $\lambda \geq0$일 때 $g(\lambda)\leq p^*$ : $g=inf\ L\leq L(x, \lambda)$이기 때문
  • $p^*$를 구하기 어렵다면 $g(\lambda)$를 구한 후 $p^*=sup_\lambda g(\lambda)$를 계산하는 방법도 있음
• $g(\lambda)=inf_{w,b}L(w,b,\lambda)$
  • $\frac{\partial L}{\partial w}=w-\sum\lambda_i y_ix_i=0$
  • $\frac{\partial L}{\partial b}=\sum\lambda_iy_i=0$
  • 즉 $g(\lambda)=-\frac{1}{2}w^Tw+\sum\lambda_i$

regularization

• Overfitting : regression 식의 feature 개수가 너무 많아지면, 학습 데이터에 대한 정확도는 높아지지만 새로운 데이터에 대한 정확도는 오히려 낮아지는 현상
  • feature 수를 줄이거나, regularization을 통해 완화
  • feature 수를 줄일 경우 보존할 feature를 선택해야 하는 문제가 존재 ( model selection algorithm )

• regularization
  • 모든 feature의 영향을 보존
  • parameter를 최소화하여 각 feature의 영향을 경감
• cost function $J(\theta)=\frac{1}{2m}\sum(H_\theta(x^i)-y^i)^2+\frac{\lambda}{2m}\sum\theta_i^2$
  • $\lambda$ : regularization parameter
  • $\lambda$가 커질수록 underfitting, 작아질수록 overfitting
  • 이처럼 학습이 아닌 실험적으로 찾아야 하는 값을 hyper-parameter라고 함
• normal eq. : $\theta = (X^TX+\lambda L)^{-1}X^Ty$

Model Evaluation

• Training / Test set : 데이터 중 일부는 학습에, 일부는 검증에 사용
• holdout validation : 데이터를 training / validation / test로 분리하여 학습
  • validation 데이터를 통해 모델을 최적화
  • 해당 모델을 test 데이터를 통해 학습 정도를 판별
• Bias vs Variance
  • Variance가 높을수록 모델의 degree, complexity가 높아짐
  • Bias가 높을수록 제대로 학습되지 않은 상태
• 오차에 대해
  • 모델 degree가 높을수록 train set의 cost는 감소하나, valid set은 감소하다가 일정 이상부터 오히려 증가
  • 큰 train / valid cost = Bias가 높다, underfitting
  • 큰 valid cost / 작은 train cost = Variance가 높다, overfitting
• 정규화 parameter $\lambda$에 대해
  • $\lambda$가 커질수록 train cost는 증가하고, valid 코스트는 감소하다 증가한다
  • valid cost가 크고, train cost가 작으면 variance가 큰 상태
  • train/valid cost가 모두 크면 bias가 큰 상태

• K-fold cross validation
  • 데이터를 K개로 분할
  • 이중 1개를 validation으로 선정하고, 나머지를 training set으로 선정
  • 모든 subset에 대해 돌아가며 학습 : subset 크기가 클 수록 train cost는 증가하고, valid cost는 감소
• learning curve
  • Bias가 높은 경우 : 일정 error 이하로는 학습되지 않음
  • 최적화된 경우 : 낮은 error로 학습되나 충분한 반복 필요
  • overfitting된 경우 : 최적 반복 지점에서 학습을 중단하지 않으면 valid cost가 역으로 높아질 수 있음

• Overfitting의 대처법
  • training set의 크기를 증가
  • feature 개수를 감소
  • regularization parameter를 증가
  • iteration 감소
• Underfitting 대처법
  • feature 개수 증가, 모델 degree 증가
  • regularization parameter 감소
  • iteration 증가

Classification

• 입력받은 데이터가 속하는 카테고리를 분류
  • 스팸 필터링
  • 의료 보조
  • 이미지 분류(Computer Vision)
• 임의 데이터셋
  

  

  • linear regression : y=ax + b꼴로 모델 형성
    • 일정 카테고리로 분류되는 데이터의 경우, linear regression 적용 시 카테고리를 크게 벗어나는 데이터에 의해 오차가 커질 위험이 있음

Logistic Regression

• 데이터가 2가지 class로 분류되었음을 가정
  • 예측하고자 하는 모델 범위는 [0, 1]
  • 클래스가 속하는 카테고리는 0 혹은 1로 구분
• $H_\theta(x)=g(\theta^Tx),\ g(k)=[1+e^{-k}]^{-1}$
  • g(k)를 signoid 혹은 logistic 함수라 부름
  • k가 무한이면 g(k)=1, -무한이면 g(k)=0
  • $\theta^Tx$ : 두 데이터 그룹을 나누는 기준선
• $P(y=1|x, \theta)=H_\theta(x)$, $P(y=0|x, \theta)=1-H_\theta(x)$
• log-likelihood $l(\theta) = log(L(\theta))\\\sum_{i=1}^m[y^ilog(H_\theta(x^i))+(1-y^i)log(1-H_\theta(x^i))]$
  • maximum log-likelihood : m=1 가정, $\frac{\partial l(\theta)}{\partial\theta_j}=[\frac{y}{H_\theta(x)}-\frac{(1-y)}{1-H_\theta(x)}]\frac{\partial H_\theta(x)}{\partial\theta_j}\\=[\frac{y}{H_\theta(x)}-\frac{(1-y)}{1-H_\theta(x)}]H_\theta(x)(1-H_\theta(x))x_j\\=(y-H_\theta(x))x_j$

Newton's method

• 최대/최소값을 찾는 방법
• f(x) = 0이 되게 하는 x를 탐색
  • $x_{t+1}=x_t-\frac{f(x)}{f'(x)}$
• $J'(\theta)$에 대해 $\theta_{t+1} = \theta_t-\frac{J'(\theta_t)}{J''(\theta_t)}$
• multiple vatiant function에 대해
  • $\vec{x_{t+1}}=\vec{x_t}-H^{-1}\nabla f(\vec{x_t})$
    • $(H_x)_{i,j} = \frac{\partial^2f}{\partial x_i\partial x_j}$ : Hessian Matrix

• Binary Classification / Logistic Regression : $\theta^Tx$가 0보다 큰가 / 작은가 여부로 분류
  • 모델 $H_\theta=g(\theta^Tx),\ g(z)=\frac{1}{1+e^{-z}}$
  • log-lokelihood $l(\theta) = log(L(\theta))\\=\sum_i[y^ilogh_\theta(x)+(1-y^i)log(1-h_\theta(x))]$
  • gradient ascent $\theta_j=\theta_j+\frac{\alpha}{m}\sum_iy^i-h_\theta(x^i))x_j^i$

Multinomial Classification

• 다수 클래스로의 분류
  • $score_j = \theta_j^Tx$
  • j개 클래스 중 가장 높은 score인 쪽으로 입력을 분류
• score normalization : [0, 1] 내의 분포로 표준화
  • $p(y^i|x^i, \theta)=\Pi_{y^i==l}[\frac{e^{\theta_i^Tx}}{\sum_je^{\theta_j^Tx}}]$
  • log-likelihood $l(\theta)=log((p(y|x, \theta))=\sum_ilog((p(y^i|x^i, \theta))))$

Exponential family

• linear, logistic, multivariant regression의 gradient descent는 동일 함수를 이용
• 이 세 함수를 같은 exponential family에 속한다고 칭함
  • exponential family : $p(y, \eta) = b(y)exp(\eta^TT(y)-a(\eta))$
• ex. linear regression
  • $p(y, \mu)=\frac{1}{\sqrt{2\pi}}exp[-\frac{1}{2}(y-\mu)^2]\\=\frac{1}{\sqrt{2\pi}}exp[-\frac{1}{2}y^2]-exp[\mu y-\frac{1}{2}\mu^2]$
  • $p(y, \eta) = b(y)exp(\eta^TT(y)-a(\eta))$ 꼴에서
  • $b(y)=\frac{1}{\sqrt{2\pi}}exp[-\frac{1}{2}y^2], T(y)=y,\ \eta=\mu,\ a(\eta)=\frac{1}{2}\mu^2=\frac{1}{2}\eta^2$
• ex. logistic regression
  • $P(y=1)=\phi$, $P(y=0)=1-\phi$
  • $P(y)=\phi^y(1-\phi)^{1-\phi}=exp[ylog\phi+(1-y)log(1-\phi)]\\=exp[ylog(\frac{\phi}{1-\phi})+log(1-\phi)]$
  • $b(y)=1,\ T(y)=y,\ \eta=log\frac{\phi}{1-\phi},\ a(\eta)=-log(1-\phi)=log(1+e^\eta)$
• Exponential family의 gradient descent
  • $\theta_j=\theta_j-\frac{\alpha}{m}\sum_i[H_\theta(x^i)-y^i]x_j^i$

• 머신러닝?
  • 명시적 프로그램 없이 학습하는 능력을 컴퓨터에게 부혀아는 것
  • 데이터를 이용한 프로그래밍

Linear Regression

• 일정 데이터의 상관관계를 선형으로 파악하는 것
• ex. 집값의 예측
  • 집의 평수와 판매 가격의 데이터가 주어짐
  • 해당 데이터를 기반으로 y = ax + b의 그래프를 작성
• 가격은 연속하여 변하는 값이므로 선형 회귀 문제로 분류된다.
• 집의 정보(입력)과 가격(출력)의 그래프를 갖고 있으므로 지도학습에 해당한다.

• 가설 $H(\theta)$ : 데이터에 기반하여 가정한 모델
  • 모델에 새 데이터를 입력시키면 예측값이 출력
  • $H(\theta) = \theta_0 + \theta_1x_1 + \theta_2x_2+...$
  • error : 해당 모델과 training data 사이의 출력(y)값 차이

• Cost Function $J(\theta)$ : 가설 H와 실제 데이터 y 사이의 차이
  • 예측 모델의 정확도를 표현
  • J가 0이면 완벽한 예측임을 의미
  • $J(\theta) = \frac{1}{2}[H(\theta) - y]^2$
    • 최솟값의 계산 : $\theta$에 대한 미분값이 0이 되는 지점을 탐색
• $\frac{\partial J(\theta)}{\partial \theta_i}=[H(\theta) - y]\frac{\partial H(\theta)}{\partial\theta_i}=[H(\theta)-y]x_i$
  • parameter update : $\theta = \theta - \alpha\frac{\partial J(\theta)}{\partial\theta}$ ($\alpha$ : running rate, 값이 변화하는 정도)
• non-convex한 경우 : 미분값이 0이 되어도 최소가 아닐 수 있음

• gradient descent : parameter update시 모든 오차값의 합을 이용해 갱신
  • 데이터가 많은 경우 속도가 느린 단점
  • 수렴할 때까지 : $\theta_j = \theta_j - \alpha\sum_{i=1}^m[H(\theta_j)-y^i]x_j^i$
• stochastic descent
  • gradient descent의 경우 모든 feature의 변화값 합을 계산하므로 연산 부담이 높음
  • stochastic의 경우 각 feature마다 weight 변화를 갱신하므로 연산 부담이 상대적으로 낮음
  • $\theta_j = \theta_j - \alpha[H(\theta_j)-y^i]x_j^i$ for all i

Normal Equation

• $\frac{\partial J(\theta)}{\partial\theta_i}=0$
  • 행렬 미분 : 각 원소에 대해 함수를 편미분
  • $\nabla_AF(A)=\begin{bmatrix} \frac{\partial F(A)}{\partial a_{11}} ... \frac{\partial F(A)}{\partial a_{1n}}\\ ...\ \ \ \ \ \ \ \ \ \ \ ...\\ \frac{\partial F(A)}{\partial a_{n1}} ... \frac{\partial F(A)}{\partial a_{nn}} \end{bmatrix}$
• $H(\theta) = X\Theta$로 표현 가능
  • $X = \begin{bmatrix} 1 x_1 x_2 .... x_n \end{bmatrix}$, $\Theta = \begin{bmatrix} \theta_0\\ \theta_1\\ ...\\ \theta_n \end{bmatrix}$
  • $\nabla_\theta J(\theta) = \frac{1}{2}\nabla_\theta[X\Theta - Y]^T[X\Theta - Y]$
  • $X^T[Y-X\hat{\Theta}]=0$
    $\rArr\hat{\Theta}=[X^TX]^{-1}X^TY$

Polynomial Regression

• Linear Regression : $H(\theta) = \theta_0 + \theta_1 x_1$
• Polynomial Regression(2nd-order) : $H(\theta) = \theta_0 + \theta_1 x_1 + \theta_2 x_1^2$
• Feature Scaling
• 함수의 각 feature들이 비슷한 범위를 갖도록 함
  • feature 범위가 달라지게 되면 각 feature가 결과에 영향을 주는 정도가 달라질 수밖에 없기 때문
  • mean normalization : $x = \frac{x-\mu}{S}$ (S는 범위 혹은 표준편차)
• Other regression
  • multiple regression : 2차 이상의 비선형 데이터에 대한 회귀
  • locally-weighted linear regression : 특정 부분에만 multiple linear model 구현

Probablistic Interpretation

• 예측값 $y^i$ 가정
  • $y^i=\theta^Tx^i+\epsilon^i$
  • $\epsilon$은 오차 ($\epsilon \sim N(0, \sigma^2)$)
    • 오차 $P(y^i|x^i, \theta) \sim N(\theta^Tx^i, \sigma^2)$
  • 전체 dataset의 오차 : $P(Y|X, \Theta) = \Pi_{i=1}^n p(y^i|x^i, \theta)$
    • $P(Y|X, \Theta) = L(\Theta)$ : Likelihood - parameter 변경 시 X에 대해 Y의 확률

Numpy

• 과학 계산의 경우 행렬 연산의 비중이 높으며, 이를 효율적으로 처리하기 위해 사용되는 라이브러리

import numpy as np

np.arange(10)
# array([0,1,2,3,4,5,6,7,8,9])

Scalar

• 단일 값으로 표현
  • pi, 온도, x, y 등등...
• 스칼라값은 소문자 알파벳으로 표현 (a,b,c,d,...)

Vector

• 값으로 이루어진 array
• column vector : $x = \begin{bmatrix} x_1\\ x_2\\ x_3\\ ... \end{bmatrix}$
• row vector : $x = \begin{bmatrix} x_1, x_2, x_3, ... \end{bmatrix}$

Matrice

• 값으로 이루어진 2차원 배열
• $x=\begin{bmatrix} x_{11},x_{12}, ..., x_{1m}\\ x_{21},x_{22}, ..., x_{2m}\\ ...\\ x_{m1},x_{m2}, ..., x_{mm}\\ \end{bmatrix}$
• 머신러닝에 있어서 많은 데이터는 벡터나 행렬로 표현
• matrix 생성 함수
  • np.array([list]) : list를 numpy 배열로 변환
  • np.arange(n) : 0~n-1의 배열 생성
  • np.reshape(r,c) : r x c 크기로 배열 재생성
  • np.zeros(size) : 0행렬 생성
  • np.ones(size) : 모든 원소가 1인 행렬 생성
  • np.full(size, element) : 해당 행렬을 element로 채움
  • np.random.random(size) : 0 ~ 1 사이의 값을 원소로 갖는 행렬 생성
  • Transepose(행렬) or 행렬.T : 행렬의 행-열을 바꿈
  • np.shape() : (행, 열) 반환
  • len(arr.shape) : 몇차원 행렬인지를 반환

Tensor

• 2개 이상의 축을 갖는 행렬
  • ex. RGB image(가로, 세로 x 3 (R, G, B))
• tensor 연산 : 일반 연산과 동일하게 작성
  • 곱셈, 나눗셈은 행렬곱이 아닌 원소 간의 곱으로 계산
• reduction
  • 원소들의 합을 계산하고, 1개 축을 제거
  • tensor.sum()
    • axis 미지정시 전체 원소의 합
    • axis : 0인 경우 세로 방향의 합을, 1인 경우 가로 방향의 합 계산
    • keepdims : 합을 계산 후 배열 크기를 유지
• np.identity : 단위행렬 반환
• np.diag : 대각행렬 반환
• np.dot(vec1, vec2) : 행렬의 합성곱($\sum x_1 \times x2$) 계산

Norm

• 벡터를 스칼라를 연결
  • 벡터의 크기에 대한 표현
• norm f의 특징
  • $f(ax)=|a|f(x)$ : vector에 상수를 곱한 만큼 증가
  • $f(x+y)\leq f(x)+f(y)$
  • $f(x)\geq 0$ : norm은 항상 0 이상
• $L_p-norm$ : $||x||_p=[\sum^n_{i=1}|x_i|^p]^{1/p}$
  • L1 norm : manhattan distance ( 절대값의 합 )
  • L2 norm : Euclidian distance

파이썬 프로그램의 실행

• 파이썬은 인터프리터 언어이므로, 기본적으로는 맨 처음부터 시작하게 됨
• 프로그램 시작점이 필요한 경우(main), 다음과 같이 정의

def main():
  # 수행할 main함수 내용

if __name__ == '__main__' :
  main()

파이썬 모듈

• import 이름 형태로 불러옴
• from package import 모듈 : 패키지(모듈) 내의 구성요소를 바로 불러올 수 있음
  • 사용자 함수와 동일한 모듈을 불러온 경우 오류 위험

import math # a
from math import cos # b

# a의 경우
math.cos(0)

# b의 경우
cos(0)

• 모듈을 import해도 하위 모듈까지 같이 import되지는 않으므로 호출해주어야 함

import A
'''
module A
ㄴmodule B
    ㄴmodule D
ㄴmodule C
일때, A를 import한다고 B,C,D를 바로 쓸수 없다
'''
A.B #(o)
B #(x)
A.B.D #(o)
B.D #x

• absolute import
  • 파이썬의 환경변수(sys.path)에 속하는 경로 모듈에 접근
• reletive import
  • 작성된 프로젝트에 속하는 모듈에 접근
• init.py : 패키지의 초기화
  • 패키지 import 시 가장 먼저 실행됨
  • __all__변수 : from ... import * 명령(패키지 내 모든 구성요소 import) 실행 시 가져오는 내용

• sys 모듈
  • 인터프리터에 의해 사용되는 정보, 변수
  • sys.argv : 커맨드라인으로 실행 시 매개변수 호출
  • ex. pyhon foo.py file.txt
    • argv[0] == "foo.py"
    • argv[1] == "file.txt"

파이썬 연산자

• 산술 연산자
  • =: 할당
  • +, -, *, / : 사칙연산
  • // : 정수 나누기(5//2 = 2)
  • % : 나머지
  • ** : 거듭제곱
  • >>, << : bit shift left, right
  • &, |, ~, ^ : bit and, or, not, xor
• 파이썬의 비교 연산자
  • A>B, A>=B : A가 B보다 크다 / 크거나 같다
  • A<B, A<=B : A가 B보다 작다 / 작거나 같다
  • A==B, A!=B : A와 B가 같다 / 다르다
  • not A : A가 아닌 경우
  • A and B, A or B : A 그리고/혹은 B
  • 모든 비교 연산자는 true 혹은 false를 반환

파이썬의 제어문

• 파이썬 제어문은 들여쓰기(space, tab)으로 해당 영역을 구분함
• 둘을 혼합해서 사용할 수는 없음
• if : 조건문

if ''' condition 1 ''':
    # TODO
elif ''' condition 2 ''':
    # TODO if condition 1 not satisfied
...
else :
    # TODO if all condition not satisfied

while, for : 반복문

while ''' condition ''':
    # while condition satisfied, TODO

for i in [1, 2, 3]:
    # loop(iterate) all element in list

• range(start, end, step)
  • start부터 end-1까지를 step 단위로 반복
  • range(5) = [0,1,2,3,4]
  • range(1,5) = [1,2,3,4]
  • range(1, 10, 2) = [1,3,5,7,9]
  • range(10,1,-1) = [10,9,...,3,2]

파이썬 함수

• 추상화를 위한 도구 : 입력과 출력 사이의 동작 내용은 Blackbox화
• 특정 기능을 구현하는 코드 영역
• 프로그램의 기본적인 단위(block)
• 코드의 재사용이 가능하게 함
• local scope : 함수 내의 변수는 외부에 영향을 주지 않음

def func1(arg1, arg2): #function header
    return arg1+arg2   #function body

#####
a = 4
def test():
    a = 5
    print(a) # 5

print(a) #4

• parameter : 함수 호출 시 전달하는 값
  • positional parameter : 전달 순서에 따른 값 할당
  • default value : 함수 선언 시 매개변수에 값을 대입하면 함수 호출시 값 전달을 하지 않아도 호출 가능
  • variadic positional argument : 정해지지 않은 개수의 파라미터를 튜플 형태로 전달
  • variadic keyword argument : 정해지지 않은 개수의 파라미터를 딕셔너리 형태로 전달

#positional parameter
def mul(a,b):
    return a*b

mul(1,2) #a=1, b=2
mul(2,1) #a=2, b=1

# default value
def mul(a,b=1):
    return a*b

mul(1,2) #a=1, b=2
mul(1) #a=1, b=1(default)


# variadic positional argument
def mul(*args):
    for a in args:
        print(a)

mul(1,2,3,4,5)

#variadic keyword argument
def mul(**args):
    for key, value in args:
        print(key, value)

mul(a=1, b=2, c=3, d=4)

• variable scope
  • 함수 내외의 변수는 독립적으로 취급됨
  • global : 최상위 변수에 접근
  • nonlocal : 자신의 상위 scope에 해당하는 변수에 접근

x = 1 # (a)
def A():
    x = 2 # (b)
    def B():
        nonlocal x = 3 #(c)
        global x = 3 #(d)

# (c)의 경우, (b)에 접근
# (d)의 경우, (a)에 접근

람다식

• 파이썬 함수는 일종의 객체
• 람다식 = 익명 함수
  • lambda arg1, agr2, ... : 계산식

sums = lambda x, y, z : x+y+z

파이썬의 클래스

• 객체지향 프로그래밍 : 동작을 정의하는 데이터와 코드를 객체 형태로 표현
• 객체지향의 특징
  • Encapsulation
    • 사용하는 데이터 접근 시 함수를 사용
    • 객체 내부의 동작은 내부에서 접근 불가
    • 디버깅을 용이하게 함
  • Abstraction
    • 디자인 관점의 문제
    • 내부의 복잡한 동작보다 문제의 핵심에 집중
  • Inheritance
    • 각 객체의 공통 특성을 상위의 하나의 객체에서 상속
    • ex. 세단, SUV, 트럭은 모두 차량이라는 공통 특성을 보유
    • 파이썬의 경우 다중 상속을 지원
  • Polymorphism
    • 같은 이름을 갖는 기능이 여러 동작을 하는 것
    • ex. sort - bubble sort, quick sort, ...
• 파이썬의 클래스 정의
  • constructor : 클래스 생성 시 자동으로 호출되는 함수로 객체를 초기화
  • 객체는 클래스의 인스턴스로 선언됨

class Car:
    num_of_cars = 0 #class variable
    def __init__(self, hp): # constructor
        Car.num_of_cars+=1
        self.hp = hp
    
    def accelerate(self): # member method
        ...

car = Car(100)

• getter/setter : 인스턴스 외부에서 접근하기 위한 방법 제공
  • getter는 변수값을 읽을 때, setter는 변수값을 쓸 때 활용
• 클래스 변수와 인스턴스 변수
  • 인스턴스 변수 : 객체 생성마다 선언되는 변수
  • 클래스 변수 : 해당 클래스가 공유하는 변수
  • 인스턴스 변수 접근 시 존재하지 않는 경우 클래스 변수 탐색
• @staticmethod : 객체가 아닌 클래스에 작용하는 메소드
• @classmethod : 클래스와 무관하게 객체에만 작용하는 메소드

Exception

• 오류를 처리하기 위한 방법
• Try-Except문을 이용해 처리
• else : except가 발생하지 않은 경우
• finally : except와 무관하게 무조건 실행
• 파이썬 Exception은 계층적으로 구성
  • 최상위에 BaseException으로 구성
  • 가장 많이 쓰는 예외들은 Exception 클래스 내에 존재
• 사용자 정의 Exception
  • 클래스 상속을 통해 정의
  • class MyError(Exception) - raise MyError("info") - except Myerror as e : print(e)

파이썬의 특징

• 인터프리터 언어 : 컴파일 과정이 없음
  • 파이썬 코드는 인터프리터를 통해 .pyc라는 binary 파일로 변환
  • Cross-Platform으로 동작 가능
• Dynamic Typing(Duck Typing) : 타입 명시가 필요 없음
• 단순한 문법

파이썬의 Value :

• 프로그램에 의해 사용될 수 있는 객체 표현
  • 숫자 : 정수(Int), 실수(Float), 허수(3+j), Boolean(True, False)
    • 허수는 .real, .imag로 실/허수를 분리해낼 수 있음

문자열

• "" / '' - 한 줄
• """ """ - 여러 줄
• 특수문자는 (키보드 ￦ 표시)뒤의 문자로 입력 가능
• 문자열 메소드
  • ''.join : 문자열을 인자와 함께 이어 붙임
  • split('') : 문자열을 인자 기준으로 나눔
  • float, int : 문자열을 숫자로 (int의 경우 진수 지정 가능)
  • strip / lstrip / rstrip : 양옆 / 왼쪽 / 오른쪽 공백 제거
  • whitespace : 공백 문자로 처리하는 문자를 확인
  • find, rfind : 시작/끝에서 문자를 찾아 인덱스 반환 (없으면 -1)
  • startswith, endswith : 해당 문자열로 시작/끝나는지 여부

리스트(배열) : [], list()

• C와 달리 여러 타입의 값이 같이 들어갈 수 있음
• [ 1, "123", [1,2,3] ]
• 파이썬의 리스트 인덱스는 음수로도 가능
  • 리스트 처음의 인덱스는 0 혹은 -(리스트 길이)
  • 리스트 마지막 인덱스는 (리스트 길이 - 1) 혹은 -1
• 슬라이스 : 리스트의 일부분을 추출해낼 수 있음
  • range와 유사하게 동작
  • a = [1,2,3,4,5]
  • a[:] = [1,2,3,4,5]
  • a[:2] = [1,2]
  • a[1:3] = [2,3]
• 파이썬 리스트 함수
  • x=[1,2,3], y=[4,5,6]
  • len(x) : 리스트의 길이 반환 (3)
  • x[len(x):] = y, x 리스트의 뒤에 y를 연결할 수 있음
    • [1,2,3,4,5,6]
    • x.extend(y), x[2:3] = y로도 가능
    • x+y로도 가능
  • x[:0] = [1,2,3] : x 리스트의 앞에 [1,2,3]으로 연장
    • [4,5,6,1,2,3]
  • x.append(10) : 리스트 끝에 추가
    • [1,2,3,10]
  • x.insert(n, element) : n번째 인덱스 앞에 element 추가
    • x.insert(0,-1) = [-1,1,2,3]
  • del x[] : 리스트 원소를 지울 수 있음
    • del x[1] = [1,3]
    • del x[:] = []
  • x.remove(2) : x리스트 안의 원소 2를 지움
    • [1,3]
  • x.reverse() : 리스트 x를 역순으로 정렬
    • [3,2,1]
  • z = [1,3,2] - z.sort() 리스트를 크기순으로 정렬
    • [1,2,3]
    • z를 변화시키며 리턴값 없음
  • y = sorted(z) : 정렬된 새 리스트를 반환
    • z = [1,3,2], y=[1,2,3]
  • in : 값이 리스트에 있는지 확인
    • 1 in [1,2,3] : True
    • 5 in [1,2,3] : False
    • 5 not in [1,2,3] : True
  • min, max : 리스트 내의 최대/최소값 반환
  • x.index(1) : 해당 원소가 존재할 경우 인덱스 반환
    • 0
  • k = [1,1,1,2,2,3] - k.count(1) : k 리스트 내의 원소 개수 반환
    • 3

튜플 : (), tuple()

• 수정 불가능한 리스트
• (1,) : 하나의 원소를 갖는 튜플 - (1)는 정수 1임
• 튜플의 활용 : 변수 선언의 간소화
• extend unpacking * : *이 붙은 원소는 길이가 맞지 않는 모든 값을 흡수

x=1
y=2
z=3
w=4
#에서
(x,y,z,w)=(1,2,3,4)#로

# Extend unpacking
a, *b, c = (1,2,3,4,5)
'''
a=1
b=[2,3,4]
c=5
'''
a,b,c,*d=(1,2,3)
'''
a=1
b=2
c=3
d=[]  : 빈 리스트
'''

딕셔너리 : {}, dict()

• 키 - 값 관계를 갖는 자료 구조
• d = {1:"one", 2:"two}일 때, d[1] = "one"을 반환

세트 : set()

• 중복이 없는 자료 구조
• set([1,2,3,4,1,2,3,4]) = set([1,2,3,4])
• |, & : 합집합, 교집합 계산
• -: 차집합
• ^ : XOR 연산과 동일
• frozenset([]) : Immutable한 set
  • set 안의 set을 구현하기 위해 사용
  • seta = {1,2, frozenset([3,4,5])}
    • set은 unique한 값을 갖는 객체를 해쉬로 구현하는데, set은 Mutable하므로 값이 바뀔 수 있어 set 안의 set 구현이 불가능. 이로 인해 set in set을 구현하기 위해 frozenset이 필요

파이썬 객체

• 프로그램이 조작 가능한 데이터
• Scala : Int, Float, Bool, None - 분리 불가능한 최소 단위
  • None : 반환값이 없는 함수에 사용(None을 반환)
• Non-scala ; List, Tuple, Dictionary, defined Class - Scala Type에 기반해서 만들어지는 자료형
• Type() : 자료형 변환이 가능(C의 type-casting)
• 값과 변수
  • Value : 값을 표현
  • Variable : 데이터가 저장된 곳을 이름으로 표현
  • 값을 변수에 할당하여 사용 (Variable = Value : pi = 3.14)
    • 만약 x=3으로 할당 후, x=4로 할당하면, x = 3의 연결이 끊어지고, 4와 x가 bind됨
    • 3의 값은 python에서 자체적으로 메모리를 정리해줌
  • del(x) : 변수 x를 삭제
• 객체 복사
  • 파이썬의 모든 변수는 레퍼런스(포인터)로 동작
    • a=3, b=3의 코드를 가정
    • C의 경우 a, b의 메모리 공간에 각각 3을 저장
    • python의 경우 a, b가 3의 값을 갖는 객체의 주소를 가리킴
    • a=4가 될 경우, c는 a변수의 메모리 공간을 지우고 4를 넣지만, python은 4의 값을 갖는 객체를 만들고, 그 주소를 a가 가리키게 됨
    • 리스트 역시 각 위치가 포인터로 동작
      • [1, 2, 3]은, 리스트의 0, 1, 2번째 인덱스가 각각 1,2,3의 값을 갖는 객체를 가리키는 상태
      • shallow copy : 리스트를 대입한 후 연산을 할 경우, 같은 리스트 변수에도 영향을 줌

li1 = [1,2,3]
li2 = li1 #shallow copy

li2 = li1 * 2 # li1, li2 모두 [2,4,6]

# Deep copy : 분리하여 복사
import copy
li2 = copy.deepcopy(li1)

• 파일 객체
  • open('파일명', '읽기/쓰기 여부')로 호출
  • 존재하는 파일을 쓰기로 호출할 경우, 덮어쓰는 식으로 파일 작성

Immutable / Mutable

• 파이썬의 객체 분류 기준
• Immutable : Number, Boolean, Tuple
• Mutable : List, Set, Dictionary
• Object ID : id() 함수는 객체의 id를 반환
  • Immutable한 객체들의 id는 모두 동일
  • Mutable 객체(ex. list)의 경우 매번 새로 생성되므로 다른 id 할당
  • is 연산자로 두 객체가 완전히 같은지 확인 가능
    • ==는 두 객체의 값을 비교

주석

• 코드가 어떻게 동작하는지를 설명
• 실제 코드에는 영향을 주지 않음
• # : 한 줄 / ''' ''' : 여러 줄

# comment in one line

'''
comment
in
lines
'''

파이썬의 코딩 스타일 - PEP 8

• 개발 편의를 위한 코딩 규칙
• 모듈명, 패키지명 : 모두 소문자로, 필요할 때만 _로 구분 (imp, sys)
• 함수, 변수명 : 모두 소문자로, 가독성을 위해 언더바 사용 (my_func(), my_var)
• 클래스명 : 각 단어마다 대문자로 시작(MyClass)
• 상수 : 모두 대문자, 가독성을 위해 언더바(MY_CONSTANT)
• 들여쓰기 : tab 대신 스페이스 4번으로 사용할 것
• 비교 : True, False와 직접적인 대조를 하지 말 것
  • if my_var == True >> if my_var
  • if my_var == False >> if not my_var

머신러닝

• 프로그램을 만들 때의 접근법
  1. 풀어야 할 문제 분석
  2. 알고리즘 구성
  3. 알고리즘 구현(By 프로그래밍 언어) 및 시험
• 머신러닝의 정의
  • 외부의 프로그램 없이 데이터를 이용하여 컴퓨터에게 학습 능력을 부여하는 것
• 머신러닝의 발전
  • 처음 퍼셉트론 개념은 약 1950년 시작
  • (1970) 단순한 알고리즘 표현도 어렵다는 점을 확인
  • (1980) Back-Propagation 알고리즘 발견
  • (2010 ~ ) Alexnet 등 다양한 딥 러닝 알고리즘 발전
• 딥 러닝의 성공 조건 : 데이터, 알고리즘, 연산
  • 알고리즘 : Backpropagation 등의 알고리즘 발전
  • 데이터 : 머신러닝은 데이터를 기반하므로 매우 많은 양의 데이터 필요
  • 연산능력 : GPU / TPU / NPU 등 머신러닝을 위한 연산 능력 발전
• 머신 러닝의 종류
  • 지도 학습 : Label된 데이터의 학습 ex. 스팸 필터, 선형 회귀, ...
  • 비지도 학습 : Unlabel된 데이터의 학습 ex. 데이터 클러스터
  • 강화 학습 : 모델과 환경 사이의 행동과 피드백에 기반 ex. 로봇, AI 게이밍, ...