onesword 님의 블로그

☑️ 취업 특강 및 자기관찰

🔎 필요스킬

데이터 수집, 처리, 분석 스킬, 문제해결능력, 데이터 기반 의사결정 능력

python, pytorch, 머신러닝, 딥러닝 알고리즘, 데이터 시각화 능력

🔎 직업군

- 데이터 사이언티스트: 데이터 분석, 모델링, 예측 등을 통해 시스템 개발 및 개선

- 데이터 엔지니어: 데이터 수집 파이프라인 설계, 구현, 배포, 데이터 수집

- AI연구원: 새로운 AI기술을 연구하고 개발하여 AI분야에 기여

- AI프로덕트 매니저: AI 기반 제품의 개발 및 출시 전략을 수집하고 시장 트렌드를 분석

- 머신러닝 엔지니어: 머신러닝 알고리즘을 설계, 구현, 배포하고 AI모델 성능을 최적화

- 데이터 엔지니어

- 머신러닝 엔지니어

- 백엔드 개발자

🔎 코딩 테스트 준비: 프로그래머스, 백준, LeetCode

🔎 내가 준비해야할 것들

- 마크다운 사용법

- 노션 사용법

- 이력서 포트폴리오 작성 노하우 늘리기

- python, pytorch, 딥러닝, 머신러닝, 데이터 분석 공부

🔎 내가 걱정하는 것들

- 지방에서는 취업하기 많이 어려운지

- 문서 작성 능력이 너무 낮다

- 직업군에 대한 정보들이 감이 잡히지 않음

- 소통, 공감 능력은 좋다고 생각하지만 문제 해결 능력이 좀 떨어짐(감정적인 편)

🔎 나의 장점

- 책임감이 강함

- 상대입장에서 생각하고 행동하는 편  

- 의견이 많고 자주 질문하는 편

- 의견 공유하는 것을 좋아함(쌍방향)

- 무언가를 많드는 과정을 좋아함(내가 만든것을 공유하고 반응 보는 것이 제일 좋음)

🔎 나의 단점

- 참을성이 부족함(한번만 해도 될 일을 먼저 진행해보고 두번하게 되는 경우가있음)

- 잘휘둘리는편

- 걱정이 많아 생각이 많음

- 깊게 생각하는 힘이 부족함(얕은 생각에서 관련도가 적은 것들을 신경쓰고 그 부분에만 집중해서 중요한 부분을 놓치는 경우가 많음)

혼자서 오해를하고 트러블이 발생하게 만드는 경우가 가끔있음 (그럴수록 더욱 이야기하고 오해를 풀려고 노력 함)

☑️ 1차 커리어 코칭

커리어코치: 임하늘 코치님

코칭 시간 14:25 ~ 14:50

내용

1. 내가 어떻게 어떤 생각으로 내일배움캠프에 신청하여 오게 되었는지 설명

2. 오늘 오전에는 어떤 학습을 하였는지

3. 채용 사이트 추천

4.인텔리픽 커리어 코칭 시스템 소개

5.포트폴리오, 이력서 등 작성 및 예시 사이트 추천

6. 현재 가지고있는 고민 상담

오늘은 1차 커리어 코칭을 진행했습니다.

커리어 코칭을 진행하기 전 오전에는 일전에 진행했던 취업특강(김대영 튜터님)의 강의를 복습했다.

강조되고 내가 미리 준비해야하는 부분을 파악해 포트폴리오와 이력서 작성에 대한 구상하는 시간을 가졌습니다.

노션을 사용해서 나의 포트폴리오 페이지를 만들기 위해 유튜브의 노션으로 포트폴리오 강의를 시청하였고

다른 사람들의 노션으로 작성한 포트폴리오를 볼 수 있는 방법으로 살펴 보던 중 데이터 분석가님의 포트폴리오를 보게 되었다.

비전공으로 데이터 분석가가 되기까지의 내용이있었고 흥미를 가지고 알아 보았습니다.

데이터 분석가 답게? 취업 싸이트에서 필수조건, 우대사항의 데이터를 가져와서 분석하여 내가 가진 기술, 필요한 기술 등 시각화하여 우선 순위를 정하는 방법에대한 소개를 봤습니다.

그리고 커리어 코칭을 받으며 느낀점을 위 진행 순서대로 말하겟습니다.

1. 지금까지 내가 걸어온 길이 너무 여기저기를 건들이면서 취업까지했지만 시도하기 전에 포기를 한 경험으로 자존감이 매우 떨어진 상태였고 이 자존감을 다시 올리기 어렵다고 생각했다. 하지만 임하늘 코치님께서는 다른 시선으로 다양한 일을 시도해보았고 본인 역량을 잘 판단하고있다고 말씀해주셨습니다.

아직 내가 나에 대한 실망감은 남아있지만 코치님의 평가를 듣고  다른 시선으로 나를 보는 방법을 배운것 같으며 조금이지만 자존감이 회복 된것 같습니다.

2. 오전에 진행한 학습을 말씀드리니 여러가지 참고 싸이트를 보여주셨습니다. 아직 다 살펴 보진 않았지만 잘 활용해보겟습니다.

3, 4. 코칭 시스템이 어떻게 진행 되는지 확인하였고 인턴신청, 본인이 원하는 방향으로 코칭 등을 알아보았고 잘 활용해 보아야겟습니다.

5. 노션으로 작성을 하려고 했는데 git으로 작성해서 배포하는게 좋다고 말씀하셔서 git으로 진행해보아야겟습니다.

6. 지금 학습상태로는 당연히 현업에 도움이 되지는 못하지만 꾸준히 열심히하면 현업에서 할 수 있을 것이다.

☑️ 딥 러닝 도전과제 

torchtext에서 OSErorr를 만나 해결해보려고 pytorch를 uninstall 해보고 다시 다운 받아보고 가상공간에서 다시 시도해보고 많은 시도를 했고 pytorch를 다운 받을 때 많은 시간이 소요되었다.

