선형회귀 실습

colab 이용하기 (구글에서 만든 주피터랑 비슷한 툴) 
https://colab.research.google.com/notebooks/intro.ipynb#recent=true

파이참에 tensorflow-cpu 라이브러리 설치하기
→ 설치 안되면 파이썬 버전 낮춰서 Project 새로 만들기

• tensorflow , plot(그래프 그리는)을 하기 위한 라이브러리 import
• linear regression을 하기 위한 model 생성 - 클래스 활용해서 생성
  • __init__ : 클래스 생성자
    • 모델을 만들면 W, b 값을 5, 0으로 초기 셋팅이 되게 하는 생성자
  • __call__ : tensorflow에서 짜면 자동으로 모델이 잘 호출이 된다.
    • y = model(x) 이런식으로 호출 가능하다.

import tensorflow as tf
import matplotlib.pyplot as plt

# linear regression model
class Model(object):
  def __init__(self):
    self.W = tf.Variable(5.0)
    self.b = tf.Variable(0.0)
  
  def __call__(self, x):
    return self.W * x + self.b # 가설값

• MSE: Mean Squared Error
  • 실제값과 가설값의 차이
  • y : 실제값 , predicted : 가설값
  • reduce_mean : 평균 구해주는 함수
  • square : 제곱해주는 함수

# MSE: Mean Squared Error
def loss_function(y, predicted):
  return tf.reduce_mean(tf.square(predicted - y))

• input을 random으로 만들고 w랑 b를 더하면 완전 선이 되니까 noise 를 더해준다.
• scatter 함수 → plt 라이브러리
  • outputs : 실제값 , c : color
  • model 함수 : 위에서 W와 b값을 미리 만들었기 때문에 그것에 대한 가설
• 실제 y값 = 3(실제 W값) * inputs(x값) + 2(실제 b값) + noise

model = Model()

true_w = 3.0 # 실제 W값
true_b = 2.0 # 실제 b값
examples = 1000 # 데이터 갯수

inputs = tf.random.normal(shape=[examples]) # input을 1000개 만든다.
noise = tf.random.normal(shape=[examples]) # noise를 1000개 만든다.
outputs = inputs*true_w + true_b + noise # 실제 y값

plt.scatter(inputs, outputs, c='b') # y - 파란선
plt.scatter(inputs, model(inputs), c='r') # H(x) - 빨간선
plt.show()

• outputs : 실제 y 값 , model(inputs) : 가설 h값
• 결과 Tensor 라는 함수로 반환을 하고 현재 loss는 8.85라고 출력

# loss function을 정의한 것에 대해서 loss값을 구해오는 것
loss = loss_function(outputs, model(inputs))
print(loss)

• GradientTape() 함수 : Tensorflow에 내장되어 있는 함수 사용
  • gradient 를 직접 구하기가 힘드니까 직접 구해주는 함수
  • gradient() 함수 호출하면 알아서 구해준다.

• 현재 loss를 기반으로 W와 b에 대해서 Gradient값을 구해주는 것
  • gradient : 기울기
• assign_sub : Gradient Descent 과정에서 learning rate를 곱해서 적용

# Gradient Desent를 적용하는 과정
def train(model, inputs, outputs, learning_rate):
  with tf.GradientTape() as t:
		# loss function을 정의한 것에 대해서 loss값을 구해오는 것
    current_loss = loss_function(outputs, model(inputs))
  dW, db = t.gradient(current_loss, [model.W, model.b])
  model.W.assign_sub(learning_rate*dW)
  model.b.assign_sub(learning_rate*db)

• train() 함수 : 학습하는 함수
• 반복문을 돌면서 loss를 구해서 출력 , 반복 학습
• numpy() 함수 : loss_function의 loss값만 가지고 오는 함수

Ws, bs = [], [] # plot 저장할 변수
epochs = 15 # 학습데이터에 대해서 몇번 반복할지에 대한 변수
for epoch in range(epochs):
  Ws.append(model.W.numpy())
  bs.append(model.b.numpy())
  current_loss = loss_function(model(inputs), outputs)

  train(model, inputs, outputs, learning_rate=0.1)
  print('epoch: %2d, W=%1.2f, b=%1.2f, loss=%2.5f'%(epoch, Ws[-1], bs[-1], current_loss))

