노션 들어가서
다운한 html 내용을 hello.html에 복사해서 넣고
확인 했더니 이렇게 flask Connection Refused 뜬다.
확인해봤더니 기동하지 않아서 . ㅠㅠ
hello.html 수정하기
<a herf ='/apply'>집 등록하기</a>
<a herf ='/list'>등록한 집 목록보기</a>
table -inline
| [FLASK 클론코딩] 1강 - 개발 환경 설정하기 & 기본적인 작동원리 (파이썬으로 웹사이트 만들기) (0) | 2021.07.08 |
|---|
구름IDE 사용법:
구름IDE - 설치가 필요없는 통합개발환경 서비스
구름IDE는 언제 어디서나 사용 가능한 클라우드 통합개발환경(Integrated Development Environment IDE)을 제공합니다. 웹브라우저만 있으면 코딩, 디버그, 컴파일, 배포 등 개발에 관련된 모든 작업을 클라
ide.goorm.io
구름 포트 바꾸기 :
보통 50번 사용한다.
지우기
구름 폴더 만들기
AttributeError: 'function' object has no attribute 'html'
오류 원인 :
해결방법:
from flask import Flask, render_template
import sys
application = Flask(__name__)
@application.route("/")
def hello():
return render_template("hello.html")
if __name__ == "__main__":
application.run(host='0.0.0.0')
참고 영상:
https://www.youtube.com/watch?v=hsfibrhGFiM&list=PLqIc89sXpwUBmr0Z282fm9JurDDYBE55r&index=2
| [FLASK 클론코딩] 2강 - 웹사이트 기본적인 디자인과 연결 (파이썬으로 웹사이트 만들기) (0) | 2021.07.09 |
|---|
위키 모델을 이용해서 한다.
pos norm ->정교화
stem ->원형으로
model.wv.similarity(word, '급하다') ->유사도가 얼마인지
문장 -> sentence tokenizer -> word tokenizer
사용자 함수 사용해서 한 번에 처리 하는 것 ->
자연어 언어 처리 프로세스를 vectorize ->형태소 (최소 단위) ->feature vector화 (컴퓨터가 숫자로 알게끔)
->개수 하는 것 countervectorizer 단점 메모리 많이 잡아서 tf-if vectorizer ->
희소행렬 방식 의미랑 문맥을 단어와 단어를 연산 가능하는 것 wordembedding 방식이 있다.
감성 분석
암인데 암이 아니라고 예측하는 것과 -> 이것이 더 중요하다.
암이 아닌데 암이라고 예측하는 것 -> 비용이 들수 있지만
그래서 두가지를 똑같이 보면 안된다.
교차검증
이유: 학습 데이터와 검증 데이터를 나누고 학습 데이터 가지고 학습 하고 나서
학습용 데이터를 학습한다. 하지만 학습데이터가 적을 경우 문제가 발생될 경우가 있어서
데이터를 5개 분류로 나눈다.
데이터를 바꿔가면서 하기 때문에 데이터 왜곡 문제를 해결할 수 있다
one-hot 인코딩은 count로
문맥 연산화 하게 해서
one -hot encoding 강아지 고양이 관계 등 ...
vector방식
back of words-> counte , tfidf
wordvector - >word_embedding(강아지와 고양이 고양이와 멍멍이 ) 좀더 정확하게 작업을 진행할 수 있도록 하는것 word to vector하면 유사도 등도 관계까지 해준다.
#정규 표현식을 이용하여 숫자를 공백으로 변경
import re
#news_df = news_df.fillna(' ') #null 없에기
news_df.document = news_df.document.apply(lambda x: re.sub(r'\d+','',x))
news_df.document[2]
텍스트 전처리 정규화 ,토큰화 필어링, stop wording
필터 백터화 : one-hot encodinng : count base이다. 그 단어에 숫자가 몇번 있는지 count기반으로 하면 의미가 없는데 count가 많아서 문제가 생길 수있다. 보완하는것이 tf-idf(penalty부여한다.)
wordembedding
한글 텍스트 처리 okt (5개에서 okt 배웠다.)
pos norm stem join(word, 품사)
nouns 명사
phrase 구조
morpus
wordembedding -> word2vec
(skip-gram 단어를 중심으로
cbow 단어의 주위를 중심으로 )
toji.model 활용해서 했다.데이터가 적어서 공감이 안나와서 데이터가 많은 위키피디아 한국어로 헀다.
위키피디아 한글은 데이터가 많아서 직접 만들수 없어서 모델을 가지고 실습했다. 토지때 보다는 공감이 가는 것이 많이 나왔다.
프로젝트에서도 말뭉치의 중요성: 이것이 되야만 서비스 등이 확대가 될 수 있다.
코사인 유사도는 특히 결과값이 [0,1]의 범위로 떨어지는 양수 공간에서 사용된다.(from 위키피디아)
모델 튜닝
1. drouputout
2. l1규제(절대값을 기준으로 ), l2규제(scale을 기준으로 하고 ) l2규제를 많이 사용한다.
3. 조기종료
openCV
NLP -> 챗봇 , 번역 ,
사람의 말을 기계가 응용할 수 있다면
텍스트 전 처리 : 텍스트 정규화 : 클랜징 , 토큰화 , 필터링(Stop words)
피처 백터화: BOW, 희소행렬, COUNT/tF-IDF
한글 텍스트 처리
감성분석
테스트 분류
토픽 군집화 : 카테고리 별로 분류
데이터를 쉽게 찾도록 카테고리 별로 한다. 정치 등 .
SCALA ->크기만 따기조
VECTOR는 방향도 고려한다.
문서가있으면 토큰화해서 문장단위로 나눈다. 그다음 단위로 나누다.그다음 컴퓨터가 알수있는 언어로 한다.
0 1 등
희소행렬 :
형태소 :의미가 통하는 최소단위를 형태소 라고 한다.
평가
결정 계수 R ^ 2
혼동 행렬
교차 검증 k - fold
hypperparameter
NLP
기계가 자연어를 이해하는 방법
기계가 이행하려면 단어별로 나누어야 한다. tokenize라고 한다. -> feature vector화 one-hot encoding으로 했다.기계는 0과 1로 구분한다.
사전 작업을 먼저 해준다.
단어를 바꾸기 위해서는 reference가 필요하다. 사전
데이터를 형태소로 나누다.
cat을 0 1 로 말뭉치 사전 -> 사전 가이드
단어를 사전을 사용하여 매핑하고 이를 백터로 변환
- 백터화를 시켜 숫자로 표현하면 분류나 회귀 등의 다양한 분석이 가능
이미지 영상 딥러닝이 훨씬 더 놀라운 performance를 나온다. 머신러닝 보다.
자연어 관련 용어
Corpus(말뭉치 ) : 텍스트(문서)의 집합
Token(토큰): 단어처럼 의미르 가지는 요소
Morphemes(형태소) : 의미를 가지는 언어에서 최소 단위
형태소는 언어학에서 일정한 의미가 있는 가장 작은 말의 단위로 발화 체 내에서 따로 떼어낼 쑤 있는 것을 의미 ,. 즉, 더 분석하면 뜻이 없어지는 말의 단위.
Post(품사) : ex) Nouns, Verbs
Stopword(불용어): 필요없는 것을 제거 조사 , 접미사와 같이 자주 나타나지만 실제 의미에 기여하지 못하는 단어들
Semming(어간 추출) : 어간만 추출하는 것을 의미(running ,runs, run->run) -> 되다.
Lemmatization(음소표기법): 앞뒤 문맥을 보고 단어를 식별하는 것
vector가 하는 종류
NlP - 텍스트 벡터화
one-hot encoding(Spare representation) 필요없는 메모리를 많이 먹는다.
단어를 백터로 바꾸는 가장 단순한 방법은 단어에 번호를 매기고 , 그 번호에 해당하는 요소만 1이고 나머지는 0을 갖는 백터로 변경
N개의 단어가 있다면 각 단어는 한 개의 요소만 1인 N차원 백터로 표현
단점은 백터 표현에 단어와 단어 간의 관계가 전혀 드러나지 않는다는 점
문맥상이 다르다는 점은 전혀 반영이 안된다.
Word Embedding(Dense representaion , distributed representation)
백터간의 덧셈 뺏샘이 해당하는 단어 간의 의미의 합과 의미의 차로 반영
자연어 처리의 경우 대상은 텍스트이고 , 이 텍스트의 속성을 표현해 놓은 것이 데이터
각각의 속성을 독립적인 차원으로 표현하지 않고 우리가 정한 개수의 차원으로 대상을 대응 시켜서 표현
Dense Representation의 장점 -> 차원을 줄일 수 있다. word와 문맥
적은 차원으로 대상을 표현 ,차원이 높으면 저주 (curse of dimensionality)라는 문제 발생
더큰 일반화 능력 (generalization power)
predictive method란 지도학습을 통하여 맥락으로 단어를 예측하거나 단어로 맥락을 예측
알고리즘
맥락으로 단어를 예측하는 CBOW()
단어로 맥락을 하는 SKIP
자연어 처리 PYTHON 라이브러리
1.NLTK -nlp의 거의 모든 영역을 처리한다.
2.KoNLPy
-우리나라 한글에 특화된 자연어 처리 라이브러리:
-단어 품사 별 분류 : hannanu, kkma, okt, komoran , mecab
3.Genism
-문서 사이의 유사도를 계산 , 텍스트 분석을 돕는 라이브러리 (wORD2Vec제공)
-Word Embedding: word2Vec
4.spacy
5.scikit-learn
conda install jupyter notebook
형태소 : 의미를 가지는 최소 단위'
feature vector화 해서 컴퓨터가 처리 할 수 있게 한다
#### 텍스트 전처리 - 텍스트 정규화
- 클렌징 : 분석에 방해되는 불필요한 문자, 기호를 사전에 제거. HTML, XML 태그나 특정 기호
- 토큰화 : 문서에서 문장을 분리하는 문장 토큰화와 문장에서 단어를 토큰으로 분리하는 단어 토큰화
- 필터링/스톱워드 제거/철자 수정 : 분석에 큰 의미가 없는 단어를 제거
- Stemming, Lemmatization : 문법적 또는 의미적으로 변화하는 단어의 원형을 찾음
- Stemming은 원형 단어로 변환 시 일반적인 방법을 적용하거나 더 단순화된 방법을 적용
- Lemmatization이 Stemming 보다 정교하며 의미론적인 기반에서 단어의 원형을 찾음
피처 벡터화 : One-hot encoding
Okt 에서 제공되는 함수
CNN DNN 코드
DNN앞에 CONVELUTION LAYER과 ㅡMAXIM
CNN(Convolutional NN) 구조
• Convolution filter와 pooling을 반복.
• 이후 일반 DNN에 적용.
Convolution Filter
Convolution Filter - Stride :
필터 적용 시의 이동 칸 수.
보통은 1.
몇칸 이동한다는 것을 stride라고 한다.
Convolution Filter - Padding
필터 특성상 이미지가 작아지는 것을 방지하기 위해 원 이미지를 키우는 것.
Max Pooling
특징 추출과 분류
• convolution 필터와 pooling이 반복하여 feature 추출.
• 이후 일반 DNN로 분류.
dnn에 여줄 때는 flattern 해준다.
기존 dnn에 convolution 하고 max pooling 있는 것인 cnn이다.
vgg16구조
성능이 좋은 구조인지는 설명 못하지만 여러개 컴퓨터로 해서 한다.
우승 했던 모델을 가져와서 변형해서 한다.
함수가 성능을 잘 나와서 하지만 설명은 못한다.
# ADDED START
from tensorflow.keras.preprocessing.image import ImageDataGenerator
datagen = ImageDataGenerator(
rotation_range=10, # 0 ~ 180 회전하는 범위가 0 ~ 180 최대 180 까지 보낼 수 있다.
width_shift_range=0.1, # 좌우
height_shift_range=0.1, # 위아래
fill_mode='nearest', # 이동 시키고 나면 없는 부분이 생겨서 잴 가까운 값을 채워준다.
horizontal_flip=True, #좌우 반전
vertical_flip=False # 세로
)
# ADDED END
요즘에는 데이트를 실시간으로 만들어서 한다
model.fit_generator(datagen.flow(X_train, y_train, batch_size=128), epochs=5)
Conv2D ->가로 세로 있는것
cnn에서 conv2d가 -> Conv1D 1차원으로 바뀌였다.
cnn은 다 사용가능하다.
옆으로 쭉 있는 것
분류(Classification)
google colab github 파일 가져오기
데이터 로딩하고 전처리 , 결측치(판다스) , outlier 데이터 이상하게 되여있는것 numpy에 담은 다음 입력 ,출력
학습을 돌리면
보통 오류가 나는 부분은 shape로 안했고 , string을 숫자로 못 바뛌거나 outlier는 학습이 안된것
rnn는 입력과 출력이 동일한다.
• 상태를 가지고 있고, 다음 연산때 그 상태가 입력으로 사용된다.
출력된 값을 일력에 하나 저장하고 한다.
#Bidirectional
Bidirectional 양방향으로 하는 것 이다.
일반적인 것을 사용하는 것이 아니라 안에는 LSTM을 사용한다 .
LSTM(Long Short Term Memory)
• RNN의 단점을 보완한 모델
결과적으로 보면 입력과 출력이 있고
입력과 출력을 주면 크게 버서 나지않는다.
학습하는 시간이 거의 차이 나지 않다
rnn은 하나의 데이터가 있으면 하나의 워드이다.
sequencial과 같이 여준다.
cnn에 비해서 rnn는 최소 10배 이상 학습이 된다.
text는 만들 떄 embedding 이라는 방법을 하나 더 사용한다.
Word2Vec
이미지 분할
segmentation 픽셀 단위의 폐야 아니야 아니면 배경이야 이런것
segmentation 은 보통 여러개 한다. 색갈 별로 한다.
이미지 분할이란
본 글을 이해하기 위해서는 이미지 분할(image semantic segmentation)의 개념을 우선 알아둘 필요가 있습니다. 이미지 분할은 이미지를 구성하는 개별 픽셀 분류를 목표로 합니다. 현재 보고 있는 픽셀에 해당하는 클래스(라벨) 값을 표기하는 방식으로 예측 결과물을 생성하죠. [그림 2]의 첫 번째 이미지의 풀(grass)과 소(cow)를 구분한다고 해봅시다. 소에 해당하는 픽셀 영역에는 ‘1’을, 그 외 잔디 영역에는 ‘0’을 표기합니다. 그 후 기계는 1이 표시된 곳에 파란색 마스크(mask) 씌우고, 0이 표시된 곳에 초록색 마스크를 씌워 이미지에서 소와 잔디를 명확하게 구분합니다.
segmentation은 픽셀 다위의 분류 이다.
| 딥러닝-2 (0) | 2020.11.26 |
|---|---|
| 딥러닝-1 (0) | 2020.11.23 |
학습 추가 진행
train_data, test_Data로 나누어서 하기
model.fit()의 batch_size
batch_size는 GPU와 관련된 옵션이다.
한번에 GPU에 보내는 데이터의 수이다.
batch_size가 1일 경우 1개를 보내고, 1개의 결과를 받고, 1번 웨이트를 업데이트 한다.
batch_size가 10일 경우 10개를 보내고, 10개의 결과를 한 번에 받고, 1번 웨이트를 업데이트 한다.
batch_size를 키우면, 시간은 줄어들지만 학습이 빠르게 진행되지 않는다.
batch_size를 키우면, 시간은 줄어들지만 학습이 빠르게 진행되지 않는다.
loss가 떨어지는 추세라면 조금 더 학습해도
학습의 진행 판단 여부는 loss 추세를 보고 결정
test loss 그래프 기울기가 양으로 바뀔 시 overfitting 이므로 더 학습을 진행하면 안 됨
hooking : test loss가 어느 정도 발생하는지 스스로 추세 파악, overfitting이 발생할 시 스스로 멈춤
model fit
history = model.fit(X_train, y_train, epochs=1000, verbose=1, batch_size=20, validation_data=(X_test, y_test))
# 모델 핏 안에 들어가는 옵션, 핏하면서 validation은 test_x, test_y 데이터로
# (좌측은 train data, 우측은 test data)
따로 validation 데이터를 주지 않고, test 데이터로 준 것의 일부를 validation에 사용.
validation에 사용된 데이터는 학습에 사용되지 않는다.
history = model.fit(X_train, y_train, epochs=1000, verbose=0, batch_size=20, validation_split=0.1)
epoch가 적어도 데이터 수가 많으면 학습 잘된다.
epoch 수보다 데이터 수 많은 것이 더 중요
데이터 수가 적으면 overfitting 발생 가능성 (overfitting이 빨리 오면 성능이 안 좋음 - 학습은 되나 원하는 성능을 못 얻을 것)
->> 데이터 확보의 중요성
학습 시에 데이터를 섞어 주지 않으면 특정 데이터 순서로 학습이 일어나 편향이 생길 수있다.
shuffle=True
입력이 여러 차원일 때 각 차원의 입력을 동일한 스케일로 맞추어주면, 학습이 빠르게 진행된다고 한다.
· Normalization : 전체 데이터를 0~1로 변환해준다.
· Standardization : 평균을 0, 표준편차를 1이되도록 변환해 준다.
· 반드시 해야 할 것 : noramlization, 결측치 처리, outlier 처리
· 수렴 속도 차이 발생
Normalization - 데이터 정규화 한다.
Overfitting 처리
(오버피팅 완화)
model.add(BatchNormalization())
Regression, 회귀
· 임의의 값 출력하도록.
classification, 분류
normolization을 하는게 좋다. 하지만 정확하게 하는 것이 좋다.
학습이 되며 0~1로 normalization했을 때 보다 살짝 빠르다
딥러닝 장단점
• 장점 : 대상 함수의 내부를 몰라도 된다.
• 단점 : 비싸다
많은 데이터, 많은 연산량
ML과 DL의 선택
• 기존의 방법으로 이미 풀린 문제는 ML
• 기존의 방법으로 못풀었는데 데이터가 있으면 DL
바둑, 얼굴인식, 물체인식, 음성인식, 번역
딥러닝의 큰 단점
• 입출력 데이터 쌍을 구하기 어렵다.
• 특히 출력 데이터. 레이블링 데이터(labeling data)
Cost Function 종류
• MSE(Mean Squared Error)
• CE(Cross Entropy)
• KL-Divergence
• MLE(Maximum Likelihood Estimation)
Optimizer 종류
• 오차에 대하여 w를 업데이트 시키는 알고리즘들.
• GD(Gradient Descent)
• Batch GD
• Mini-Batch GD
• SGD(Stochastic GD)
• Momentum
• AdaGrad
• AdaDelta
• Adam
• RMSprop
Overfitting 방지법 종류
• DropOut
• BN(Batch Normalization)
• Regularization
• Data Augmentation
학습율
가중치가 변경되는 정도
SoftMax
• activation function중의 하나.
• 최종 출력층에 사용되며, 여러개의 출력 노드의 합 중에 비중의 값으로 나타낸다.
Gradient Descent
• 함수가 학습될 바를 정의한 비용함수의 값이 최소로 하기 위해 가중치를 업데이트 하기 위한 알고리즘
BackPropagation 역전파
• 출력된 값과 원하는 값과의 차이를 가지고 그 전의 w 값들을 변경하는 알고리즘.
• 뒤에서부터 그 오차의 값이 전파된다는 이름.
• 실제 변경되는 값의 크기는 GD로 결정됨.
| 딥러닝-3 (0) | 2020.11.26 |
|---|---|
| 딥러닝-1 (0) | 2020.11.23 |
tensorflow 설치 및 버전 확인
pip install -q tensorflow==2.0.0-beta1
import tensorflow as tf
print(tf.__version__)
keras fashion_mnist data load
fashion_mnist = keras.datasets.fashion_mnist
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat','Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
normalization data
train_images = train_images / 255.0
test_images = test_images / 255.0
Deep Learning
DNN
CNN
RNN
GAN
분류: 사람이 분류해야 한다.
기준을 찾는 것이 목적이다.
조정 값 = 오차 * 입력값 * 학습율
비용 함수는 모델을 구성하는 가중치(w)의 함수이다.
정답을 찾아가는 방향으로 한다.
경사 하강법(Gradient Descent)
수학에서 경사를 구하는 것 이 미분이다 . 경사 하강법을 구하는 것이다.
학습이 안되는 원인 2개는
1) 코드 가 잘못되거나 잘못 작성하거나
2) 데이터가 잘 못 됬다.
모든 데이터는 모두 오차가 있다.
실제값하고 차이가 날 수 밖에 없다.
코드를 통해서 데이터 전처리 했는데 오류때문에 숫자가 틀려지고
튜닝을 해야 한다. 어떤것 하면 좋은 값이 나오는지
신경명
퍼셉트론(Perceptron)
MLP(Multi Layer Perceptron)
입력과 출력 사이에 층이 더 있다. ->hidden layer
인공지능(AI; Artificial Intelligence)
머신러닝(ML; Machine Learning)
딥러닝(DL; Deep Learning)
딥런닝하려고 하는 것은 기존의 방법으로 안풀리기 때무에
딥런닝하고 머신러닝은 서로 보완하는 방법
딥런닝 : 자연어 처리 바둑 , 비전
역전파, 경사하강법
역전파(bp, back propagation) 알고리즘
경사하강법(gd, Gradient descent) 알고리즘
가중치를 업데이트 하기 위해 사용되는 알고리즘
tensorflow, keras,pytorch
pytorch최근에는 많이 사용한다.
딥러닝의 큰 단점
• 입출력 데이터 쌍을 구하기 어렵다.
• 특히 출력 데이터. 레이블링 데이터(labeling data)
비지도 학습, 강화 학습
• 레이블링 데이터 문제를 해결하기 위한.
• 비지도 학습 : 모델 구조를 통해 레이블링 데이터 없이. GAN
• 강화 학습 : 환경과 동적으로 연동하여 레이블링 데이터를 취득.
Cost Function 종류
• MSE(Mean Squared Error)
• CE(Cross Entropy)
• KL-Divergence
• MLE(Maximum Likelihood Estimation)
Optimizer 종류
cost function 이 있으면 이동하는 것
• 오차에 대하여 w를 업데이트 시키는 알고리즘들.
• GD(Gradient Descent)
• Batch GD
• Mini-Batch GD
• SGD(Stochastic GD)
• Momentum
• AdaGrad
• AdaDelta
• Adam
• RMSprop
Overfitting 방지법 종류
• DropOut
• BN(Batch Normalization)
• Regularization L1, L2
• Data Augmentation -> 데이터의 양을 많이 늘린다.
영상은 증강 시키는데 자연어 등 처리는 증가 시키는 것이 어렵다.
학습율
• 가중치가 변경되는 정도
활성화 함수 종류
SoftMax 최대 1 최소 0으로 하고 싶다. 합쳐서 1이다.
relu 기본인데
다른 것 사용하면 학습이 늦어진다. 뭐 사용해도 관계없지만 실습시간의 문제가 있다.
컴파일 : 모델 optimizer + loss
model.fit(X_train, y_train, epochs=1000, verbose=0, batch_size=20)
verbose = 0 직접 결과만 나온다.
verbose = 1 인 경우는 학습 과정이 나온다.
노드 개수와 레이어 개수는 optimizer , activation -> hypper parameter
architecture이 결정한다.
결론은 가이드가 없다.
그전에 grid search도 있었다.
그리드로 하는 것이다. 이것으로 해도 잘 안된다.
그래서 가이드가 없다.
값이 다른 것은 시작의 weigh가 다르다.
시작을 하면 메모리에서 값을 정한다. 데이터 초기화 하지 않아서
초기화 값이 다 달라서
seed는 데이터 섞을 때 seed
노드를 쭐이는 방향으로 한다.
| 딥러닝-3 (0) | 2020.11.26 |
|---|---|
| 딥러닝-2 (0) | 2020.11.26 |
keras 모델 학습
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras import optimizers
np.random.seed(1234) # 실행핛 때마다 같은 결과를 출력하기 위해 설정하는 부분
# 학습 데이터
x_train = [1, 2, 3, 4]
y_train = [2, 4, 6, 8]
#학습 모델 생성
model = Sequential()
model.add(Dense(1, input_dim=1)) #출력 층을 만든다.
# 출력 node 1개 입력 node 1개
#1개의 층을 받아서 1개 출력한다.
#모델 학습 방법 설정
#model.compile(loss ='mse',optimizer='adam' , metrics=['accuracy'])
model.compile(loss ='mse',optimizer= optimizers.Adam(learning_rate=0.001), metrics=['accuracy'])
# learning_rate 크면 발산 작으면 확률이 떨어진다.
#오차가 줄어들면 정확도가 증가된다.
#loss post 손실
#mse 평균제급곤오류
#optimizer: 경사 하강법 사용하는뎅 adam으로 사용
#adam learning rate 자동으로 설정된다.
#모델 학습
model.fit(x_train, y_train, epochs=20000) # # 20000번 학습 학습의 수가 적으면 오차가 크게 나온다.
#모델을 이용해서 예측
y_predict = model.predict(np.array([1,2,3,4]))
print(y_predict)
# 모델을 이용해서 예측
y_predict = model.predict(np.array([7,8,9,100]))
print(y_predict)
keras의 대표적인 오차함수(cost function)
오차 값에 따라 손실이 차이가 난다.
평균제곱계열 -> 예측 보통 mse잘 사용하한다.
교차엔트로피계열 분류
다중분류 softmax 사용
모델 정의
모델 정의
model = Sequential()
- keras에서 모델을 만들때는 Sequential()함수를 사용함
은닉층
model.add(Dense(30, input_dim=17, activation='relu'))
- model에 새로운 층을 추가핛때는 add()함수를 사용함
- model에 추가된 각 층은 Dense()함수를 통해서 구체적인 구조를 설정핚다.
- 출력node 30개, 입력 데이터 17개, 홗성화 함수는 relu 함수를 사용함
- 첫번째 Dense()가 입력층 + 은닉층 역핛을 핚다.
출력층
model.add(Dense(1, activation='sigmoid'))
- 출력층에서 홗성화 함수는 sigmoid함수를 사용해서 폐암홖자의 생존유무를 결정핚다. ( 1 or 0 )
모델 학습과정 설정 및 모델 학습
모델 학습과정 설정
model.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy'])
- 오차함수는 평균제곱오차(mean_squared_error) 사용
- 최적화 방법(optimizer)는 adam 사용
- metrics=[‘accuracy’]는 모델이 컴파일될 때 모델의 정확도(accuracy)를 출력
모델학습
model.fit(X, Y, epochs=30, batch_size=10)
- 학습 프로세스가 모든 샘플에 대해 핚번 실행하는 것을 1 epoch(에포크)라고 핚다.
- epochs=30 은 각 샘플을 처음 부터 끝까지(470개) 30번 반복 실행핚다는 의미
- batch_size=10 은 전체 470개의 샘플을 10개씩 끊어서 학습하라는 의미
sigmoid 2중적인 분류를 할 때 가장 적합한 함수
relu 함수
기울기 급증 할 수 있어서 relu를 사용한다.
#폐암 수술 환자의 생존을 예측하기
# 필요핚 라이브러리를 불러옴
import numpy
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
# 실행핛 때마다 같은 결과를 출력하기 위해 설정하는 부분
seed = 0
numpy.random.seed(seed)
tf.random.set_seed(seed)
# 준비된 수술 홖자 데이터를 불러옴
dataset = numpy.loadtxt("dataset/ThoraricSurgery.csv", delimiter=",")
X = dataset[:, 0:17] # 행 열
Y = dataset[:,17] # 17번 : 홖자들의 생존유무 (0 or 1)
# 모델을 설정
model = Sequential() # 모델 정의
model.add(Dense(30, input_dim=17, activation='relu')) # 은닉층 : 출력node 30개, 입력데이터 17개
#입력층 은닉층 동일하다.
#은닉층은 일정자격이 와야만 다음층에 지나간다.
#출력노드의 개수는 임의의 개수이다.
model.add(Dense(1, activation='sigmoid')) # 출력층 : 입력node 30개, 출력 node 1개
# 모델 학습과정 설정 및 모델 학습
# 젂체 데이터 470개를 10개씩 끊어서, 30번 학습함
#mean_squared_error mse 상관 없다.
model.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy'])
# 420개를 10개씩 나누어서 학습 시키라
model.fit(X, Y, epochs=30, batch_size=10) # 모델 학습
# 모델 평가 : 정확도
ac = model.evaluate(X, Y)
print(type(ac))
print(ac)
print("\n Accuracy: %.4f" % (model.evaluate(X, Y)[1]))
필요할 떄마다 은닉층 추가할 수 있다.
선형회귀(Linear Regression)
상관관계를 선(=회귀선)을 그어서 모델(=가설)로 지정하였습니다
최소 제곱법(Least-squares)
평균 제곱근 오차 (Root Mean Squared Error : RMSE) : 오차 = 실제 값 – 예측 값
마치 경사를 타고 내리온 방향으로
로스값이 최소가 되는 방향으로 학습 한다.
로스값이 작은 것은 학습이 잘 됬다.
비용함수
가설 (hypothesis)
keras의 대표적인 오차함수(cost function) yt:실제값, yo:예측값
회귀는 평균제급 오차를 재일 많이 사용한다.
#보스턴 집값 예측하기
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from sklearn.model_selection import train_test_split
import numpy as np
import pandas as pd
import tensorflow as tf
#난수 시도 설정 - 실행시 동일한 결과를 가져오기
# seed 값 설정
seed = 0
seed = np.random.seed(seed)
tf.random.set_seed(seed)
# 공백으로 분리된 데이터 파일을 읽어옴
df = pd.read_csv("dataset/housing.csv", delim_whitespace=True, header=None)
print(df.info()) # 데이터프레임의 정보를 구해옴 : 인덱스:506행, 컬럼:14열
print(df.head()) # 5개 데이터 출력
dataset = df.values
X = dataset[:,0:13]
Y = dataset[:,13]
# 젂체 데이터를 훈렦 데이터와 테스트 데이터를 분리
# test_size=0.3 : 젂체 데이터에서 테스트 데이터를 30% 사용
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.3, random_state=seed)
# 모델 정의
model = Sequential()
model.add(Dense(30, input_dim=13, activation='relu'))
model.add(Dense(6, activation='relu'))
model.add(Dense(1)) # 예측의 경우에는 출력층에 홗성화 함수가 필요 없음
# 모델학습 방식 설정
model.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy'] )
# 모델학습
model.fit(X_train, Y_train, epochs=200, batch_size=10) # 200번 학습
# 예측 값과 실제 값의 비교
# flatten() : 데이터의 배열을 1차원으로 바꿔주는 함수
Y_prediction = model.predict(X_test).flatten()
for i in range(10): # 506개의 30%(1 ~ 151)
label = Y_test[i]
prediction = Y_prediction[i]
print("실제가격: {:.3f}, 예상가격: {:.3f}".format(label, prediction))
Logistic Regression
Logistic Regression은 대표적인 분류(classification) 알고리즘 중의 하나이다.
Spam Detection : Spam(1) or Ham(0)
S자 형태의 그래프를 그려주는 함수가 시그모이드 함수(sigmoid function) 이다.
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
# 피마 인디언 당뇨병 데이터셋 로딩
# 불러올 때 각 컬럼에 핬당하는 이름을 지정
df = pd.read_csv('dataset/pima-indians-diabetes.csv',
names = ["pregnant", "plasma", "pressure", "thickness", "insulin", "BMI", "pedigree", "age", "class"])
# 처음 5개 데이터 확인
print(df.head(5))
print(df) # [768 rows x 9 columns]
# 데이터의 자료형 확인
print(df.info())
# 데이터의 통계 요약 정보 확인
print(df.describe())
# 공복혈당, 클래스 정보 출력
print(df[['plasma', 'class']])
# 그래프 설정
colormap = plt.cm.gist_heat # 그래프의 색상 설정
plt.figure(figsize=(12,12)) # 그래프의 크기 설정
# 데이터 갂의 상관관계를 heatmap 그래프 출력
# vmax의 값을 0.5로 지정핬 0.5에 가까울 수록 밝은 색으로 표시
sns.heatmap(df.corr(), linewidths=0.1, vmax=0.5, cmap=colormap, linecolor='white', annot=True)
plt.show()
# 히스토그램
grid = sns.FacetGrid(df, col='class')
grid.map(plt.hist, 'plasma', bins=10) # plasma : 공복 혈당
plt.show()
# 딥러닝을 구동하는 데 필요핚 케라스 함수 불러오기
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
import numpy
import tensorflow as tf
# 실행핛 때마다 같은 결과를 출력하기 위핬 설정
numpy.random.seed(3)
tf.random.set_seed(3)
# 데이터를 불러오기
#dataset = numpy.loadtxt("/dataset/pima-indians-diabetes.csv", delimiter=",")
#numpy 2차원 배열 형태
#X = dataset[:,0:8] # 8개의 컬럼 정보
#Y = dataset[:,8] # class : 0 or 1
dataset = pd.read_csv("/dataset/pima-indians-diabetes.csv", delimiter=",")
X = dataset.iloc[:,0:8] # 8개의 컬럼 정보
Y = dataset.iloc[:,8] # class : 0 or 1
# 모델 설정
model = Sequential()
model.add(Dense(12, input_dim=8, activation='relu')) # 출력 노드:12개, 입력노드:8개
model.add(Dense(8, activation='relu')) # 은닉층
#반드시 은닉층을 만드는 것은 아니다.
# 은닉층은 하나 보다 2개가 높다
model.add(Dense(1, activation='sigmoid')) # 출력층 이중붂류(sigmoid)
# 모델 컴파일
model.compile(loss='binary_crossentropy', # 오차함수 : 이중붂류 - binary_crossentropy
optimizer='adam',
metrics=['accuracy'])
# 모델 실행 - 학습
# 몇번 학습 할 지는 epochs
# 200번을 데이터 500개를 나누어서 할 때는 batch_size로 한다.
model.fit(X, Y, epochs=200, batch_size=10) # 200번 학습
# 결과 출력
print("\n Accuracy: %.4f" % (model.evaluate(X, Y)[1]))
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
import pandas as pd
import numpy
import tensorflow as tf
import matplotlib.pyplot as plt
# seed 값 설정 : 실행핛때 마다 같은 결과가 나오도록 핬주는 역핛
seed = 0
numpy.random.seed(seed)
tf.random.set_seed(seed)
# 데이터 로딩
df = pd.read_csv('dataset/wine.csv', header=None)
print(df) # [6497 rows x 13 columns]
dataset = df.values # 데이터프레임의 데이터만 불러와서 dataset을 만듬
X = dataset[:,0:12] # 와인의 특징 12개의 열 추출 (0~11)
Y = dataset[:,12] # 12번째 열 (1:레드와인, 0:화이트와인)
# 모델 설정
model = Sequential()
model.add(Dense(30, input_dim=12, activation='relu')) # 입력층 : 출력 node 30개, 입력 node 12개
model.add(Dense(12, activation='relu')) # 은닉층 : 출력 node 12개
model.add(Dense(8, activation='relu')) # 은닉층 : 출력 node 8개
model.add(Dense(1, activation='sigmoid')) # 출력층 : 출력 node 1개 (이중붂류)
#모델 컴파일
model.compile(loss='binary_crossentropy', # 오차함수 : 이중붂류 - binary_crossentropy
optimizer='adam',
metrics=['accuracy']) # accuracy 다르게 이름 사용해도 된다.
# 모델 실행
model.fit(X, Y, epochs=200, batch_size=200) # 학습횟수(epochs) : 200회
# 결과 출력
print("\n Accuracy: %.4f" % (model.evaluate(X, Y)[1]))
Softmax Function : 다중적인 분류(Multinomial Classification)
#입력층과 출력층은 정해져 있다.
#입력 4가지 출력 3가지
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from sklearn.preprocessing import LabelEncoder
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import numpy
import tensorflow as tf
# seed 값 설정
seed = 0
numpy.random.seed(seed)
tf.random.set_seed(seed)
# 데이터 읽어오기
df = pd.read_csv('dataset/iris.csv', names = ["sepal_length", "sepal_width", "petal_length", "petal_width", "species"])
print(df)
# 그래프 출력
sns.pairplot(df, hue='species')
plt.show()
# 데이터 붂류
dataset = df.values # 데이터프레임의 데이터만 불러와서 dataset을 만듬
x = dataset[:,0:4].astype(float) # dataset의 데이터를 float형으로 변홖함
y_obj = dataset[:,4] # y_obj : species 클래스값 저장함
print(y_obj) # y_obj = ['Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa'
# 문자열을 숫자로 변홖
# array(['Iris-setosa','Iris-versicolor','Iris-virginica'])가 array([0,1,2])으로 바뀜
e = LabelEncoder() # 문자열을 숫자로 변홖핬주는 함수
e.fit(y_obj)
y = e.transform(y_obj)
print(y) # [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
# 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 ...
# 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 ]
# 원-핪 인코딩(one-hot-encoding)
y_encoded = tf.keras.utils.to_categorical(y)
print(y_encoded) # [[1. 0. 0.] [1. 0. 0.] [1. 0. 0.] ...
# [[0. 1. 0.] [0. 1. 0.] [0. 1. 0.] ...
# [[0. 0. 1.] [0. 0. 1.] [0. 0. 1.] ]
# 모델의 설정
model = Sequential()
model.add(Dense(16, input_dim=4, activation='relu'))
model.add(Dense(3, activation='softmax')) # 3가지로 붂류
# 모델 컴파일
model.compile(loss='categorical_crossentropy', # 오차함수 : 다중붂류 - categorical_crossentropy
optimizer='adam',
metrics=['accuracy'])
# 모델 실행
model.fit(x, y_encoded, epochs=50, batch_size=1) # 학습횟수(epochs) : 50회
# 결과 출력
print("\n Accuracy: %.4f" % (model.evaluate(x, y_encoded)[1]))
from tensorflow.keras.datasets import mnist
import matplotlib.pyplot as plt
# MNIST 데이터(학습데이터, 테스트데이터) 불러오기
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# 학습데이터의 크기 : 60000개
print(x_train.shape) # (60000, 28, 28)
print(y_train.shape) # (60000,)
# 테스트 데이터 크기 : 10000개
print(x_test.shape) # (10000, 28, 28)
print(y_test.shape) # (10000,)
print('학습셋 이미지 수: %d 개' %(x_train.shape[0])) # 학습셋 이미지 수: 60000 개
print('테스트셋 이미지 수: %d 개' %(x_test.shape[0])) # 테스트셋 이미지 수: 10000 개
# 첫번째 이미지 출력 : 배열로 출력 ( 0 ~ 255 )
print(x_train[0])
# 그래픽으로 첫번째 이미지 출력
plt.imshow(x_train[0])
# plt.imshow(x_train[0], cmap='Greys') # 흑백 이미지
plt.show()
# 첫번째 이미지 라벨 출력 : 5
print(y_train[0])
# MNIST 데이터 중 10장만 표시
for i in range(10):
plt.subplot(2, 5, i+1) # 2행 5열로 이미지 배치
plt.title("M_%d" % i)
plt.axis("off")
plt.imshow(x_train[i], cmap=None)
# plt.imshow(x_train[i], cmap='Greys')
plt.show()
from tensorflow.keras.models import load_model
model = load_model('mnist_mlp_model.h5')
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Activation
import numpy as np
import tensorflow as tf
# seed 값 설정
seed = 0
np.random.seed(seed)
tf.random.set_seed(seed)
# 1. 데이터셋 생성하기
# 훈련셋과 시험셋 불러오기
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# 데이터셋 젂처리 : 이미지 정규화 ( 0 ~ 255 --> 0 ~ 1 )
# 60000 데이터 784 28 * 28
x_train = x_train.reshape(60000, 784).astype('float32') / 255.0
x_test = x_test.reshape(10000, 784).astype('float32') / 255.0
# 원핫인코딩 (one-hot encoding) 처리
y_train = tf.keras.utils.to_categorical(y_train)
y_test = tf.keras.utils.to_categorical(y_test)
print(y_train[0]) # MNIST의 첫번째 이미지(5)의 원핫인코딩 : [0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]
# 2. 모델 구성하기
model = Sequential()
model.add(Dense(64, input_dim=28*28, activation='relu')) # 입력 28*28 , 출력 node 64개
model.add(Dense(10, activation='softmax')) # 입력 node 64개, 출력 node 10개 (0 ~ 9)
#출력은 10 이기 때문에 10
# 3. 모델 학습과정 설정하기
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
# 4. 모델 학습시키기
hist = model.fit(x_train, y_train, epochs=5, batch_size=32)
# 5. 학습과정 살펴보기
# 5번 학습후 loss와 accuracy 결과 출력
print('# train loss and accuracy #')
print(hist.history['loss'])
print(hist.history['accuracy'])
# 6. 모델 평가하기
loss_and_metrics = model.evaluate(x_test, y_test, batch_size=32)
print('# evaluation loss and metrics #')
print(loss_and_metrics)
# 6. 모델 저장하기
from tensorflow.keras.models import load_model
model.summary()
model.save("mnist_mlp_model.h5") # 학습된 모델 저장하기
import numpy as np
import cv2
from tensorflow.keras.models import load_model
print("Loading model...")
model = load_model('mnist_mlp_model.h5') # 학습된 모델 불러오기
#학습된 모델이기 때문에 따로 학습을 할 필요없다.
print("Loading complete!")
onDown = False
xprev, yprev = None, None
def onmouse(event, x, y, flags, params): # 마우스 이벤트 처리 함수
global onDown, img, xprev, yprev
if event == cv2.EVENT_LBUTTONDOWN: # 왼쪽 마우스 눌렀을 경우
# print("DOWN : {0}, {1}".format(x,y))
onDown = True
elif event == cv2.EVENT_MOUSEMOVE: # 마우스 움직일 경우
if onDown == True:
# print("MOVE : {0}, {1}".format(x,y))
cv2.line(img, (xprev,yprev), (x,y), (255,255,255), 20)
elif event == cv2.EVENT_LBUTTONUP: # 왼쪽 마우스 눌렀다가 놓았을 경우
# print("UP : {0}, {1}".format(x,y))
onDown = False
xprev, yprev = x,y
cv2.namedWindow("image") # 윈도우 창의 title
cv2.setMouseCallback("image", onmouse) # onmouse() 함수 호출
width, height = 280, 280
img = np.zeros((280,280,3), np.uint8)
while True:
cv2.imshow("image", img)
key = cv2.waitKey(1)
if key == ord('r'): # r 버튼 클릭 : clear
img = np.zeros((280,280,3), np.uint8)
print("Clear.")
if key == ord('s'): # s 버튼 클릭 : 예측값 출력
x_resize = cv2.resize(img, dsize=(28,28), interpolation=cv2.INTER_AREA)
x_gray = cv2.cvtColor(x_resize, cv2.COLOR_BGR2GRAY)
x = x_gray.reshape(1, 28*28)
y = model.predict_classes(x) # 모델에서 예측값 구해오기
print(y) # 예측값 출력
if key == ord('q'): # q 버튼 클릭 : 종료
print("Good bye")
break
cv2.destroyAllWindows() # 윈도우 종료
#예측된 콘솔창에 추가 해준다.
pip install opencv-python
합성곱 신경망 (CNN : Convolutional Neural Network)
특징 추출(Feature Extraction)
- 컨볼루션 레이어(Convolution Layer) + 풀링 레이어(Pooling Layer)를 반복하여 구성 된다.
분류기(Classifier)
- Dense Layer + Dropout Layer(과적합을 막기 위핚 레이어) + Dense Layer(마지막 Dense 레이어 후에는
Dropout하지 않습니다.)
컨볼루션 레이어 (Convolution Layer, 합성곱 층)
필터로 이미지의 특징을 추출해주는 컨볼루션(Convolution) 레이어
필터(Filter)
맥스 풀링 레이어(Max Pooling Layer)
Flatten 2차원을 1차원으로 바꾼다.
드롭아웃(Dropout) ->과적합을 피하는 방법중에 하나이다. 특정 네트워크를 꺼버리는 기법이다.
tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
# seed 값 설정
seed = 0
np.random.seed(seed)
tf.random.set_seed(seed)
# 1. 데이터셋 생성하기
# 훈련셋과 시험셋 불러오기
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# 데이터셋 전처리 : 이미지 정규화 ( 0 ~ 255 --> 0 ~ 1 )
x_train = x_train.reshape(x_train.shape[0], 28, 28, 1).astype('float32') / 255
x_test = x_test.reshape(x_test.shape[0], 28, 28, 1).astype('float32') / 255
# 원핪인코딩 (one-hot encoding) 처리
y_train = tf.keras.utils.to_categorical(y_train)
y_test = tf.keras.utils.to_categorical(y_test)
# 2. 모델 구성하기
model = Sequential()
# 컨볼루션 레이어
model.add(Conv2D(32, kernel_size=(3, 3), input_shape=(28, 28, 1), activation='relu'))
model.add(Conv2D(64, (3, 3), activation='relu'))
# 맥스 풀링 레이어
model.add(MaxPooling2D(pool_size=2))
# 전결합층
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))
# 3. 모델 학습과정 설정하기
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
# 4. 모델의 실행
history = model.fit(x_train, y_train, validation_data=(x_test, y_test), epochs=30, batch_size=200, verbose=1)
# 5. 테스트 정확도 출력
print("\n Test Accuracy: %.4f" % (model.evaluate(x_test, y_test)[1]))
# 테스트 셋의 오차
y_vloss = history.history['val_loss']
# 학습셋의 오차
y_loss = history.history['loss']
# 6. 그래프로 출력
x_len = np.arange(len(y_loss))
plt.plot(x_len, y_vloss, marker='.', c="red", label='Testset_loss')
plt.plot(x_len, y_loss, marker='.', c="blue", label='Trainset_loss')
# 그래프에 그리드를 주고 레이블을 출력
plt.legend(loc='upper right')
plt.grid()
plt.xlabel('epoch')
plt.ylabel('loss')
plt.show()