결국 튜터님을 찾아가서 물어보았고 답은 정말 간단했다. torch에서 최신버젼부터 window에는 text를 지원하지 않아서 그렇다고 한다.

그래서 pytorch를 다운그레이드 시켜주어서 해결하였다.

이제 OS문제를 해결했으니 도전과제를 시작하였다.

도전과제를 진행한게 벌써 5일이 지났다.

딥러닝 모델인 LSTM모델을 구현하다가 시간이 너무 오래걸려서 포기하고 머신러닝에 대한 이해도 부터 높여야겟다는 생각으로 머신러닝 모델 학습을 진행해 왔었는데 너무 다 잊어 버리기 전에 다시 한번 복습한다는 생각으로 오늘 다시 딥러닝 모델 구현을 시도해 보았다.

우선 전처리, feature 분석, 데이터 시각화(막대그래프) 부분은 얼추 기억하고있어넘어가고 LSTM모델 학습 코드 공부를 진행했다.

• torch.nn

- torch.nn 모듈은 신경망을 구축하기 위한 다양한 함수들을 포함한다.

- 주로 nn.Module, nn.Linear, nn.Conv2d, nn.ReLU 등 신경망의 계층을 구성하거나 손실 함수를 정의할 때 사용한다.

그럼 여기서  nn.Module, nn.Linear, nn.Conv2d, nn.ReLU 등을 정의하는 이유를 알아보자

nn.Module

목적: 모든 신경망 레이어와 모델의 기본 클래스이다.

역할: 사용자 정의 신경망을 만들 때 nn.Module을 상속받아 신경망 계층들을 구성하고, forward()메서드를 정의해 데이터를 순차적으로 전달하는 방식을 설계한다.

장점: 자동 미분, 학습, 평가 모드를 쉽게 전환 가능, 신경망의 구조를 객체 지향적으로 구성하여 코드의 재사용성과 관리성 높여준다.

nn.Linear

목적: 인공신경망에서 완전 연결(filly connected, FC) 계층을 나타내는 클래스

역할: 입력 데이터를 가중치와 곱하고, 편향(bias)를 더하는 "선형 변환"을 수행한다. 주로 신경망의 출력층이나 중간층에 사용

장점: 입력과 출력 차원을 지정하여 데이터를 학습 가능한 파라미터(가중치와 편향)를 통해 변환함으로써 모델이 데이터의 특성을 학습하도록 도와준다.

nn.Conv2d

목적: 2차원 합성곱(convolution) 연산을 수행하는 계층(이미지 처리)

역할: 입력 데이터(예: 이미지)에서 특징(feature)을 추출하는 데 중요한 역할이며, 필터(커널)를 사용하여 입력 데이터를 슬라이딩하며 연산을 수행하고, 이미지의 특정 패턴이나 특징을 학습

nn.ReLU

목적: Rectified Linear Unit 활성화 함수로, 입력 값을 양수는 그대로 유지하고 음수는 0으로 만드는 비선형 함수다.

역할: 신경망에 비선형성을 추가하여 더 복잡한 패턴을 학습할 수 있게 합니다. 이는 선형 연산만으로 이루어진 모델이 해결하지 못하는 문제를 해결하도록 도와준다.

장점: 기울기 소실 문제를 방지, 대부분 신경망에서 기본 활성화 함수로 자주 사용한다.

• optim

- 매개변수를 학습하기 위한 최적화 알고리즘을 제공하는 모듈이다.

- 다양한 최적화 알고리즘(SGD, Adam, RMSprop)이 포함, 이를 통해 모델의 손실을 줄이는 방향으로 학습이 진행 된다.

• get_tokenizer

- torchtext 라이브러리에서 제공하는 유틸리티 함수로, 텍스트 데이터를 단어 또는 문장 단위로 나누기 위해 토크나이저를 생성할 때 사용한다.

- basic_english, spacy와 같은 다양한 옵션을 지정할 수 있어, 영어 텍스트와 같은 자연어 처리 작업에서 자주 활용한다.

- basic_english: 소문자 변환, 구두점 제거, 공백 기준 분리

- spacy: 언어 모델 기반 처리(사전 훈련된 언어 모델을 사용해 문장을 토큰으로 분할한다.), 품사 태깅(각 단어에 대한 푸사정보를 제공한다.), 형태소 분석(단어의 기본형과 어근을 추출하는데 도움을 준다.), 구두점 처리 및 특수문자 구분

• build_vocab_from_iterator

- 텍스트 데이터로부터 어휘 집합(vocabulary)를 생성한다.

- 모든 단어를 순회하며 고유한 단어를 모아 어휘집합을 만들고 단어를 정수로 매핑할 수 있는 사전을 생성한다.

- 자연어를 수치화하여 모델이 학습할 수 있는 형태로 만드는데 필수적이다.

• torch.utils.data.Dataset
• torch.utils.data.DataLoader

torch.utils.data.Dataset:

PyTorch의 데이터셋 클래스이며. 데이터를 불러오기 위해 이 클래스를 상속하여 사용자 정의 데이터셋을 구성할 수 있다.

torch.utils.data.DataLoader:

- Dataset에서 정의한 데이터셋을 배치 단위로 로드하고, 모델 학습을 위한 미니 배치를 생성하는 역할을 한다.

- DataLoader는 데이터를 배치로 분리하고 섞는(shuffle) 기능을 제공하여 학습 과정에서 데이터의 순서가 고정되지 않도록한다.

배치(Batch):

- 모델학습시 한 번에 처리할 데이터 샘플의 전체 집합을 의미한다. (100개의 데이터 샘플이있다면 하나의 배치에는 100개의 샘플이 들어 간다.)