• W값과 b값을 찾아가는 과정을 나타낸 그래프

plt.plot(range(epochs), Ws, 'r', range(epochs), bs, 'b')
plt.show()

선형회귀분석을 1차원으로 봤는데 딥러닝에서는 수십 차원에 대해서 학습한다.
딥러닝에서는 선이 굴곡지게 그려지는데 실제로 제일 잘 맞는 선을 찾아야함.
너무 많이 돌리면 학습 데이터에 너무 학습이 된다.
노이즈가 조금 달라서 조금만 달라져도 값이 엄청 차이가 나면 실제 데이터에서 성능이 안나오게 된다.
→ 아주 많이 돌리면 Overfitting이 일어난다.

로지스틱 회귀

이진 분류(Binary Classification)

• 2가지중 하나를 선택하는 문제

시그모이드 함수(Sigmoid Function)

• S자 형태로 그려지고, 0과 1 사이의 값을 가지는 함수

import numpy as np
import matplotlib.pyplot as plt

def sigmoid(x):
  return 1/(1+np.exp(-x))

x = np.arange(-5.0, 5.0, 0.1)
y = sigmoid(x)

plt.plot(x, y, 'g')
plt.plot([0,0],[1.0,0.0], ':') # 가운데 점선 추가
plt.title('Sigmoid Function')
plt.show()

→ 0을 기준으로 0보다 클때는 1로 분류 , 0보다 작을때는 0으로 분류

→ 두개로 분류하는 logistic regression

• 이런식으로 Sigmoid function이 움직이면서 분류에 맞게 점점 함수가 모양을 찾아감
  • Linear Regression이 처음에 선을 점점 옮겨가면서 데이터에 맞게 찾아가는 것처럼 Rogistic Regression은 Sigmoid Function이 움직여가면서 두개로 분류를 할 수 있게 모델이 움직인다.

비용함수(Cost function or Loss function)

• 실제값이 1이고 예측값이 0일 때는 cost가 무한으로 발산 실제값이 0이고 예측값이 0일 때는 cost가 0

→ cost를 이런 식으로 지정을 해주면 위의 내용이 바로 반영이 된다.

• 위에서 반영이 된 cost 값들을 다 더하게 cost function을 디자인을 한다.
• 이러한 cost function 을 cross entropy라고 함 → 분류에서 항상 사용이 됨 !! 중요한 부분

지금은 두개라서 0 ,1 인데 밀리면서 0 ,1 , 2 , 3 .. 이런식으로 디자인을 해서 멀티 클래스에서도 cross entropy를 기반으로 분류를 할 수 있음

Linear Regression이랑 Logistic Regression이 지금은 1차원으로 다루고 있지만 점점 2차원 , 3차원으로 올라가는게 딥러닝이다.

로지스틱 회귀 실습

import numpy as np
import tensorflow as tf

# numpy를 가지고 데이터를 임의로 만들어줌
# 데이터가 - 일때는 0이 되고 , + 일때는 1로 분류
x = np.array([-5, -3, -1, 1, 3, 5])
y = np.array([0, 0, 0, 1, 1, 1])

• loss function 함수 정의
  • y 값과 예측값(predicted 값)을 받아옴
  • cost function 수식대로 짜준다.

# cross entropy loss function
def loss(y, predicted):
  return tf.reduce_mean(-y*tf.math.log(predicted) - (1+y)*tf.math.log(1-predicted))

• 모델 생성
  • W만 정의해준다. → W만 있던지 b랑 W랑 있던지 똑같은 과정임

class Model(object):
  def __init__(self):
    self.W = tf.Variable(-0.01)

  def __call__(self, x):
    return 1/(1+tf.math.exp(self.W*x))

model = Model()

• 학습 함수
  • gradient 기울기 값 구해서 assign_sub 해줌
  • assign_sub : Gradient Descent 과정에서 learning rate(학습률)를 곱해서 적용

# Gradient Desent를 적용하는 과정
def train(model, inputs, ouputs, learning_rate):
  with tf.GradientTape() as t:
    predict = model(inputs)
    current_loss = loss(outputs, model(inputs))
    dW = t.gradient(current_loss, model.W)
    model.W.assign_sub(leaning_rate*dW)

