Given a curve, we can use the tangent at any given point to find the slope of the curve. To find the tangent, we divide the change in $y$ by the change in $x$, \(\frac{\Delta y}{\Delta x}\)
where $\Delta$ represents a very small change in a given value. However, this would correspond to the movement along the tangent as opposed to along the slope. However, as the changes in $x$, $\Delta x$, approaches 0, the tangent line also approaches th slope until the tangent and the slope are the same at $\Delta x = 0$.
Here is where the problem comes in: … how do we divide a value (in this case, $\Delta y$) by 0? This is where calculus comes in. Calculus allows us to calculate the ratio of the changes in two values even as the term approaches zero.
Specifically, $\frac{dy}{dx}$ is a little bit of $y$ divided by a little bit of $x$, and calculus allows us to calculate this ratio even when $dx \rightarrow 0$
What we aim to do here is minimise $x$ in order to move down the gradient. $\eta$ is some fraction that represents how far along the gradient do we want to move (step size). That is, we want to find the global minimum.
For a 3-D function, we need partial derivatives. Given \(z = x^2 + y^2,\) we need find the partial derivatives of $z$. In this case, they are: \(\frac{\delta{z}}{\delta{x}} = 2x, \frac{\delta{z}}{\delta{y}} = 2y.\)
By calculating $2x$ and $2y$, you get a vector, which informs us the direction directly opposite to the steepest descent. The main takeaway is is that for a multidimensional function, the gradient is given by a vector. Given our elliptical paraboloid, its gradient would be written as:
\[\begin{bmatrix}\delta z/ \delta x \\ \delta{z} /\delta{y}\end{bmatrix} = \begin{bmatrix}2x \\ 2y\end{bmatrix} or \begin{bmatrix}2x & 2y\end{bmatrix}\]Reorganising the above equations, we get the following weight update rule: \(\mathbf{w}_\text{new} = \mathbf{w}_\text{old} + \mu (-\nabla), \text{where } \mu = \text{step size, } \nabla=\text{gradient}\)
However, with a large number of features, finding the gradient would be computatinally expensive, if not impossible. Thus, we estimate the gradient so that the update rule becomes:
\[\mathbf{w}_\text{new} = \mathbf{w}_\text{old} + 2\mu\epsilon\mathbf{x} \text{ where, }\] \[\mu = \text{step size}\] \[\epsilon = \text{error based on one data point},\] \[\mathbf{x} = \text{the vector representing a single data point}\]The error is given by:
\[\epsilon = d - \mathbf{w}\top\mathbf{x}, \text{where } d = \text{target}\]And through this, we get the least mean squares algorithm.
]]>KHUDA 자연언어처리 트랙 뒷타임 수학 세션은 Anil Ananthaswamy가 쓰신 Why Machines Learn: The Elegant Math Behind Modern AI라는 책을 다룹니다. 책 내용을 번역하여 정리하고 뒷타임 세션 때 강의해드립니다. 그리고 욕심이 엄청 높아져서 해당 책에서 공부하는 수학을 코드로 응용하는 것도 해보겠습니다.
을 가정합시다. 수학적으로 지도학습은 각 가중치 $w_i$를 추출하도록 학습하는 목표입니다. 즉, 특징 (features)와 타겟값의 관계를 분석하는 것입니다.
${x, y}$를 가지는 데이터를 훈련데이터하고 하는데 labeled data 또는 annotated data라고도 합니다.
- 노트!
- 지연언어처리 논문에서 보통 annotated data라고 합니다
McCulloch-Pitts (MCP) 뉴런: 계산 단위인데, 계산만 가능하고 학습 불가능 → Rosenblatt’s Perceptron
\[\begin{aligned}g(x) & = x_1 + x_2+\cdots+x_n \\ f(z) & = \begin{cases} 0, z < \theta \\ 1, z \geq \theta \end{cases} \\ y = f(g(x)) & = \begin{cases} 0, g(x) < \theta \\ 1, g(x) \geq \theta \end{cases} \end{aligned}\]→ Rosenblatt은 인간의 뉴런과 같이 서로 트리거함으로써 공부하는 인공 뉴런을 발전하고자 하셨습니다.
벡터로 표현하려면
\[y = \begin{cases} - & 1, \mathbf{w}^\top\mathbf{x} \leq 0 \\ & 1, \mathbf{w}^\top\mathbf{x} > 0 \end{cases}, \text{ where } \mathbf{w} = \{w_0, w_1, \cdots, w_n\} \text{ and } \mathbf{x} = \{1, x_1, \cdots, x_n\}\]파라미터 업데이트
\[\mathbf{w}_{\text{new}} = \mathbf{w}_\text{old} + y\mathbf{x} \text{ if } y\mathbf{w}^\top\mathbf{x} \leq 0\]왜 $y\mathbf{w}^\top\mathbf{x}$인가?
$y$과 $\mathbf{w}^\top\mathbf{x}$가, 즉 실제값과 예측값이, 똑같으면 스칼라곱은 양수고, 예측값이 틀리면 음수가 나와서 잘 예측한지 확인하도록 스칼라곱 과정을 진행합니다.
→ 즉, 데이터와 적합하는 가중치와 편향을 알아보는 목표입니다
| MCP | Perceptron |
|---|---|
| 인풋은 이진값이어야 함 | 인풋은 이진값이 아닌 값을 가져도 됨 |
| 가중치 없음 | 가중치 有 |
| 아웃풋은 0이나 1임 | 아웃풋은 -1이나 1임 |
| 학습 불가 | 가중치와 편향을 학습 가능 |
자… 위 개념을 기반으로 퍼셉트론 직접 만들어봅시다.
참고: Colab
해당 실습은 numpy를 이용합니다.
1
import numpy as np
우리는 Perceptron이라는 파이썬 클래스를 만들고 클래스 속 함수를 정의합니다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
class Perceptron:
def __init__(
self,
inputs,
labels,
epoch,
# learning_rate = 0.05
):
"""
클래스 초기화하는 함수
self를 통해 '이 클래스가 원래 요 변수들을 갖는다'라고 정할 수 있습니다.
해당 코드는 bias를 w[0]로 정의하여, 인풋 배열에 x[0]=1 산입합니다 (즉, [1, x1, x2])
그리고, 교재에서 learning rate 아직도 안 나타났지만, learning rate 어떻게 적용할지를 아실 수 있도록 주석으로 learning rate에 해당 코드를 놓았습니다.
"""
self.inputs = inputs
self.inputs = np.array([np.insert(inp, 0, 1) for inp in inputs])
self.weights = np.zeros(len(self.inputs[0]))
self.labels = labels
self.epoch = epoch
# self.lr = learning_rate
def step_function(self, product):
"""
이진 분류 실행하는 계단함수 코드
"""
if product <= 0:
return -1
else:
return 1
def update(self, weights, inputs, labels):
"""
가중치 업데이트
"""
return weights + labels*inputs
def train(self):
"""
훈련 코드
epoch마다 각 샘플에 대한 y'를 계산하고, 필요하면 파라미터 업데이트 실행합니다.
"""
epoch = self.epoch
for e in range(epoch):
for i in tqdm(range(len(self.inputs)), desc=f'Epoch {e+1}'):
pred = self.weights @ self.inputs[i]
acc = self.step_function(pred) * self.labels[i]
if acc <= 0:
self.weights = self.update(self.weights, self.inputs[i], self.labels[i])
# self.weights = self.weights + self.lr * (self.labels[i] * self.inputs[i])
def predict(self, inputs):
"""
예측 코드
추출된 가중치를 통해 실험 셋의 레이블을 계산합니다.
"""
weights = self.weights
inputs = np.array([np.insert(inp, 0, 1) for inp in inputs])
product = np.array([weights @ x for x in inputs])
pred = np.array([self.step_function(pred) for pred in product])
return pred
나중 6주차 때 평가에 대해 공부할 테지만, 그래도 자연언어처리에 사용하는 평가의 기초 공식을 간략하게 공부하면 좋지 않을까 싶었습니다.
제일 기분 공식은 정확성(Accuracy)라고, 전체 샘플에 비해 모델을 어느 정도 잘 맞추는지를 알려주는 공식입니다. 즉,
\[\text{Accuracy} = \frac{\text{Correct Predictions}}{\text{Total Samples}}\]코드로:
1
2
3
4
5
6
def evaluate(pred_labels, label):
count = 0
for pred, true in zip(pred_labels, label):
if pred == true:
count += 1
return count/len(pred_labels)
하지만, 클래스 불균형이 있으면 단순히 Accuracy를 이용하면 불확실한 결과도 나올 수도 있습니다.
따라서, confusion matrix를 이용하는 평가 공식을 이용합니다.
예측값은 4가지로 분류될 수 있습니다. 첫번째 경우 true positive이라고 잘 예측된 positive한 레이블, 두번째는 true negative이라고 잘 예측된 negative한 레이블, 셋번째 false positive이라고 못 맞추는 negative한 레이블, 그리고 false negative이라고 못 맞추는 positive한 레이블. 즉,
| Pred/True | Positive | Negative |
|---|---|---|
| Positive | TP | FP |
| Negative | FN | TN |
따라서, confusion matrix를 이용해 정확성을 다시 정의하려면,
\[\text{Accuracy} = \frac{\text{TP} + \text{TN}}{\text{TP} + \text{TN} + \text{FP} + \text{FN}}\]즉, 단순히 모델은 어느 정도 잘 맞추느냐를 나타내는 공식입니다.
관련성은 모델이 얼마 정도로 우리가 원하는 정보를 추출하는지를 알려주는 평가방법입니다. 관련성 기반 평가 계산은 크게 3가지 있습니다.
Precision
Precision은 모델이 positive하는 것으로 예측하는 샘플에 비해 올바르게 positive하는 것을 예측하는 값이 나타납니다. 즉,
\[\text{Precision} = \frac{TP}{\text{TP} + \text{FP}}\]Recall
Recall은 실제 positive 값 샘플에 비해 모델이 올바르게 예측하는 positive값 얼마인지를 나타내는 값입니다. 즉,
\[\text{Recall} = \frac{TP}{\text{TP} + \text{FN}}\]Precision vs. Recall
Precision과 Recall 중에 어떤 걸로 사용하면 더 나을까요? 정답은 케이스바이케이스입니다.
FP 줄이도록 하고자 하면 Precision 이용하면 더 낫고 FN 줄이도록 하고자 하면 Recall 이용하면 더 좋죠. 예를 들어 암 검사에서 FP 나타나면 환자에게 비용이 많아지며 FP를 줄도록 평가하면 더 좋고, 피슁이 발생하면 정말 大 일 나겠어 Recall 위주로 평가하면 제일 베스트죠.
$F_1$ 점수
$F_1$ 점수는 Precision과 Recall 같이 계산하는 평가방법인데, $\beta=1$인 $F_\beta$ 점수 나타납니다. $\beta$는 가중치이므로 $\beta=1$이라면 Precision과 Recall을 대칭으로 대표해 계산합니다. 즉, Precision과 Recall 조화 평균(harmonic mean)을 나타냅니다.
\[F_\beta = \frac{(1+\beta^2)\cdot\text{precision}\cdot\text{recall}}{\beta^2\cdot\text{precision}+\text{recall}}\]$\beta > 1$라면, $w_\text{recall} > w_\text{precision}$이라고 생각해도 되고 $\beta < 1$ 경우 $w_\text{recall} < w_\text{precision}$이라고 생각해도 됩니다. 즉, $\beta =1$일 때, $w_\text{recall} = w_\text{precision}$입니다.
\[\begin{align*} \beta & = 1, \\ F_1 & = 2\cdot\frac{\text{precision}\cdot\text{recall}}{\text{precision} + \text{recall}} = \frac{2\text{TP}}{2\text{TP}+\text{FP}+\text{FN}}\end{align*}\]]]>노트! LLM 평가할 때 $F_1$ 위주로 이용합니다.
synchronise하다 
ifconfig을 통해서 server02의 IP 주소 확인 
sudo netplan apply 명령어를 실행해봤을 때 오류가 나와서 몇번까지 수정해봤는데 결국에는 포기해서 챗지피티한테 물어봐서 아래와 같이 받았다 
sudo netplan apply 실행하고 IP 주소 확인
ping 명령어를 이용하여 server01로 ping을 보내면 원활하게 작동하는 것 확인 
ssh server01 명령어를 이용하여 server01로 접속해봤을 때 잘 되긴 한다 
tee: 출력을 두 곳으로 보낼 수 있는데, 한 곳은 tee 다음에 명시되어 있는 파일로 출력되고 다른 한 곳은 표준 출력(stdout)이다
tee 명령어를 활용하면 화면에 출력됨과 동시에 파일에 저장된다overlay: 리눅스 커널의 네트워크 드라이버를 가리킨다
br_netfilter: 네트워크 패킥 처리 관련 모듈러로써 iptables/netfilter 규칙이 적용되게 한다
EOF: 문서의 마지막이라는 뜻
modprobe: 리눅스 커널 모듈 관리 도구 → 특정 모듈을 로드하거나 제거할 수 있는 도구sysctl 매개변수를 설정한다
sysctl 매개변수를 설정하면 재부팅 후에도 값이 유지된다sysctl 매개변수를 적용할 수 있다 
1
2
sudo mkdir -p /etc/containerd
containerd config default | sudo tee /etc/containerd/config.toml
free -h 명령어를 통해 메모리 공간 확인
kubeadm을 사용해 초기화한다 
--apiserver-advertise-address: 쿠버네티스 마스터 노드의 IP 주소를 입력한다--pod-network-cidr: 네트워크 대역을 설정할 수 있다
1
2
3
sudo apt-get purge kubeadm kubectl kubelet
sudo apt-get remove
sudo rm -rf ~/.kube
django를 활용하기 위해 pyenv를 설치해야 되는데 이는 파이썬 가상 환경을 관리할 수 있게 해주는 소프트웨어이다
vim .bashrc 명령어를 입력하여 .bashrc 파일을 아래와 같이 수정한다 
아래 명령어를 이용하여 셸을 재시작
pyenv를 입력하면 pyenv가 성공적으로 설치되었는지 확인할 수 있다 
pyenv virtualenv 명령어를 활용하여 py3_11_6이라는 가상 환경을 만들고 목록 확인 
1
2
3
pip install django
pip install gunicorn
pip install psycopg2-binary
tree [경로]를 입력하면 해당 경로를 포함한 하위 디렉터리 및 파일 구조를 확인할 수 있다
vim 명령어를 사용해서 yaml_practice.yml 파일을 생성하여 수정한다 
{key:value} 구조를 사용하는 파이썬의 딕셔너리 자료형과 비슷한다
{'name':'nginx', 'image': 'nginx:latest'}와 같이 name과 image에 대한 데이터가 같은 딕셔너리로 구성되는데, 이를 가능하게 하는 것이 yaml 파일에서의 ‘-‘이다
vim settings.py를 입력하고 settings.py를 아래와 같이 수정한다 
runserver 명령어를 이용하여 django 프로젝트 실행 
vim Dockerfile 명령어를 이용해서 Dockerfile을 생성하는데 아래와 같이 작성한다 
FROM: 베이스 이미지WORKDIR: 리눅스의 cd 명령어롸 비슷하다COPY 호스트에 존재하는 파일을 도커 이미지의 파일 시스템 경로로 복사하는 명령어RUN: 이미지 빌드 시 실행하고 싶은 명령어를 실행CMD: 서비스(컨테이너)를 실행EXPOSE: 8000번 포트를 연다
-d 옵션을 이용하여 컨테이너를 백그라운드로 실행하고 -p <도커 호스트 포트>:<컨테이너 포트> 옵션은 포트토워딩 옵션이다 
아래와 같은 Dockerfile을 생성하고 작성한다
docker image build 명령어를 이용하여 이미지를 빌드하겠다 
docker image build 명령어를 통해서 Nginx 이미지를 빌드하겠다 
먼저 도커 네트워크를 생성해야 된다고 한다 
호스트의 웹 브라우저에서 주소창에 127.0.0.1:80을 입력하면 포트포워딩 기능을 통해 10.0.2.4:80으로 트래픽이 전달됨 → nginxtest 컨테이너를 통과한 후 djangotest 컨테이너에 접속하게 되어 django 서비스를 활용할 수 있게 됨
-e 옵션을 이용하여 환경변수를 수정한다
그리고 myDjango03에 있는 requirements.txt를 아래와 같이 수정한다 
호스트에서 웹 브라우저를 실행한 후 127.0.0.1:80에 접속하면 포트포워딩을 통해 10.0.2.4:80으로 트래픽이 전달됨 → nginxtest 컨테이너를 거쳐 djangotest 컨테이너에 접속할 수 있으며, djangotest 컨테이너는 postgrestest 컨테이너를 통해 데이터베이스를 활용하게 됨
django가 잘 실행하는 걸 확인 
ifconfig 명령어를 이용하여 docker0의 IP주소를 확인한다 → django와 PostgreSQL이 서로 통신하려면 docker0을 이용해야 한다
restart: always: 컨테이너가 정지되면 재실행하라는 명령어
app = Flask(__name__): flask 웹 애필리케이션 객체를 app이라고 지정한다app.run(host='0.0.0.0', port=8001: 파이썬 스크립트가 실행되면 app.run 통해 웹 애플리케이션을 실행하도록 정한다
host='0.0.0.0: 모든 IP주소로부터 요청을 수락하고록 설정하는 옵션port=8001: 8001번 포트를 사용하겠다는 의미
 |
→ |  |
→ |  |
| 프로그램 | 프로세스 |
|---|---|
| 디스크에 존재하는 명령어 집합 | 실행 중인 프로그램이라 램에 존재하는 것 |
| 네임스페이스 | 의미 | 역할 |
|---|---|---|
| pid | PID: Process ID | 니룩스 커널의 프로세스 ID 분리 |
| net | NET: Networking | 네트워크 인터페이스(NET) 관리 |
| ipc | IPC: Inter Process Communication | 프로세스 간 통신(IPC) 접근 관리 |
| mnt | MNT: Mount | 파일 세스템의 마운트 관리 |
| uts | UTS: Unix Timesharing System | 커널과 버전 식별자 관리 |
build, pull, run 과 같은 명령을 내린다
sudo apt-get update: apt 패키지 인덱스를 업데이트한다는 명령어sudo apt-get install ca-certificates curl gnupg lsb-release: apt가 HTTPS에서 리포지토리를 사용할 수 있게 하는 데 필요한 패키리를 설치하는 과정이다
docker version을 입력하면 도커 버전을 확인할 수 있다