미니 배치(Mini - batch):
전체 배치를 더 작은 그룹으로 나누어 처리하는 방식이다. 모델 학습 시 전체 데이터셋을 몇 개의 작은 그룹(미니배치)로 나누고, 각각의 미니 배치를 순차적으로 사용해 학습을 진행한다(100개의 샘플일 경우 배치크기(batch size를 10으로 설정하면 10개의 미니배치로 나위게 된다.)

.item메서드

- 스칼라 값을 가진 텐서에서 단일 값을 추출할 때 사용

- 손실(loss) 값이 단일 숫자 값으로 나오는 경우, 이 값을 item()을 통해 Python의 기본 자료형으로 변환

- 하나의 값만을 담고 있는 텐서에 대해서만 사용 가능

- tensor.tolist()를 사용하여 전체를 리스트로 변환하는 방법을 사용가능

☑️ GitHub

오늘 OSError를 해결하며 시간이 너무 비어서 github에서 포트폴리오를 만들기 위한 본인의 홈페이지를 만드는 시간을 가졌다.

우선 새로운 repositories를 만들어야한다.

만들 때 설정으로는

이름을

Repository name: 원하는 이름.github.io

Public 클릭

Add a README file 클릭

create repository 클릭

이제 새로운 레포지토리에서

+ 버튼 클릭

Create new file 클릭

name에 Create index.html 작성

Code에

<html>
  <body>
    <h1>한검 포트폴리오 만들기!</h1>
  </body>
</html>

를 작성해준다.

setting에 들어가 page 클릭

Branch에서 None을 Main으로 바꾸고 save클릭을 하게 되면 페이지 위쪽에 홈페이지 주소가 만들어진다.

여기까지 진행하였고 시간이 빌때나 주말에 홈페이지에 테마 추가를 진행해보려고 한다.

오늘은 모든 내용에 나의 생각이 들어가있으며 학습을 많이 진행하지목해 회고는 따로 작성하지 않았습니다.

합성곱 신경망(CNN)

순환 신경망(RNN)

어테션(Atention) 메커니즘

자연어 처리(NLP) 모델

회고

☑️ 합성곱 신경망(CNN)

🔎합성곱 신경망(CNN)이란?

• 이미지와 같은 2차원 데이터의 특징을 효과적으로 추출하기 위해 설계 된 신경망
• 필터를 통해 필터 내부의 값들을  학습함으로써 
• 합성곱 층, 풀링 층, 완전연결 층으로 구성
  • 합성곱 층:                                                                                                                                                                   - 다차원 데이터의 특징을 효과적으로 추출                                                                                                               - 입력 이미지에 필터(커널)을 적용하여 특징 맵을 생성                                                                                             - 필터는 이미지의 국소적인 패턴을 학습
  • 풀링 층                                                                                                                                                                         - 특징 맵의 크기를 줄이고 중요한 특징을 추출                                                                                                           - 주로 Max Pooling 과 Average Pooling이 사용
  • 완전 연결 층                                                                                                                                                                - 추출된 특징을 바탕으로 최종 예측을 수행                                                                                                              - CNN이라는 분석레이어를 통해 추출한 특성을 바탕으로 결론을 내리는 부분

🔎 합성곱 연산의 원리와 필터의 역할

• 합성곱 연산은 입력 이미지에 필터(커널)를 적용하여 특징 맵을 생성하는 과정입니다. 필터는 작은 크기의 행렬로, 이미지의 국소적인 패턴을 학습합니다.

1. 합성곱 연산:
   • 필터를 이미지의 각 위치에 슬라이딩하며, 필터와 이미지의 해당 부분 간의 점곱(dot product)을 계산합니다.
   • 계산된 값은 특징 맵의 해당 위치에 저장됩니다.
2. 필터의 역할:
   • 필터는 이미지의 에지(edge), 코너(corner), 텍스처(texture) 등 다양한 국소적인 패턴을 학습합니다.
   • 여러 개의 필터를 사용하여 다양한 특징 맵을 생성할 수 있습니다.

🔎 풀링 레이어의 필요성과 종류

• 풀링 층은 특징 맵의 크기를 줄이고, 중요한 특징을 추출하는 역할을 합니다. 풀링 층은 주로 Max Pooling과 Average Pooling이 사용됩니다.

1. Max Pooling:
   • 필터 크기 내에서 최대 값을 선택합니다.
   • 중요한 특징을 강조하고, 불필요한 정보를 제거합니다.
2. Average Pooling:
   • 필터 크기 내에서 평균 값을 계산합니다.
   • 특징 맵의 크기를 줄이면서, 정보의 손실을 최소화합니다.

🔎 플래튼 레이어의 역할

• 플래튼 층(Flatten Layer)은 2차원 특징 맵을 1차원 벡터로 변환하는 역할을 합니다. 이는 완전 연결 층에 입력으로 사용하기 위해 필요합니다. 

📚CNN 모델 정의

calss SimpleCNN(nn.Module): #nn.module을 import
    def__init__(self):
        super(SimpleCNN, self).__init__()
        #nn.Conv2d(입력채널, 출력 채널, 커널크기 3*3)
        #입력채널에 흑백사진은 1, RGB(컬러)인 경우에 3
        #출력채널이 증가하는 이유는 필터의 개수를 조절할 수 있기 때문
        self.conv1 = nn.Conv2d(3, 32, 3, padding=1) 
        self.pool = nn.MaxPool2d(2, 2)
        #다음 레이어의 입력은 그 전의 출력과 동일해야 한다.
        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
        self.fc1 = nn.Linear(64 * 8 * 8, 512)
        self.fc2 = nn.Linear(512,10)
        

    def forward(self, x):
        #relu 컨볼루션할 네트워크 뒤에 활성화 함수가 와야한다.(복잡한 데이터 특성 학습하기 위해)
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = x.view(-1, 64 * 8 * 8)  # 플래튼 (차원 축소 즉. 펼친다)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x        

☑️ 순환 신경망(RNN)

🔎 순환 신경망(RNN)

• 시퀀스 데이터를 다루는데 유용 (주가 / 문장 등 데이터가 숱서를 이루고있을 때)
• 시계열 데이터를 처리하기 위해서 각 시점에서 입력을 받는다. tn => 그 때 출력을 바로 다음 시간에 입력으로 받는다 => 이 과정에서 이전 시점의 정보를 저장하는 숨겨진 상태
• RNN의 기본 요소는 순환노드 일반적으로 쉘 각 시점의 입력과 숨겨진 상태를 결합해 새로운 숨겨진 상태와 출력을 만든다 이렇게 새롭게 만들어진 hidden state는 다시 순환을 한다.
• 시퀀스의 각 시간 단계에서 동일한 가중치 공유 (가중치가 전체적으로 업데이트 된다.)

🔎LSTM & GRU

• 기울기 소실 문제 해결 위한 방법

1. LSTM은 셀 + 게이트(입력게이트 / 망각 게이트/출력 게이트)로 구성

• 셀: 각 시점 정보흐름 조절, 정보 장기 유지
• 게이트: 정보를 선택적으로 저장하거나 삭제
• 입력 게이트: 새로운 입력과 이전의 숨겨진 상태를 결합해서 새로운 정보가 새 상태에 얼마나 반영할지 조절해준다.
• 망각 게이트: 새 상태에서 어떤 정보를 잊을지 정해준다.
• 입력 / 망각 게이트의 출력을 바탕으로 쉘상태 업데이트 한다.
• 출력 게이트: 새로운 쉘 상태와 입력 데이터를 바탕으로 출력을 생성
• 그리고 다시 순환한다.

2. GRU

• LSTM의 변형으로 더 간단한 구조
• 쉘상태와 hidden state를 통합한다.
• 리셋/ 업데이트 게이트로 구성
• 리셋 게이트: 새정보와 이전 정보를 결합해 이전 정보를 얼마나 잊어 버리는기 결정하는데 사용
• 업데이트 게이트: 이전 상태와 새로운 입력을 결합 그리고 새로운 정보가 상태에 반영할지 결정

=> RNN은 시퀀스 데이터에 적합하다 이전 단계를 반영할 수 있어서 근데 긴 시퀀스에선 정상적이지 않아 게이트를 활용해 정보를 체계적으로 관리하는 LSTM과 GRU가 나왔다.

🔎시계열 데이터 처리

1. 데이터 전처리:
   • 시계열 데이터를 적절한 형태로 변환하고, 정규화(normalization)합니다.
   • 입력 시퀀스와 출력 시퀀스를 정의합니다.
2. 모델 구축:
   • RNN, LSTM, GRU 등의 모델을 정의합니다.
   • 입력 크기, 은닉 상태 크기, 출력 크기 등을 설정합니다.
3. 모델 학습:
   • 손실 함수와 최적화 알고리즘을 정의합니다.
   • 순전파와 역전파를 통해 모델을 학습시킵니다.
4. 모델 평가:
   • 테스트 데이터를 사용하여 모델의 성능을 평가합니다.

📚데이터 셋 생성 및 전처리

# Sine 파형 데이터 생성 (sine함수는 위아래로 구불구불하게 반복되는 것)
def create_sine_wave_data(seq_length, num_samples):
    X = []
    y = []
    for _ in range(num_samples):
        start = np.random.rand()
        x = np.linspace(start, start + 2 * np.pi, seq_length)
        X.append(np.sin(x))
        y.append(np.sin(x + 0.1))
    return np.array(X), np.array(y)

seq_length = 50
num_samples = 1000
X, y = create_sine_wave_data(seq_length, num_samples)

# 데이터셋을 PyTorch 텐서로 변환(pytorch에서tensor라는건 기울기를 계산할 수 있는 자료구조)
X = torch.tensor(X, dtype=torch.float32).unsqueeze(-1)
y = torch.tensor(y, dtype=torch.float32).unsqueeze(-1)

📚RNN 모델 정의

class SimpleRNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleRNN, self).__init__()
        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True) #RNN만들기( batch_first=True는 첫번째 batch 결정)
        self.fc = nn.Linear(hidden_size, output_size) #출력레이어

    def forward(self, x):
        h0 = torch.zeros(1, x.size(0), hidden_size)  # 초기 은닉 상태 (초기 값에는 hidden state가 없기 때문)
        out, _ = self.rnn(x, h0) #rnn에 x를 전달해주고 다시 은닉상태 전달
        out = self.fc(out[:, -1, :])  # 마지막 시간 단계의 출력
        return out