epochs = 10
for epoch in range(epochs):
  current_loss = loss(y, model(x))
  train(model, x, y, learning_rate = 0.01)
  print("epoch:%2d, W=%1.2f, loss=%2.5f"%(epoch, model.W, current_loss))

→ epochs 값만큼 반복 학습함

→ 학습할수록 loss가 점점 줄어듬, W값 계속 변함

Linear Regression && Logistic Regression
머신러닝에서 제일 기초가 되는 과정이고 , 학습한 과정이 딥러닝 모델 학습하는 과정이랑 동일하고 좀더 복잡해지는 차이밖에 없음
꼭 잘 이해하고 넘어가야함 !!

머신러닝 프로세스

과적합(Overfitting)

• 훈련 데이터를 과하게 학습한 상태
• 훈련 데이터에서의 정확도는 매우 높지만, 실제 서비스에서의 데이터에 대해서는 정확도가 좋지 않은 현상

과소적합(Underfitting)

• 테스트 데이터의 성능이 올라갈 여지가 있음에도 훈련을 덜 한 상태
• 대표적으로 Word2Vec

지도학습(Supervised Learning)

• 데이터에 레이블이 있는 경우 → 데이터와 정답을 함께 넣어서 학습
• 대표적으로 분류 문제가 있음

비지도학습(Unsupervised Learning)

• 레이블 없이 주어진 데이터 안에서 학습
• Word2Vec ⇒ 주변 단어는 서로 연관이 있을 것이다 라고 가정해서 주변 단어를 보고 학습

BERT 같은 최신 대규모 언어 모델들도 비지도 학습을 이용해서 1차적으로 모델을 학습하고 그 모델을 다른 Task에 적용하기 위해서 변경을 해줄 때 적은 데이터로 지도학습을 해준다.

강화학습(Reinforcement Learning)

• 행동(Action)에 대한 보상(rewards) 기반으로 학습
• 알파고 , 게임

회귀(Regression)

• 원래 상태로 돌아가는 것
• 회귀분석
  • 주어진 자료들이 특정한 경향성을 띄고 있다는 가정을 활용

• 단순 회귀 분석(Simple Regression Analysis)
  • 하나의 종속변수에 대해 독립변수가 하나인 경우
• 다중 회귀 분석(Multiple Regression Analysis)
  • 하나의 종속변수에 대해 독립변수가 둘 이상인 경우

종속변수 : 입력값이나 원인
독립변수 : 결과물이나 효과

선형회귀

단순 선형 회귀 분석(Simple Linear Regression Analysis)

• 데이터가 선형 경향을 띈다고 가정

x : 독립변수 , W : 가중치(weight) , b : 편향(bias)

• 가설에 대해서 적절한 W 와 b 를 찾아주는 문제
• 위의 식을 두고 W와 b를 찾아가는 과정

y = 실제값 , H = 가설값

비용함수(cost function or Loss function)

• 딥러닝에서도 똑같이 적용되서 잘 이해하고 넘어가자!! - 인공지능 전반적인 부분에 대해서도 이해가 잘 될것이다.
• 가설과 실제 데이터를 넣었을 때의 값의 차이

W = 2 , b = 2 로 가정,,
x = 1 대입하면 H(x) = 4 , y = 2 (차이 : 2)
x = 2 대입하면 H(x) = 6 , y = 3 (차이 : 3)

• 학습은 차이를 줄이는 방향으로 W와 b를 조정

가설과 실제 데이터의 차이 → H(x)-y 를 하면 0이 될 수 있는데 최적화된 값이라고 착각할 수 있음

해결하는 방법은?? 절대값 , 제곱

(H(x)-y)^2 제곱을 취하면, 차이가 큰 경우에 대해서 가중치가 높아지는 효과

• cost function : 차이를 제곱한 것들의 평균 → 평균 제곱 오차 (Mean Squared Error)
• 단순 선형 회귀 분석에서는 MSE가 많이 활용됨
• MAE , MSLE , MAPE , Cross-entropy 등 다양한 loss function이 존재하므로, 상황에 맞는 loss function 을 정의하는 것도 중요
  • 여기서 Cross-entropy는 조금 다른데 분류할 때 많이 쓰인다.

옵티마이저(Optimizer)

• 비용 함수를 최소화하는 W와 b를 찾기 위한 최적화 작업을 학습이라고 부름
• 학습하는 과정은 W와 b를 조정을 해가면서 최적의 값을 찾는 것
• 학습하는 함수를 옵티마이저라고 부른다.

경사 하강법 (Gradient Descent)

• 옵티마이저의 한 종류
• 임의의 W값을 정한 뒤에, cost 가 최소가 되도록 W를 조금씩 수정하는 방법
• 미분을 통한 접선에서의 기울기를 활용

• 기울기를 조금씩 옮길때 learning rate를 곱한 만큼만 옮겨준다.

학습률 (Learning Rate)

• W의 값을 변경할 때, 얼마나 크게 변경할지를 결정
• 너무 크게 정하면 발산, 너무 작게 정하면 학습 속도가 느려짐

벡터화

• 자연어가 기계가 이해할 수 있도록 숫자로 변환해주는 과정

원-핫 인코딩(One-Hot Encoding)

• 단어 집합의 크기를 벡터의 차원으로 하고, 표현하고 싶은 단어의 인덱스에 1의 값을 부여하고, 다른 인덱스에는 0을 부여하는 벡터 표현 방식
• 원-핫 인코딩 과정
  1. 각 단어에 고유한 인덱스 부여
  2. 표현하고 싶은 단어의 인덱스에 1, 아닌 단어에는 0 부여

원-핫 인코딩 실습1

from my_tokenizer import tokenize

# 사전 생성
def make_vocab(tokens):
    word2index = {}
    for voca in tokens:
        if voca not in word2index.keys():
            word2index[voca] = len(word2index)
    return word2index

# 원핫인코딩
def one_hot_encoding(word, word2index):
    one_hot_vector = [0] * (len(word2index))
    index = word2index[word]
    one_hot_vector[index] = 1
    return one_hot_vector


if __name__ == '__main__':
    document = '안녕하세요. 이번에 같이 교육받게 된 김지선이라고 합니다.'
    tokens = tokenize(document, 'lemma')
    word2index = make_vocab(tokens)
    # print(word2index)
    print('dictionary:', word2index) 
    print(one_hot_encoding('같이', word2index))

원-핫 인코딩 실습2

import nltk
from nltk.tokenize import sent_tokenize
from nltk import WordPunctTokenizer
from nltk.stem import LancasterStemmer
from nltk.stem import WordNetLemmatizer


class Tokenizer:
    def __init__(self, tokenize_type): # 클래스로 만들어서 self 가 자동으로 붙음
        self.type = tokenize_type

    def make_vocab(self, document):
        tokens = self.tokenize(document)
        word2index = {'<unk>': 0}
        for voca in tokens:
            if voca not in word2index.keys():
                word2index[voca] = len(word2index)
        self.vocab = word2index
        print('dictionary:', self.vocab)

    # types = ['stem', 'lemma', 'pos']
    def tokenize(self, document):
        words = []
        sentences = sent_tokenize(document)  # sentence tokenizing
        for sentence in sentences:
            words.extend(WordPunctTokenizer().tokenize(sentence))  # word tokenizing
        if self.type == 'stem':
            lancaster_stemmer = LancasterStemmer()
            tokenized = [lancaster_stemmer.stem(w) for w in words]  # stemming
        elif self.type == 'lemma':
            lemmatizer = WordNetLemmatizer()
            tokenized = [lemmatizer.lemmatize(w).lower() for w in words]  # lemmatizing
        elif self.type == 'pos':
            # tokenized = nltk.pos_tag(words) # pos tagging
            tokenized = [token[0] + '/' + token[1] for token in nltk.pos_tag(words)]
        else:
            raise TypeError
        return tokenized

    def one_hot_encoding(self, word):
        one_hot_vector = [0] * (len(self.vocab))
        if word not in self.vocab:
            word = "<unk>"
        index = self.vocab[word]
        one_hot_vector[index] = 1
        return one_hot_vector

    def get_vector(self, sentence):
        # return 2차원 배열
        tokens = self.tokenize(sentence)
        print('Tokenized:', tokens)
        return [self.one_hot_encoding(token) for token in tokens]