input_size = 1
hidden_size = 32
output_size = 1
model = SimpleRNN(input_size, hidden_size, output_size)

📚LSTM모델 정의

class SimpleLSTM(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleLSTM, self).__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        h0 = torch.zeros(1, x.size(0), hidden_size)  # 초기 은닉 상태
        c0 = torch.zeros(1, x.size(0), hidden_size)  # 초기 셀 상태
        out, _ = self.lstm(x, (h0, c0))
        out = self.fc(out[:, -1, :])  # 마지막 시간 단계의 출력
        return out

model = SimpleLSTM(input_size, hidden_size, output_size)

📚모델학습

# 손실 함수와 최적화 알고리즘 정의
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.01) #여기선 Adam을 쓰고있는데 SGD나 다른 것들도 있지만 실험적으로 사요해보아야한다.

# 모델 학습
num_epochs = 100
for epoch in range(num_epochs):
    outputs = model(X)
    optimizer.zero_grad()
    loss = criterion(outputs, y)
    loss.backward()
    optimizer.step()

    if (epoch + 1) % 10 == 0:
        print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')

print('Finished Training')

☑️ 어텐션 (Attention) 메커니즘

🔎 어텐션 (Attention) 메커니즘란?

• 시퀀스 데이터의 중요한 부분에 많은 가중치를 할당해서 종보를 효율적
• 자연어 처리, c계열 데이터에서 사용 (번, 요약, 질의 응답 등)
• 입력의 시퀀스를 보고 중요도를 평가해 가중치로 바뀌어 각 요소에 부여

🔎 어텐션 (Attention) 메커니즘란 동작방식

• Atention score(중요도) = query와 key간의 유사도를 dot product를 사용해 계산
• 계산된 Atention score(중요도)는 Softmax 함수를 통해 확률로 변환
• 모든 Atention score (가중치)의 합은 1이 된다
• 이 Atention score(가중치)를 value에 곱한다
• 그러면 value에는 가중치가 반영된 정보다 된다.(중요한 부분이 어딘지 판별할 수 있게 되는 것이다)

• 비유

1. 독서클럽에서 책을 읽는다(책=시퀀스입력데이터)
2. 멤버들이 서로 질문을하고 답을 참고하며 중요도를 찾는다
3. 답(key), 질문(query쿼리)을 비교해서 얼마나 중요한지 평가 후 가중치 부여
4. 최종덕으로 답에 기반해서 최종 요약(value)을 만든다.

🔎 Multi-Head Attention

• Multi-Head Attention은 여러 개의 Self-Attention을 병렬로 수행하는 메커니즘입니다.
• 각 헤드는 서로 다른 부분의 정보를 학습하며, 이를 통해 모델이 다양한 관점에서 데이터를 처리할 수 있습니다.

☑️ 자연어 처리(NLP) 모델

🔎  자연어 처리(NLP)란?

• 자연어를 컴퓨터가 이해하고 처리할 수 있도록 돕는 기술을 자연어 처리(NLP)라고 합니다. 이를 통해 컴퓨터는 사람의 언어를 분석하고, 번역하거나 질문에 답하는 등의 작업을 수행할 수 있습니다

🔎워드 임베딩 기법

• 단어를 고정된 크기의 백터(숫자)로 변환 시킨다.
• 대표적인 워드 임베딩 기법으로는 Word2Vec과 GloVe가 있습니다.

Word2Vec

단어를 백터로 변환하는 2가지 모델 제공

• CBOW (Continuous Bag of Words): 주변 단어(context)로 중심 단어(target)를 예측합니다.                                          ( 나 장한검 백수 라고 하면 "나" 와 "백수"를 사용해 예측한다.)
• Skip-gram: 중심 단어(target)로 주변 단어(context)를 예측합니다.                                                                                    ( 나 장한검 백수에서 "장한검"을 보고 "나"와 "백수" 예측)

GloVe

단어-단어 공기행렬(word-word co-occurrence matrix)을 사용, 단어 벡터를 학습합니다

🔎 Transformer의 구조와 원리

• Transformer는 순차적인 데이터를 병렬로 처리할 수 있는 모델로, 자연어 처리에서 뛰어난 성능을 보입니다.
• Transformer는 인코더-디코더(Encoder-Decoder) 구조로 구성됩니다

인코더

입력 문장을 인코딩(고차원 백터로 변환)

• 입력 백터들이 각각 고정된 크기의 백터(임베딩)으로 변환(이 때 포지셔널 인코딩이라는 것을 포함해서 단어의 순서정보를 백터에 포함 시켜준다)
• Multi-Head의 selfatention이 동작한다. 입력 백터들이 각기 다른 헤드를 통해 서로의 중요도를 평가하고 이 정보로부터 새로운 백터를 만든다.
• selfatention메커니즘을 사용해서 문장 내에 관계를 학습하게 된다.

디코더

• 위 백터를 보고 출력하고자하는 목적에 따라 문장을 생성
• 타겟문장의 각 단어를 고정 된 크기의 백터로 변환한다
• 포지셔널 인코딩을 추가
• 마스크드 멀티헤드 셀프 어텐션이 동작한다. (이전의 단어들만 참고할 수 있도록 selfatention을 마스킹해서 참고한다)
• 인코더 디코더 어텐션이 동작(디코더는 인코더의 출력백터를 참고하고 입력문장의 정보를 바탕으로 타겟문장의 다음 단어를 예측한다.)
• 어텐션으로 변환 된 백터가 나오는데 피드포워드신경망을 통해 추가로 변환된다.
• 이러한걸 여러 층을 통해 반복해서  인코딩 백터를 만들고 이걸 이용해 디코딩 백터를 만든다.

어텐션 메커니즘

• 어텐션 메커니즘은 입력 시퀀스의 각 위치에 가중치를 부여하여, 중요한 정보를 강조합니다.
• 셀프 어텐션은 입력 시퀀스 내의 단어 간의 관계를 학습합니다.

=> 인코더 디코더를 통해 입력문장을 인코딩하고 디코더를 통해 출력을 생성 이 과정에서 어텐션 메커니즘이 사용 되고 이는 단어간의 관계를 학습하는데 사용하게 된다. 

인코더 디코더 어텐션을 통해 입력과 출력을 연결하고 모델은 데이터의 의미적 유사성을 학습하고 이를 바탕으로 번역을 진행하게 된다.

🔎 BERT란?

• Transformer 인코더를 기반으로 한 사전 학습된 언어 모델입니다.
• 양방향으로 문맥을 이해할 수 있어, 다양한 자연어 처리 작업에서 뛰어난 성능을 보입니다.
• 사전학습: 대규모 텍스트 코퍼스를 사용해 학습 된다. (마스킹 언어 모델, 다음 문장 예측 작업으로 학습)
• 입력을 처리해서 입력문장은 토큰화해서 단어토큰으로 변환
• 마스킹해서 일부 스퀀시를 마스킹한다.
• 인코더는 마스킹 된 시쿼스를 인코더로 처리해서 각 단어의 컨텍스트를 이해하고 마스킹 된 단어를 예측하고 다음 문장이 올바른지 예측하는 방식으로 동작

=> 사전학습된 bert모델은 특정 작업에 맞게 파인 튜닝 되는에 이를 통해 번역, 질의응답, 분류 등 다양한 목적에 맞춰 모델을 튜닝하게 된다.

☑️회고

최근 회고에는 궁금하거나 새롭게 알게 된 정보가 적게 들어 가는 것 같습니다.