if __name__ == '__main__':
    document = 'Hi! 안녕하세요.\n 이번에 같이 교육받게 된 김지선\n이라고 합니다.'
    tokenizer = Tokenizer('lemma')
    tokenizer.make_vocab(document)
    print(tokenizer.get_vector('hi, 같이 김지선'))

전처리 이해

• 토큰화
  • 주어진 데이터를 토큰(Token)이라 불리는 단위로 나누는 작업
  • 토큰이 되는 기준은 다를 수 있음(어절, 단어, 형태소, 음절, 자소 등)
• 정제
  • 불필요한 데이터(Noise data)를 제거하는 작업
• 정규화
  • 표현 방법이 다른 단어들을 통합시켜서 같은 단어로 만들어주는 작업
• 문장 토큰화
• 문장분리
• 단어 토큰화“Hello, World!” -> “Hello”, “,”, “World”, “!”
• 구두점 분리, 단어 분리

토큰화 실습

# 문장 분리 
from nltk.tokenize import sent_tokenize 
text = "Hello, world. These are NLP tutorials." 
print(sent_tokenize(text))

import nltk from nltk import WordPunctTokenizer 
nltk.download('punkt') 
text = "Hello, world. These are NLP tutorials." 
print(WordPunctTokenizer().tokenize(text))

정제&정규화

• 불필요한 데이터를 제거하는 작업
• 표기가 다른 단어들의 통합 예시) US, USA -> USA, 어간 추출(stemming), 표제어 추출(lemmatization)
• 대소문자 통합: 문장 첫 글자 문제
• 불필요한 단어 제거 예시) 불용어(stopwords), 영어가 아닌 외국어
• 정규표현식

어간추출&표제어 추출

• 어간추출(stemming)
  • 축약형으로 변환
• 표제어추출(lemmatization)
  • 품사 정보가 보존된 형태의 기본형으로 변환

어간추출&표제어추출 실습

### 어간 추출 ###

from nltk import WordPunctTokenizer
from nltk.stem import PorterStemmer
from nltk.stem import LancasterStemmer

text = "Hello, world. These are NLP tutorials."
words = WordPunctTokenizer().tokenize(text)
print(words)
porter_stemmer = PorterStemmer()
print([porter_stemmer.stem(w) for w in words])
lancaster_stemmer = LancasterStemmer()
print([lancaster_stemmer.stem(w) for w in words])

#### 표제어 추출 ####

import nltk
from nltk import WordPunctTokenizer
from nltk.stem import WordNetLemmatizer
nltk.download('wordnet')
text = "Hello, world. These are NLP tutorials."
words = WordPunctTokenizer().tokenize(text)
lemmatizer = WordNetLemmatizer()
print(words)
print([lemmatizer.lemmatize(w) for w in words])

불용어 실습

## 불용어 확인 ##

import nltk
from nltk.corpus import stopwords

nltk.download('stopwords')
english_stopwords = stopwords.words('english')
print(len(english_stopwords))
print(english_stopwords[:10])

## 불용어 제거 ##
from nltk.corpus import stopwords
from nltk import WordPunctTokenizer

text = "Hello, world. These are NLP tutorials."
stop_words = stopwords.words('english')
stop_words.append('hello')

words = WordPunctTokenizer().tokenize(text)
words = [word.lower() for word in words]


result = []
for word in words:
    if word not in stop_words:
        result.append(word)
print(words)
print(result)

POS Tagging, Named Entity Recognition 실습

# POS tagging (part of speeck tagging)
# Named Entity Recognition

import nltk
from nltk import WordPunctTokenizer

nltk.download('averaged_perceptron_tagger')
nltk.download('words')
nltk.download('maxent_ne_chunker')

text = "Hello, world. These are NLP tutorials."

word = WordPunctTokenizer().tokenize(text)
tagged = nltk.pos_tag(word)
entities = nltk.chunk.ne_chunk(tagged)

print(word)
print(tagged)
print(entities)

토크나이저 실습

import nltk
from nltk.tokenize import sent_tokenize
from nltk import WordPunctTokenizer
from nltk.stem import LancasterStemmer
from nltk.stem import WordNetLemmatizer

types = ['stem', 'lemma', 'pos']