그도그럴게 현재 배우는 부분이 머신러닝 딥러닝이다 보니 정의나 개념 새롭게 보게 되는 코드들이 어떤 작용을 하는지에 대한 부분만 주의 깊게 공부하고있기 때문입니다.

그래서 오전에 공부한 용어 공부 중 

마음 속 한켠에 자리잡고있던 궁금증을 해결한 것을 적으려고 합니다.

그것은 바로 차원 배열 ndarray에 대한것 입니다.

1차원 2차원 3차원 4차원 처음 들었을 때는 저게 뭐지 싶었고

설명을 들으면 들을수록 코드를 작동시켜 답을 출력 시켜보아도 어떤 것인지 모르겟고 

그냥 저런게 있구나 하고 넘어 갓는데 

오늘 어느정도 이해했습니다.

• 3차원에 대한 이해

shape함수로 차원을 확인할 수 있습니다. 1차원 (n,)#(행) / 2차원 (n, n)#(행, 열) / 3차원(n, n, n)#(높이,행,열)

저는 3 차원이 이해가 안 가서

제가 이해하기 쉽게 하려고 엑셀 표 형식을 떠 올려서 정리를 했습니다.

arr_3d = np.array([ [[1, 2], [3, 4]], [[5, 6], [7, 8]] ])

print(arr_3d.shape) #출력: (2, 2, 2)

각 셀마다 한 개의 숫자들이 들어간 2x2표가 2개가 만들어진 것이다.

셀 8개 중에 4개씩 1개의 표를 만들어 2개의 표가 된 것이 3차원

차원의 수로 표의 수가 정해지는 건지 궁금해져서 gpt에 물어보니 그건 또 아니네요

표가 늘어나는건 3차원 (n1,n2,n3)에서 n1인 높이 숫자가 올라가는거라고 하네요

• 브로드캐스팅

브로드캐스팅에서 두 개의 배열 중 하나라도 크기가 1인 것이 없으면 오류가 난다고 했는데 1은 바로 열의 크기였습니다.

쉽게 말해 대괄호[] 안에 1가지의 숫자만 들어간 배열이여야지 차원이 다른 배열끼리 브로드캐스팅이 된다고 합니다.

차원의 수가 올라갈수록 배열에 대괄호가 많아지는 것 같은데 정확히 어떻게 짜야하는 이해가 안되더군요.

그래도 고차원의 배열을 직접 손으로는 칠일은 없겟지 하는 마음으로 대괄호가[] 늘어나는구나 정도로 이해하고 넘어가겟습니다. 감사합니다. 

• 딥러닝 개념
• 신경망의 기본 원리
• 인공 신경망
• 회고

☑️ 딥러닝 개념

🔎딥러닝이란?

• 딥러닝은 인공신경망(Artificial Neural Networks)을 기반으로 한 기계 학습의 한 분야입니다.
• 다층 신경망을 사용하여 데이터로부터 특징을 자동으로 학습하고, 이를 통해 복잡한 문제를 해결합니다.
• 입력 데이터에서 중요한 패턴을 추출하고, 이를 바탕으로 예측, 분류, 생성 등의 다양한 작업을 수행할 수 있습니다.
• 머신러닝에서 중요한 패턴은 큰영향을 주는 데이터를 말한다.(문제해결을 위해 가장 잘 동작하는 특징)

🔎딥러닝의 특징

• 비선형 추론: 딥러닝은 비선형 추론을 통해 복잡한 데이터의 패턴을 학습할 수 있습니다.
• 다층 구조: 여러 층의 신경망을 사용하여 데이터의 고차원 특징을 학습합니다.
• 자동 특징 추출: 데이터로부터 중요한 특징을 자동으로 추출하여 별도의 특징 공학(feature engineering) 과정이 필요 없습니다.

🔎머신러닝과의 차이 

• 머신러닝: 데이터 전처리를 통하여 중요한 데이터를 추출해서 사용
• 딥러닝: 데이터만 줘도 자동으로 추출, 작동까지 가능

🔎딥러닝 활용(대표적)

• 이미지 인식
• 자연어 처리
• 음성인식
• 의료 분야

☑️ 신경망의 기본 원리

🔎 신경망이란? (사람의 뇌)

• 인공 신경망이란 퍼셉트론으로 이루어진 네트워크 

🔎 퍼센트론이란?(뇌속의 뉴런)

• 퍼셉트론(Perceptron)은 인공 신경망의 가장 기본적인 단위로, 하나의 뉴런을 모델링한 것입니다.
• 퍼셉트론은 입력 값을 받아 가중치(weight)를 곱하고, 이를 모두 더한 후 활성화 함수(activation function)를 통해 출력 값을 결정합니다.
• 곱하고 더하고 함수적용시켜 출력

🔎 다층 퍼센트론이란?

• 다층 퍼셉트론(Multi-Layer Perceptron, MLP)은 여러 층의 퍼셉트론을 쌓아 올린 신경망 구조입니다.
• MLP는 입력층(input layer), 은닉층(hidden layer), 출력층(output layer)으로 구성되며, 각 층의 뉴런들이 서로 연결되어 있습니다
• 입력 레이어(Input Layer) : 외부 데이터가 신경망에 입력되는 부분입니다. 입력 레이어의 뉴런 수는 입력 데이터의 특징 수와 동일합니다.
• 은닉 레이어(Hidden Layer) : 은닉 레이어는 입력 레이어와 출력 레이어 사이에 위치한 층으로, 입력 데이터를 처리하고 특징을 추출하는 역할을 합니다. 은닉 레이어의 뉴런 수와 층 수는 모델의 복잡성과 성능에 영향을 미칩니다.
• 출력 레이어(Output Layer) : 출력 레이어는 신경망의 마지막 층으로, 최종 예측 값을 출력합니다. 출력 레이어의 뉴런 수는 예측하려는 클래스 수 또는 회귀 문제의 출력 차원과 동일합니다.

🔎 활성화 함수란?