def tokenize(document, type):
    words = []

    sentences = sent_tokenize(document) # sentence tokenizing
    for sentence in sentences:
        words.extend(WordPunctTokenizer().tokenize(sentence)) # word tokenizeing

    # sentence tokenizing
    # word tokenizing
    # 타입에 따라서 토큰으로 분리
    if type == 'stem':
        lancaster_stemmer = LancasterStemmer()
        tokenized = ([lancaster_stemmer.stem(w) for w in words]) # stemming
    elif type == 'lemma':
        lemmatizer = WordNetLemmatizer()
        tokenized = ([lemmatizer.lemmatize(w) for w in words]) # lemmatizing
    elif type == 'pos':
        # tokenized = nltk.pos_tag(words) # pos tagging
        tokenized = [token[0]+'/'+token[1] for token in nltk.pos_tag(words)]
    else:
        raise TypeError
    return tokenized

if __name__ == '__main__':
    document = '안녕하세요. 이번에 같이 교육받게 된 김지선이라고 합니다.'
    print(tokenize(document, 'pos'))

자연어란?

• 자연어(Natural Language)는 사람과 사람이 일상 생활에서 서로 대화하는데 사용하는 언어를 뜻함

자연어 처리

• 자연어의 의미를 분석하여 컴퓨터가 처리할 수 있도록 하는 일
• 전처리를 위한 형태소 분석, 개체명 인식, 구문 분석부터 음성 인식, 내용 요약, 번역, 사용자의 감성 분석, 텍스트 분류 작업(스팸 메일 분류, 뉴스 기사 카테고리 분류), 질의 응답 시스템, 챗봇 등의 응용분야에 활용이 됨

전처리 이해

• 토큰화

  • 주어진 데이터를 토큰(Token)이라 불리는 단위로 나누는 작업
  • 토큰이 되는 기준은 다를 수 있음(어절, 단어, 형태소, 음절, 자소 등)

• 정제

  • 불필요한 데이터(Noise data)를 제거하는 작업

• 정규화

  • 표현 방법이 다른 단어들을 통합시켜서 같은 단어로 만들어주는 작업

• 문장 토큰화

  문장분리

• 단어 토큰화

  구두점 분리, 단어 분리

  “Hello, World!” -> “Hello”, “,”, “World”, “!”

Task의 종류

• Part-of-Speech 태깅
• 형태소 분석(한글)
• 개체명 인식
• 구문 분석
• 상호 참조
• 감정 분석
• 번역
• 질의 응답
• 기계 독해
• 텍스트 생성
• 텍스트 요약
• 대화 시스템(챗봇)
• 언어 모델

형태소 분석

• 형태소
  • 의미가 있는 최소 단위
  • 문법적, 관계적은 뜻을 나타내는 단어 또는 단어의 부분
• 단어를 구성하는 각 형태소를 분리하고 기본형 및 품사 정보를 추출

예시) 회사는 서울시 강남구에 위치하고 있습니다.

회사/NNP+는/JX 서울시/NNP 강남구/NNP+에/JKB 위치/NNG+하/XSV+고/EC 있/VX+습니다/EF+./SF

개체명 인식

• 개체명
  • 사람이름, 회사이름, 지명, 영화제목, 날짜, 시간 등
• 개체명 인식
  • 텍스트에서 개체명을 찾아서 태깅하는 것

예시) 회사는 서울시 강남구에 위치하고 있습니다. 회사<OG>, 서울시<LC>, 강남구<LC>

구문 분석

• 문장을 이루고 있는 구성 성분으로 분해하고, 위계 관계를 분석하여 문장의 구조를 결정하는 것

기계 독해

• 주어진 문서를 빠르게 이해하고 문서에 기반하여 질문에 대한 답을 찾아내는 기술

언어 모델(Language Model)

• 언어라는 현상을 모델링하고자 단어 시퀀스(또는 문장)에 확률을 할당하는 모델
• 언어모델이 주어지면, 확률분포를 가지고 단어의 시퀀스를 뽑을 수(sample) 있으며, 텍스트를 생성할 수 있다는 뜻으로 생성 모델이라고도 불림
• 언어 모델을 만드는 방법은 통계를 활용하는 방법과, 인공 신경망을 이용한 방법이 있음

앞에 있는 입력을 가지고 뒤에 뭐가 나올지 예측하는 것
- BERT, GPT