• 활성화 함수는 신경망의 각 뉴런에서 입력값을 출력값으로 변환하는 역할을 합니다.
• 활성화 함수가 없다면 신경망은 단순 선형변환만 수행하게 되어 복잡한 패턴을 학습할 수 없습니다.
• 활성화 함수는 비 선형성을 도입하여 신경망이 복잡한 패턴을 학습할 수 있게합니다.
• ReLU (Rectified Linear Unit): 계산이 간단하고, 기울기 소실 문제 완화
• Sigmoid: 확율을 나타내기 적합
• Tanh (Hyperbolic Tangent)

🔎 손실 함수

• 손실 함수(Loss Function)는 모델의 예측 값과 실제 값 사이의 차이를 측정하는 함수입니다.
• 손실 함수는 모델의 성능을 평가하고, 최적화 알고리즘을 통해 모델을 학습시키는 데 사용됩니다.
• 회귀문제에서 주로 사용 된다.

🔎 최적화 알고리즘

• 최적화 알고리즘(Optimization Algorithm)은 손실 함수를 최소화하기 위해 모델의 가중치를 조정하는 방법입니다.
• 최적화 알고리즘은 손실 함수의 기울기를 계산하고, 이를 바탕으로 가중치를 업데이트합니다.

🔎 역전파 

• 연쇄 법칙(Chain Rule)을 사용해 손실함수의 기울기를 계산합니다.
• 각 층의 기울기는 이전 층의 기울기와 현재 층의 기울기를 곱하여 계산합니다.
• 이를 통해 신경망의 모든 가중치가 업데이트 됩니다

☑️ 인공 신경망(ANN)

🔎 인공 신경망(ANN)

• 인공 신경망(Artificial Neural Network, ANN)은 생물학적 신경망을 모방하여 설계된 컴퓨팅 시스템입니다
• ANN은 입력층(Input Layer), 은닉층(Hidden Layer), 출력층(Output Layer)으로 구성되며, 각 층은 뉴런(Neuron)으로 이루어져 있습니다.
• 입력층: 입력 데이터를 받아들이는 층. 입력층의 뉴런수는 입력데이터 피펴수와 동일
• 은닉층 : 입력데이터를 처리하고 특징을 처리하는 층.은닉층의 뉴런수와 층수는 모델의 복잡성과 성능에 영향
• 출력층 : 최종 예측값을 출력하는 층. 출력층의 뉴런수는 예측하려는 클래스 수 또는 회귀문제 출력차원과 동일

🔎 동작방식

1. 순전파 (Forward Propagation)
   • 입력 데이터를 통해 각 층의 뉴런이 활성화되고, 최종 출력 값을 계산합니다.
   • 각 뉴런은 입력 값에 가중치(weight)를 곱하고, 바이어스(bias)를 더한 후 활성화 함수(activation function)를 통해 출력 값을 결정합니다.
2. 손실 계산 (Loss Calculation)
   • 예측 값과 실제 값의 차이를 손실 함수(Loss Function)로 계산합니다.
3. 역전파 (Backpropagation)
   • 손실 함수의 기울기를 출력층에서 입력층 방향으로 계산하고, 이를 바탕으로 가중치를 업데이트합니다.
    

🔎 출력 레이어의 유형

1. 회귀 문제 (Regression):
   • 출력 레이어의 뉴런 수는 예측하려는 연속적인 값의 차원과 동일합니다.
   • 활성화 함수로는 주로 선형 함수(linear function)를 사용합니다.
2. 이진 분류 문제 (Binary Classification):
   • 출력 레이어의 뉴런 수는 1입니다.
   • 활성화 함수로는 시그모이드 함수(Sigmoid Function)를 사용하여 출력 값을 0과 1 사이의 확률로 변환합니다.
3. 다중 클래스 분류 문제 (Multi-Class Classification):
   • 출력 레이어의 뉴런 수는 예측하려는 클래스 수와 동일합니다.
   • 활성화 함수로는 소프트맥스 함수(Softmax Function)를 사용하여 각 클래스에 대한 확률을 출력합니다.

📚  PyTorch 및 필요한 라이브러리 임포트

import torch #핵심 라이브러리 

import torch.nn as nn #신경망 구축을 위한 네트워크들이 포함 되어있다

import torch.optim as optim #최적화 (어떤 함수들의 최소나 최대로 만드는 변수를 찾는 것)

import torchvision #이미지처리 라이브러리

import torchvision.transforms as transforms #데이터 전처리를 위한 라이브러리

📚  데이터셋 로드 및 전처리

#데이터셋 전처리

# transform 이라는 분분은 여러 부분을 순차적으로 변환 시켜준다.

# transforms.ToTensor() 이미지를 tensor라고 하는 파이토치에서 사용하는 기본 자료구조로 변환.

# transforms.Normalize 이미지를 정규화 해준다.평균을 0.5, 표준편차를 0.5로 설정했다.

transform = transforms.Compose([

            transforms.ToTensor(),

            transforms.Normalize((0.5,), (0.5,))

])

정규화란

data의 평균(data가 어떤 값을 가지냐)과 분산(data가 얼마나 퍼졌있냐)

예시)

키 0~3m

나이 0~200세

재산 0~1000억

ax+b 형태로 페셉트론이 형성 된다

x가 0~200일때랑 0~1000억일때 어느쪽이 더 영향력이 큰가 재산이다. 그런데 재산이 문제를 해결하기 위해 키나 나이보다 중요한 의미를 가질까? 아닐 수 있다(재산이 너무 크면 키나 나이가 반영이 안될 수 있다,). 그래서 각각의 표준과 평균을 맞춰 주는게 학습을 원활하게 해준다.

#MNIST 데이터셋 로드 

# sorchvision.datasets.MNIST 토치비젼에있는MNIST를 다운로드 한다.

# root='./data 다운로드 하기 위한 경로

# train=True train셋인지 본다.

# download=True 다운로드 할것인지 본다.

# transform=transform transform을 전달해주면서 데이터를 전처리 한상태로 다운로드 해주는 것

trainset = sorchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)

trainloader = torch.utils.data.DataLoader(trainset, batch_size=64,suffle=True)

# torch에 utils에 data에 DataLoader를 가져온다.

# batch_size는 데이터를 쪼개준다 (학습속도를 높이기 위해)

# suffle 데이터를 쪼갤때 손상이 갈 수 있어 섞어서 batch를 만들게해준다.

testset = torchvision.datasets.MNIST(root='./data', train=False, downlad=True, transform=transform)

testloader = torch.utils.dataDataLoader(testset, batch_size=64, shuffle=False)

📚 간단한 ANN 모델 정의

class SimpleANN(nn.Module): #클래스 정의 이름정하기 nn.module 상속받기 (nn.module을 상속받음으로써 딥러닝모델을 만들기 위한 기본기능을 사전에 가져오는 것)
#class가 생성되는 순간 model을 만들고  그때 자동으로 호출 된다 

#부모 클래스에서 기능을 작동하는 super함수를 불러준다.

   def __init__(self): 
        super(SimpleANN, self).__init__()
       #  self.fc1 레이어를 만들어준다.

       # nn.Linear(28 * 28, 128) ANN모델을 설정해준다. 28*28은 data의 크기/128은 fc2의128로 64는 fc3의 64로

        self.fc1 = nn.Linear(28 * 28, 128)  # 입력층에서 은닉층으로
        self.fc2 = nn.Linear(128, 64)       # 은닉층에서 은닉층으로
        self.fc3 = nn.Linear(64, 10)        # 은닉층에서 출력층으로

    def forward(self, x):
        x = x.view(-1, 28 * 28)  # 입력 이미지를 1차원 벡터로 변환
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

📚 모델 학습

#모델 초기화
model = SimpleANN()

#학습 전 결과 출력 (비교를 위해)
correct = 0
total = 0
#no_grad는 메모리 효율성을 위해 사용
#no_grad는 평가단계에서 기울기를 계산하지 않는다 지정(오차함수를 줄이는 방향으로 업데이트 한다는 의미)
#no_gard 동안에는 학습을 진행하지 않는다.
with torch.no_grad():
    #학습을 진행하지 않는 상황에서 데어로더에서 데이터를 하나씩 꺼내서
    for data in testloader:
        #데이터의 이미지와 레이블을 본다
        images, labels = data
        #그뒤 모델에 전달해서 예측 값을 본다(outputs).
        outputs = model(images)
        #torch.max를 통해서 가능성의 최대값을 찾는다.
        _, predicted = torch.max(outputs.data, 1)
        #레이블의 사이즈를 total에 더해준다
        total += labels.size(0)
        #batch의 크기를 반환해서 실제 데이터를 알수있는 상태
        #예측값과 실제값이 일치하는 샘플을 찾는거다.
        correct += (predicted == labels).sum().item()

print(f'Accuracy of the network on the 10000 test images: {100 * correct / total:.2f}%')

# 손실 함수와 최적화 알고리즘 정의
#CrossEntropyLoss는 분류모델에서 성능을 확인하기 위한 손실함수
criterion = nn.CrossEntropyLoss()
#SGD는 최적화에서 기울기(가중치)를 업데이트를 할 때 사용
#전체를 보게하면 너무 느리니 일부만 보게해서 기울기 계산
#lr 학습율 정하기 (가중치 변화량 조절) 값은 적당히 작게하고 문제와 데이터크기에 따라 달라서 실험적으로 정해야한다.
#parameters 업데이트를 하기 위한 파라미터 지정
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

#epoch 전체데이터를 몇번 반복할건지를 말한다.
#range(10) 10번 선택
for epoch in range(10):
    #손실함수가 어느정도 발생했는지 보기 위함?
    running_loss = 0.0
    #i는 인덱스
    #data는 data
    for i, data in enumerate(trainloader,0):
        inputs, labels = data
        
        #optimizer는 연쇄계산이라 기울기 초기화
        optimizer.zero_grad()
        
        #순전파로 계산
        outputs = model(inputs)
        #loss계산
        loss = criterion(outputs, labels)
        #loss를 다시 뒤로 전달해서 각각의 loss가 어떻게 반영해야 되는지 알려준다
        #기울기를 찾는다.
        loss.backward()
        #기울기를 바탕으로 가중치를 업데이트
        optimizer.step()
        
        #loss출력
        running_loss += loss.item()
        #100개의 미니배치마다 출력
        if i%100 == 99:
            print(f'[Epoch {epoch + 1}, Batch{i + 1}] loss: {running_loss / 100:.3f}')
            running_loss = 0.0
            
print('Finished Training')

☑️ 회고

오늘은 고민이 해결 되는 날이였다.

내용은 어렵다 보니 집중력이 떨어져 많은 공부를 하지 못했지만

이때까지 내가 근본적으로 궁금해했지만 그걸 어떻게 설명해야할지 모르겟던 질문이 생각났고 답을 찾게 되었다.

그 질문은 바로

이렇게 머신러닝 딥러닝 코드를 짜고 학습시켜서 이미지 분류하는 모델를 만든다고 했지만 실제로는 어떻게 적용시켜? 뭐 할 때 써?

질문 자체가 이걸 내가 왜 배우고있어? 이런 뉘앙스여서 여태 쉽게 정의 하지 못한듯하다.

하지만 정말 간단했고 답을 찾았을 땐 시원했다. (이제는 나를 불편하게 했던 녀석이 없어졌기 때문!!)

위 질문의 해답은 MNIST나 비슷한 모델들이 사용 되고있는 실제사례를 알게 되었고

가장 궁금했던 어떻게 적용하고 쓰냐 이건데

복잡한 과정이 많아 보이지만 짧게 정리한다면

로컬환경(어플리케이션 등)을 만들어서 학습모델 코드를 집어넣어 작동시키는 것이였다.

모델도 만들고 그것을 사용하기 위한 환경도 만든다니 너무 어려워 보이지만

매우 기대가 된다.