개발새발코딩

파파고 API 구현 코드

HooSL — Wed, 30 Mar 2022 15:51:10 +0900

https://developers.naver.com/docs/papago/papago-nmt-overview.md

Papago 번역 - Papago API

Papago 번역 개요 Papago 번역 개요 Papago 번역은 Papago의 인공 신경망 기반 기계 번역 기술(NMT, Neural Machine Translation)로 텍스트를 번역한 결과를 반환하는 RESTful API입니다. Papago 번역으로 번역할 수 있

developers.naver.com

첫번째 코드

import requests

URL = "https://openapi.naver.com/v1/papago/n2mt"

text = '파이썬 너무 어려워요'

header = {'Content-Type':'application/x-www-form-urlencoded; charset=UTF-8',
            'X-Naver-Client-Id':'개발자센터에서 발급받은 Client ID 값',
            'X-Naver-Client-Secret':'개발자센터에서 발급받은 Client Secret 값'}

data = {'source':'ko','target':'en','text':text} #source : 번역할 언어 , target : 번역된 언어

responce = requests.post(URL,data=data,headers=header)

print(responce.json())

print()

print(responce.json()['message']['result']['translatedText'])

두번째 코드

import os
import sys
import urllib.request
import json
client_id = "개발자센터에서 발급받은 Client ID 값"
client_secret = "개발자센터에서 발급받은 Client Secret 값" 

encText = urllib.parse.quote("반갑습니다") #번역할 문장

data = "source=ko&target=en&text=" + encText #source : 번역할 언어 , target : 번역된 언어
url = "https://openapi.naver.com/v1/papago/n2mt"
request = urllib.request.Request(url)
request.add_header("X-Naver-Client-Id",client_id)
request.add_header("X-Naver-Client-Secret",client_secret)
response = urllib.request.urlopen(request, data=data.encode("utf-8"))
rescode = response.getcode()
if(rescode==200):
    response_body = response.read()
    print(response_body.decode('utf-8'))
    print()
    json_dict = json.loads(response_body.decode('utf-8'))
    print(json_dict['message']['result']['translatedText'])
else:
    print("Error Code:" + rescode)

첫번째 코드가 더 간결합니다.

CNN 이용하여 정교한 이미지 분류 (강아지, 고양이 분류)

HooSL — Tue, 29 Mar 2022 13:17:14 +0900

/tmp 컬럼에, 2000개의 이미지를 다운로드 받아서 저장합니다.

!wget --no-check-certificate \
  https://storage.googleapis.com/mledu-datasets/cats_and_dogs_filtered.zip \
  -O /tmp/cats_and_dogs_filtered.zip

압축풀기

import tensorflow as tf
import os
#압축풀기
import zipfile
filename = '/tmp/cats_and_dogs_filtered.zip'
zip_ref = zipfile.ZipFile(filename,mode='r')
zip_ref.extractall('/tmp/cats_and_dogs_filtered')
zip_ref.close()

데이터 억세스할 경로를 만든다.

train_cats_dir = '/tmp/cats_and_dogs_filtered/cats_and_dogs_filtered/train/cats'
train_dogs_dir = '/tmp/cats_and_dogs_filtered/cats_and_dogs_filtered/train/dogs'

validation_cats_dir = '/tmp/cats_and_dogs_filtered/cats_and_dogs_filtered/validation/cats'
validation_dogs_dir = '/tmp/cats_and_dogs_filtered/cats_and_dogs_filtered/validation/dogs'

파일 확인해보기

train_cats_names = os.listdir(train_cats_dir)
train_dogs_names = os.listdir(train_dogs_dir)

validation_cats_names = os.listdir(validation_cats_dir)
validation_dogs_names = os.listdir(validation_dogs_dir)

print(train_cats_names)
print(train_dogs_names)
print(validation_cats_names)
print(validation_dogs_names)

트레이닝 이미지와 밸리데이션 이미지를 각각 몇개씩인지 확인해 본다.

len(train_cats_names)
len(train_dogs_names)
len(validation_cats_names)
len(validation_dogs_names)

강아지와 고양이 8개씩 화면에 이미지를 표시해봅니다.

%matplotlib inline

import matplotlib.image as mpimg
import matplotlib.pyplot as plt

# Parameters for our graph; we'll output images in a 4x4 configuration
nrows = 4
ncols = 4

pic_index = 0 # Index for iterating over images

# Set up matplotlib fig, and size it to fit 4x4 pics
fig = plt.gcf()
fig.set_size_inches(ncols*4, nrows*4)

pic_index+=8

next_cat_pix = [os.path.join(train_cats_dir, fname) 
                for fname in train_cats_names[ pic_index-8:pic_index] 
               ]

next_dog_pix = [os.path.join(train_dogs_dir, fname) 
                for fname in train_dogs_names[ pic_index-8:pic_index]
               ]

for i, img_path in enumerate(next_cat_pix+next_dog_pix):
  # Set up subplot; subplot indices start at 1
  sp = plt.subplot(nrows, ncols, i + 1)
  sp.axis('Off') # Don't show axes (or gridlines)

  img = mpimg.imread(img_path)
  plt.imshow(img)

plt.show()

이미지의 사이즈를 150x150, 칼라(rgb) 로 처리해서 모델링하는 함수를 만듭니다.

#라이브러리 import
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D,MaxPooling2D,Flatten,Dense

#모델링 함수
def build_model():
  model = Sequential()
  model.add(Conv2D(filters=16,kernel_size=(3,3),activation='relu',input_shape=(150,150,3)))
  model.add(MaxPooling2D(pool_size=(2,2),strides=2))

  model.add(Conv2D(filters=32,kernel_size=(3,3),activation='relu'))
  model.add(MaxPooling2D(pool_size=(2,2),strides=2))

  model.add(Conv2D(filters=64,kernel_size=(3,3),activation='relu'))
  model.add(MaxPooling2D(pool_size=(2,2),strides=2))

  model.add(Flatten())

  model.add(Dense(units=512,activation='relu'))
  model.add(Dense(units=1,activation='sigmoid'))

  return model
  
  #모델 생성
  model = build_model()
  
  #모델 요약
  model.summary()

RMSprop 으로 컴파일합니다.

from tensorflow.keras.optimizers import RMSprop,Adam,Adagrad,Adadelta #RMSprop 보폭

model.compile(loss='binary_crossentropy',
              optimizer=RMSprop(learning_rate=0.001),
              metrics=['accuracy'])

Data Preprocessing Image Data Generator 사용하기

from tensorflow.keras.preprocessing.image import ImageDataGenerator

train_datagen = ImageDataGenerator(rescale=1/255.0)
validation_datagen = ImageDataGenerator(rescale=1/255.0)

train_generator = train_datagen.flow_from_directory('/tmp/cats_and_dogs_filtered/cats_and_dogs_filtered/train',target_size=(150,150),class_mode='binary')
validation_generator = validation_datagen.flow_from_directory('/tmp/cats_and_dogs_filtered/cats_and_dogs_filtered/validation',target_size=(150,150),class_mode='binary')

모델 훈련 15epochs

epoch_history = model.fit(train_generator,epochs=15,steps_per_epoch=8,validation_data=validation_generator)

모델 평가

model.evaluate(validation_generator)

실제 다른 사진을 넣고 비교해보기

import numpy as np

from google.colab import files
from keras.preprocessing import image

uploaded=files.upload()

for fn in uploaded.keys():
 
  # predicting images
  path='/content/' + fn
  img=image.load_img(path, target_size=(150, 150))
  
  x=image.img_to_array(img)
  x=np.expand_dims(x, axis=0)
  images = np.vstack([x])
  
  classes = model.predict(images, batch_size=10)
  
  print(classes[0])
  
  if classes[0]>0.5:
    print(fn + " is a dog")
    
  else:
    print(fn + " is a cat")

Image Data Generator 사람과 말 분류

HooSL — Tue, 29 Mar 2022 12:57:40 +0900

이미지 파일 다운로드

말, 사람을 분류하기 위한 사진 파일 다운로드하기

!wget --no-check-certificate \
    https://storage.googleapis.com/laurencemoroney-blog.appspot.com/horse-or-human.zip \
    -O /tmp/horse-or-human.zip

확인용

! wget --no-check-certificate \
    https://storage.googleapis.com/laurencemoroney-blog.appspot.com/validation-horse-or-human.zip \
    -O /tmp/validation-horse-or-human.zip

압축풀기

import os
import zipfile

filename = '/tmp/horse-or-human.zip'
zip_ref = zipfile.ZipFile(filename,mode='r')
zip_ref.extractall('/tmp/horse-or-human')
zip_ref.close()

import zipfile
filename = '/tmp/validation-horse-or-human.zip'
zip_ref = zipfile.ZipFile(filename,mode='r')
zip_ref.extractall('/tmp/validation-horse-or-human')
zip_ref.close()

사진이 저장된 폴더 경로 만들기

train_horse_dir = '/tmp/horse-or-human/horses'
train_human_dir = '/tmp/horse-or-human/humans'

validation_horse_dir = '/tmp/validation-horse-or-human/horses'
validation_human_dir = '/tmp/validation-horse-or-human/humans'

각 폴더에 저장되어 있는 사진파일 이름들 출력하기

train_horse_names = os.listdir(train_horse_dir)
train_human_names = os.listdir(train_human_dir)

validation_horse_names = os.listdir(validation_horse_dir)
validation_human_names = os.listdir(validation_human_dir)

#잘 나오는 지 확인용
print(validation_horse_names)
print(validation_human_names)

각 디렉토리에 저장된 파일의 개수 확인

시각화로 사진 이미지 확인해 보기

%matplotlib inline

import matplotlib.pyplot as plt
import matplotlib.image as mpimg

# Parameters for our graph; we'll output images in a 4x4 configuration
nrows = 4
ncols = 4

# Index for iterating over images
pic_index = 0

말 8마리, 사람 8명씩 이미지 확인하기

# Set up matplotlib fig, and size it to fit 4x4 pics
fig = plt.gcf()
fig.set_size_inches(ncols * 4, nrows * 4)

pic_index += 8
next_horse_pix = [os.path.join(train_horse_dir, fname) 
                for fname in train_horse_names[pic_index-8:pic_index]]
next_human_pix = [os.path.join(train_human_dir, fname) 
                for fname in train_human_names[pic_index-8:pic_index]]

for i, img_path in enumerate(next_horse_pix+next_human_pix):
  # Set up subplot; subplot indices start at 1
  sp = plt.subplot(nrows, ncols, i + 1)
  sp.axis('Off') # Don't show axes (or gridlines)

  img = mpimg.imread(img_path)
  plt.imshow(img)

plt.show()

간단한 모델링 하기

사진의 결과는 2개중의 하나이기 때문에 맨 마지막 액티베이션 함수는 시그모이드를 사용합니다.

필요한 라이브러리 import

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D,MaxPooling2D,Flatten,Dense

모델링 함수

def build_model():
  model = Sequential()
  model.add(Conv2D(filters=16,kernel_size=(3,3),activation='relu',input_shape=(300,300,3)))
  model.add(MaxPooling2D(pool_size=(2,2),strides=2))

  model.add(Conv2D(filters=32,kernel_size=(3,3),activation='relu'))
  model.add(MaxPooling2D(pool_size=(2,2),strides=2))

  model.add(Conv2D(filters=64,kernel_size=(3,3),activation='relu'))
  model.add(MaxPooling2D(pool_size=(2,2),strides=2))

  model.add(Flatten())

  model.add(Dense(units=512,activation='relu'))
  model.add(Dense(units=1,activation='sigmoid'))

  return model

모델 생성, 요약

model = build_model()
model.summary()

RMSprop optimization algorithm 사용하여 컴파일

from tensorflow.keras.optimizers import RMSprop,Adam,Adagrad,Adadelta #RMSprop 보폭

model.compile(loss='binary_crossentropy',
              optimizer=RMSprop(learning_rate=0.001),
              metrics=['accuracy'])

파일로 되어있는 이미지를 학습을 위해서 넘파이로 바꿔줘야 합니다.
실제로 복잡한 작업을 해야 하는것을 텐서플로우에서 쉽게 처리할수있게 라이브러리를 제공합니다.
ImageDataGenerator

from tensorflow.keras.preprocessing.image import ImageDataGenerator

파일로 되어있는 이미지의 피쳐스케일링을 합니다 -> 255.0으로 나누는 것

train_datagen = ImageDataGenerator(rescale=1/255.0)
validation_datagen = ImageDataGenerator(rescale=1/255.0)

파일이 들어있는 디렉토리를 알려주고, 이미지 사이즈 정보도 알려주고, 분류할 정보도 알려줍니다.

target_size 파라미터는 우리가 마음대로 정해줄수있습니다.

단 모델의 input_shape과 동일해야합니다.
class_mode는, 2개 분류는 binary, 3개이상은 categorical로 설정

train_generator = train_datagen.flow_from_directory('/tmp/horse-or-human',target_size=(300,300),class_mode='binary')

train_generator는 X_train과 y_train이 들어있게 됩니다.
y_train의 값은 폴더의 이름으로 설정됩니다.
따라서 폴더의 이름을 알파벳순으로 정렬한수 0부터 차례로 숫자를 매깁니다.

validation_generator = validation_datagen.flow_from_directory('/tmp/validation-horse-or-human',target_size=(300,300),class_mode='binary')

모델 학습

전체 데이터수는 = batch_size x steps_per_epoch 와 같습니다.
1000 = 20 x 50

epoch_history = model.fit(train_generator,epochs=30,steps_per_epoch=8,validation_data=validation_generator)

모델 결과, 시각화

model.evaluate(validation_generator)

plt.plot(epoch_history.history['accuracy'])
plt.plot(epoch_history.history['val_accuracy'])
plt.title('Model Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend(['Train','Validation'])
plt.savefig('chart1.jpg')
plt.show()

import numpy as np
from google.colab import files
from tensorflow.keras.preprocessing import image

uploaded = files.upload()

for fn in uploaded.keys() :
  path = '/content/' + fn
  img = image.load_img(path, target_size=(300,300))     #target_size를 맞게 변경
  x = image.img_to_array(img)

  print(x.shape)

  x = np.expand_dims(x, axis = 0)

  print(x.shape)

  images = np.vstack( [x] )
  classes = model.predict( images, batch_size = 10 )
  
  print(classes)

  if classes[0] > 0.5 :                                #분류할 데이터의 이름을 맞게 변경하세요.
    print(fn + " is a human")
  else :
    print(fn + " is a horse")

이 코드를 실행하고 파일 선택에 사람 또는 말 사진을 넣으면 지금까지 만든 모델이 분류를 해줍니다.

Convolutional Neural Networks

HooSL — Tue, 29 Mar 2022 12:32:46 +0900

필요한 라이브러리 import

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten,Conv2D,MaxPooling2D
from tensorflow.keras.datasets import mnist
import matplotlib.pyplot as plt

(X_train,y_train),(X_test,y_test) = mnist.load_data()

이미지는 원래 컬러 이미지이므로, 1개의 이미지는 3차원 입니다.

따라서 이미지 처리를 CNN을 구성할때는, 전체 데이터셋은 4차원으로 구성해야합니다.

X_train=X_train.reshape(60000,28,28,1)
X_test=X_test.reshape(10000,28,28,1)

피처스케일링

X_train=X_train/255.0
X_test=X_test/255.0

CNN으로 모델링, 컴파일, 학습합니다.

model = Sequential()
model.add(Conv2D(filters=64,kernel_size=(3,3),activation='relu',input_shape = (28,28,1))) #첫번째는 input_shape 필수
model.add(MaxPooling2D(pool_size=(2,2),strides=2))
model.add(Conv2D(filters=64,kernel_size=(2,2),activation='relu'))
model.add(MaxPooling2D((2,2),2))
model.add(Flatten())
model.add(Dense(units=128,activation='relu'))
model.add(Dense(units=10,activation='softmax'))
model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])
model.fit(X_train,y_train,epochs=5)

학습이 끝나면 테스트셋으로 정확도를 확인합니다.

model.evaluate(X_test,y_test)

컨퓨전 매트릭스로 어떤 것을 틀렸는지 확인합니다.

from sklearn.metrics import confusion_matrix,accuracy_score

y_pred = model.predict(X_test)
y_pred=y_pred.argmax(axis=1)

cm = confusion_matrix(y_test,y_pred)

import seaborn as sb
sb.heatmap(data=cm,annot=True,fmt='.0f',cmap='RdPu')

트레이닝셋은 93% , 테스트셋은 91% 까지 나옵니다.
에포크를 20까지 해보면, 트레이닝셋 정확도는 올라가지만 밸리데이션 정확도는 내려갑니다.

즉, 오버핏팅이 됩니다.

import tensorflow as tf
mnist = tf.keras.datasets.fashion_mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
training_images=training_images.reshape(60000, 28, 28, 1)
training_images=training_images / 255.0
test_images = test_images.reshape(10000, 28, 28, 1)
test_images=test_images/255.0

위에서 만든 모델을 함수로 만들겠습니다.

그리고 학습할때 에포크를 20으로 해서 학습하겠습니다.

변수는 epoch_history로 사용해서 학습

def build_model():
  model = Sequential()
  model.add(Conv2D(filters=64,kernel_size=(3,3),activation='relu',input_shape = (28,28,1)))
  model.add(MaxPooling2D(pool_size=(2,2),strides=2))
  model.add(Conv2D(filters=64,kernel_size=(2,2),activation='relu'))
  model.add(MaxPooling2D((2,2),2))
  model.add(Flatten())
  model.add(Dense(units=128,activation='relu'))
  model.add(Dense(units=10,activation='softmax'))
  model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])

  return model

모델 생성

model = build_model()

모델 학습

epoch_history = model.fit(X_train,y_train,epochs=20,validation_split=0.2)

Accuracy 차트

plt.plot(epoch_history.history['accuracy'])
plt.plot(epoch_history.history['val_accuracy'])
plt.title('Model Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend(['Train','Validation'])
plt.show()

Loss 차트

plt.plot(epoch_history.history['loss'])
plt.plot(epoch_history.history['val_loss'])
plt.title('Model Loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend(['Train','Validation'])
plt.show()

Visualizing the Convolutions and Pooling

import matplotlib.pyplot as plt
f, axarr = plt.subplots(3,4)
FIRST_IMAGE=0
SECOND_IMAGE=7
THIRD_IMAGE=26
CONVOLUTION_NUMBER = 1
from tensorflow.keras import models
layer_outputs = [layer.output for layer in model.layers]
activation_model = tf.keras.models.Model(inputs = model.input, outputs = layer_outputs)
for x in range(0,4):
  f1 = activation_model.predict(X_test[FIRST_IMAGE].reshape(1, 28, 28, 1))[x]
  axarr[0,x].imshow(f1[0, : , :, CONVOLUTION_NUMBER], cmap='inferno')
  axarr[0,x].grid(False)
  f2 = activation_model.predict(X_test[SECOND_IMAGE].reshape(1, 28, 28, 1))[x]
  axarr[1,x].imshow(f2[0, : , :, CONVOLUTION_NUMBER], cmap='inferno')
  axarr[1,x].grid(False)
  f3 = activation_model.predict(X_test[THIRD_IMAGE].reshape(1, 28, 28, 1))[x]
  axarr[2,x].imshow(f3[0, : , :, CONVOLUTION_NUMBER], cmap='inferno')
  axarr[2,x].grid(False)

EXERCISES

1. 컨볼루션 필터 갯수를 16 또는 64로 바꿔서 정확도를 확인합니다.

2. 맨 마지막 컨볼루션 지우고 해봅니다

3. 콜백 셋팅해서 돌려봅니다.

모델생성

model = build_model()

얼리스탑핑 이용 방법

early_stop = tf.keras.callbacks.EarlyStopping(monitor='val_loss',patience=5)

콜백 클래스 이용 방법

class myCallback(tf.keras.callbacks.Callback):
  def on_epoch_end(self,epoch,logs={}):
    if logs['val_accuracy'] > 0.99 :
      print('\n벨리데이션 정확도가 99%가 넘으므로, 에포크를 멈춥니다.')
      self.model.stop_training = True

my_callback = myCallback()

모델 학습

epoch_history = model.fit(X_train,y_train,epochs=20,validation_split=0.2,callbacks=[early_stop,my_callback])

ANN 인공신경망을 이용해 자동차 연비 예측하기 EarlyStopping 콜백(callback) 사용

HooSL — Tue, 29 Mar 2022 11:27:03 +0900

필요한 라이브러리 import

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

구글 드라이브 마운트

from google.colab import drive
drive.mount('/content/drive')

auto-mpg.csv

0.01MB

csv파일 읽기

import os
# Working Direcctory Setting 워킹 디렉토리 세팅
os.chdir('/content/drive/csv파일 있는 위치')

df = pd.read_csv('auto-mpg.csv')

df

1. 빈데이터 확인

df.isna().sum()

2. 빈데이터 삭제

df=df.dropna()

3. X, y 설정

X=df.iloc[:,1:]
y=df['MPG']

4. 카테고리컬 데이터처리

Origin 컬럼은 다음과 같습니다. (1. American, 2. European,3. Japanese)

X=pd.get_dummies(X,columns=['Origin'])

더미삭제

X=X.drop('Origin_1',axis=1)

5. X 만 피처 스케일링 합니다. (차트 확인을 위해 y는 하지 않습니다.)

from sklearn.preprocessing import MinMaxScaler
scaler_X = MinMaxScaler()
scaler_X.fit_transform(X)
X = scaler_X.fit_transform(X)

6. Train / Test로 분리

from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=7)
X_train

7. 딥러닝 모델링(모델링 해주는 함수만들고 모델링)

필요한 라이브러리

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

모델링 함수

def build_model():
  model = Sequential()
  model.add(Dense(64,'relu',input_dim=X_train.shape[1]))
  model.add(Dense(64,'relu'))
  model.add(Dense(1,activation='linear'))

  model.compile(optimizer = 'adam',loss = 'mse',metrics=['mse','mae'])

  return model

모델링

model=build_model()

중요!! 학습하기 (EarlyStopping 콜백(callback)사용하고 안하고의 차이)

이곳은 안따라하셔도 됩니다.(오래 걸림)

epoch_history = model.fit(X_train,y_train,epochs=1000,validation_split=0.2)

이렇게 에포크 1000개까지 학습합니다.

상당한 시간이 걸립니다.

이 학습한 내용을 시각화 한다면?

#학습한 후의 결과를, 보기 위해서 학습 결과의 변수에 history 변수안에 있는 데이터를 데이터 프레임으로 만들기
df_history = pd.DataFrame(epoch_history.history)
df_history

차트화

import matplotlib.pyplot as plt

def plot_history(history):
  hist = pd.DataFrame(history.history)
  hist['epoch'] = history.epoch

  plt.figure(figsize=(8,12))

  plt.subplot(2,1,1)
  plt.xlabel('Epoch')
  plt.ylabel('Mean Abs Error [MPG]')
  plt.plot(hist['epoch'], hist['mae'],
           label='Train Error')
  plt.plot(hist['epoch'], hist['val_mae'],
           label = 'Val Error')
  plt.ylim([0,5])
  plt.legend()

  plt.subplot(2,1,2)
  plt.xlabel('Epoch')
  plt.ylabel('Mean Square Error [$MPG^2$]')
  plt.plot(hist['epoch'], hist['mse'],
           label='Train Error')
  plt.plot(hist['epoch'], hist['val_mse'],
           label = 'Val Error')
  plt.ylim([0,20])
  plt.legend()
  plt.show()

plot_history(epoch_history)

그래프를 보면 수 백번 에포크를 진행한 이후에는 모델이 거의 향상되지 않는 것 같습니다.

model.fit 메서드를 수정하여 검증 점수가 향상되지 않으면 자동으로 훈련을 멈추도록 만들어줍니다.

그래서 !! EarlyStopping 콜백(callback)사용합니다!!

#위에 에포크 1000개 했다면 모델을 다시 만들어 줍니다.
model = build_model()
# 안했다면 윗부분은 건너뜁니다.

# patience= 파라미터는 성능향상을 체크할 에포크 수로서
# 10이라고 세팅하면 에포크가 10번 지났는데도 성능향상없으면, 멈추라는 뜻입니다.
early_stop=tf.keras.callbacks.EarlyStopping(monitor='val_loss',patience=10)

epoch_history = model.fit(X_train,y_train,epochs=1000,validation_split=0.2,
                          callbacks = [early_stop])

이번엔 에포크 172까지만 수행하고 종료됐습니다.

import matplotlib.pyplot as plt

def plot_history(history):
  hist = pd.DataFrame(history.history)
  hist['epoch'] = history.epoch

  plt.figure(figsize=(8,12))

  plt.subplot(2,1,1)
  plt.xlabel('Epoch')
  plt.ylabel('Mean Abs Error [MPG]')
  plt.plot(hist['epoch'], hist['mae'],
           label='Train Error')
  plt.plot(hist['epoch'], hist['val_mae'],
           label = 'Val Error')
  plt.ylim([0,5])
  plt.legend()

  plt.subplot(2,1,2)
  plt.xlabel('Epoch')
  plt.ylabel('Mean Square Error [$MPG^2$]')
  plt.plot(hist['epoch'], hist['mse'],
           label='Train Error')
  plt.plot(hist['epoch'], hist['val_mse'],
           label = 'Val Error')
  plt.ylim([0,20])
  plt.legend()
  plt.show()

plot_history(epoch_history)

몇번 동일한 값이 나오니 자동으로 종료했습니다.

Neural Networks

HooSL — Tue, 29 Mar 2022 10:57:16 +0900

필요한 라이브러이 import

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
%matplotlib inline

구글 드라이브 마운트

from google.colab import drive
drive.mount('/content/drive')

Churn_Modelling.csv

0.64MB

csv파일 읽기

import os
# Working Direcctory Setting 워킹 디렉토리 세팅
os.chdir('/content/drive/csv파일 있는 위치')

df = pd.read_csv('Churn_Modelling.csv')

df

1. 비어있는 데이터 확인합니다.

df.isna().sum()

2. X와 y 설정합니다.

X=df.loc[:,'CreditScore':'EstimatedSalary']
y=df['Exited']

3. 문자열 데이터를 숫자로 변경합니다.

X의 Geography은 3개로 되어있으므로 원핫인코딩 해야합니다.
X의 Gender은 2개로 외어있으므로 레이블인코딩 해야합니다.

#원핫인코딩
X = pd.get_dummies(X,columns=['Geography'])

#레이블인코딩
from sklearn.preprocessing import LabelEncoder
encoder = LabelEncoder()
encoder.fit_transform(X['Gender'])

#Female, Male 정렬하면 ,Female이 0, Male이 1이 됩니다.
X['Gender'] = encoder.fit_transform(X['Gender'])

X

원 핫 인코딩한 결과의 맨 왼쪽 컬럼은, 삭제를 해도 0과 1로 모두 3개 데이터 표현 가능
Dummy varialbe trap : 즉 맨 왼쪽 하나의 컬럼은 지워도 됩니다.

많으면 메모리 먹기 떄문입니다
0 0 1 => 0 1
0 1 0 => 1 0
1 0 0 => 0 0

X=X.drop('Geography_France',axis=1)
X

4. 각 데이터의 범위를 일정하게 맞춰주는, 피쳐 스케일링 합니다.

딥러닝은 무조건 피처스케일링 합니다.

from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X = scaler.fit_transform(X)

5. 학습용과 테스트용으로 나눕니다.

from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.2,random_state=0)

6. 딥러닝으로 모델링

import tensorflow as tf
from tensorflow.keras.models import Sequential #sequential 신경망 같은거
from tensorflow.keras.layers import Dense #Dense는 레이어

model = Sequential()
X.shape# input_dim을 확인하기 위해

#히든레이어 생성 : 이때는 인풋 레이어의 숫자도 세팅해줍니다
model.add(Dense(units=6,activation='relu',input_dim = 11))

#히든레이어 생성(인풋레이어 필요없음)
model.add(Dense(units=8,activation='relu'))

#아웃풋 레이어 생성
model.add(Dense(units=1,activation='sigmoid'))

컴파일 합니다. Compile
오차함수를 설정하고 옵티마이저(그레디언트 디센트 알고리즘)를 설정합니다
옵티마이저는 그래디언트 디센트 알고리즘을 개선한 것들 중에서 선택하면 됩니다.
그래디언트 디센트는 오차가 최소가 될때의 W값을 찾는 알고리즘입니다.

loss는, 오차함수를 말합니다
분류의 문제는 2가지로 나뉩니다.
1. 2개로 분류하는 문제 : binary_crossentropy
2. 3개 이상으로 분류하는 문제 : categorical_crossentropy
위의 2개중 하나를 설정합니다

metrics 분류의 문제는 보통 정확도를 측정합니다

따라서 accuracy를 설정합니다

model.compile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy'])

#만든 모델을, 요약
model.summary()

7. 컴파일이 끝나면, 학습합니다.

epoch : 한 번의 epoch는 신경망에서 전체 데이터 셋에 대해 forward pass/backward pass 과정을 거친 것을 말합니다. 즉, 전체 데이터 셋에 대해 한 번 학습을 완료한 상태를 말합니다.

batch_size : 메모리의 한계와 속도 저하 때문에 대부분의 경우에는 한 번의 epoch에서 모든 데이터를 한꺼번에 집어넣을 수는 없습니다.

그래서 데이터를 나누어서 주게 되는데 이때 몇 번 나누어서 주는가를 iteration, 각 iteration마다 주는 데이터 사이즈를 batch size라고 합니다.

출처: https://www.slideshare.net/w0ong/ss-82372826

model.fit(X_train,y_train,epochs=20,batch_size=10)

8. 학습이 끝나면, 평가해야 합니다.

y_pred = model.predict(X_test)

# 0~1사이의 실수로 나옵니다.
# 이유는 아웃풋 레이어의 액티베이션 펑션으로 시그모이드를 시용했기 때문 입니다.
y_pred

y_pred 값이 실수로 나왔기 때문에 컨퓨전 매트릭스에 넣을 수 없습니다
따라서 0.5기준으로 크면 1, 작으면 0으로 맞춰줘야합니다.

y_pred = (y_pred > 0.5).astype(int)
#결과값 (2000,1)

#y_pred는 2차원 이므로, 컨퓨전매트릭스에 넣을 수 없기 때문에 1차원으로 만들어줍니다.

y_pred=y_pred.reshape(2000,)
#결과값 (2000,)

from sklearn.metrics import confusion_matrix, accuracy_score

confusion_matrix(y_test,y_pred)
accuracy_score(y_test,y_pred)

# 텐서플로우의 평가 함수 제공,
model.evaluate(X_test,y_test)

Facebook의 Prophet을 이용해 아보카도 가격 예측 plot,count plot차트 시각화 하기

HooSL — Tue, 29 Mar 2022 10:28:52 +0900

avocado.csv

1.88MB

데이터는 미국의 아보카도 리테일 데이터 입니다. (2018년도 weekly 데이터)
아보카도 거래량과 가격이 나와 있습니다.

컬럼 설명 :

Date - The date of the observation
AveragePrice - the average price of a single avocado
type - conventional or organic
year - the year
Region - the city or region of the observation
Total Volume - Total number of avocados sold
4046 - Total number of avocados with PLU 4046 sold - PLU는 농산물 코드입니다
4225 - Total number of avocados with PLU 4225 sold
4770 - Total number of avocados with PLU 4770 sold

1. 데이터 준비

Prophet 라이브러리
install : pip install fbprophet

위 에러 발생시 : conda install -c conda-forge fbprophet

레퍼런스 : https://research.fb.com/prophet-forecasting-at-scale/ https://facebook.github.io/prophet/docs/quick_start.html#python-api

Quick Start

Prophet is a forecasting procedure implemented in R and Python. It is fast and provides completely automated forecasts that can be tuned by hand by data scientists and analysts.

facebook.github.io

필요한 라이브러이 import

import pandas as pd  
import numpy as np 
import matplotlib.pyplot as plt 
import random
import seaborn as sns
from fbprophet import Prophet

구글 드라이브 마운트

from google.colab import drive
drive.mount('/content/drive')

csv파일 읽기

import os
# Working Direcctory Setting 워킹 디렉토리 세팅
os.chdir('/content/drive/csv파일 있는 위치')

# avocado.csv 데이터 읽기 필요없는 맨 첫컬럼은 제거 합니다.
avocado_df = pd.read_csv('avocado.csv',index_col=0)

avocado_df

2. EDA(Exploratory Data Analysis) : 탐색적 데이터 분석

데이터의 날짜가 뒤죽박죽이기 때문에 날짜로 정렬합니다.

avocado_df.sort_values('Date',inplace=True)
avocado_df

날짜별로 가격이 어떻게 변하는지 plot로 간단하게 확인해보겠습니다.

df_date=avocado_df.groupby('Date')['AveragePrice'].mean()

plt.plot(df_date)
plt.show()

region 지역별로 데이터가 몇개인지 시각화

plt.figure(figsize=(6,10))
sns.countplot(data=avocado_df,y='region')
plt.show()

프로펫분석을 위해, 두개의 컬럼만 가져옵니다. ('Date', 'AveragePrice')

avocado_prophet_df = avocado_df[['Date', 'AveragePrice']]

avocado_prophet_df

3. Prophet 을 이용한 예측 수행

날짜 컬럼은 ds로 예측하고자하는 가격 컬럼은 y로 바꿔줍니다.

avocado_prophet_df = avocado_prophet_df.rename(columns={'Date':'ds','AveragePrice':'y'})

avocado_prophet_df.head()

프로펫으로 예측합니다.

#1. 변수로 만듭니다
prophet = Prophet()

#2. 기존의 날짜와 데이터로 학습시킵니다
prophet.fit(avocado_prophet_df)

#3. 예측하고자 하는 기간을 정해서, 기간만 나와있는 데이터프레임 만듭니다
future = prophet.make_future_dataframe(periods=365) # 365일치를 예측했을 때

#4. 프로펫의 predict 함수를 이용해서 실제로 예측합니다
forecast = prophet.predict(future)

forecast

Time Series 타임 시리즈 데이터라고 합니다.

plot로 차트 확인

prophet.plot(forecast)
plt.savefig('chart1.jpg') #버그 떄문에 두개가 나와서 드라이브에 저장하면 한개만 나옵니다.

값이 너무 많내요...

컬럼을 더 쪼개면 값이 보기 편하게 나올겁니다. (예 region이 west인 아보카도 가격 예측)

prophet.plot_components(forecast)
plt.savefig('chart2.jpg')
#위에는 앞으로 전망
#밑에는 연단위 주기성

WordCloud Visualizing 스팸이메일 단어 워드클라우드

HooSL — Tue, 29 Mar 2022 09:55:55 +0900

https://dbfoot.tistory.com/173

Naive Bayes 나이브 베이즈와 Vectorizing 벡터라이징을 이용한 스팸 분류 예시

5,574개의 이메일 메시지가 있으며, 스팸인지 아닌지의 정보를 가지고 있다. 컬럼 : text, spam spam 컬럼의 값이 1이면 스팸이고, 0이면 스팸이 아닙니다. 스팸인지 아닌지 분류하는 인공지능을 만들

dbfoot.tistory.com

여기서 이어집니다.

from wordcloud import WordCloud, STOPWORDS

스팸만 들어있는 이메일의 내용을 가져와서 화면에 어떤 단어가 많이 나왔는지 시각화 하려 합니다.
데이터프레임에 있는 문자열을 하나의 문자열로 만들어 줘야합니다.

1. 각 행의 문자열을 리스트로 받아옵니다.

spam['text'].tolist()

2. 리스트에 들어있는 문자열을 join 함수 이용해서 하나로 만들어 줍니다.

words_as_one_string=''.join(spam['text'].tolist())

3. 워드 클라우드 만들기

워드클라우드를 사과모양으로 하기 위한 사진 파일

from PIL import Image

#첨부한 이미지를 가져옵니다.
img = Image.open('apple.jpg')

#이미지를 넘파이로 만들어줍니다.
img_mask = np.array(img)

#워드클라우드의 스탑워즈를 내 메모리에 생성해서 사용합니다
my_stopwords = STOPWORDS

my_stopwords.add('subject')
my_stopwords.add('us')
my_stopwords.add('one')

wc = WordCloud(background_color='white',mask=img_mask,stopwords=my_stopwords,max_words=100)

wc.generate(words_as_one_string)

plt.figure(figsize=(10,6))
plt.imshow(wc)
plt.axis('off')
plt.show()

Naive Bayes 나이브 베이즈와 Vectorizing 벡터라이징을 이용한 스팸 분류 예시

HooSL — Tue, 29 Mar 2022 09:46:26 +0900

5,574개의 이메일 메시지가 있으며, 스팸인지 아닌지의 정보를 가지고 있다.

컬럼 : text, spam

spam 컬럼의 값이 1이면 스팸이고, 0이면 스팸이 아닙니다.

스팸인지 아닌지 분류하는 인공지능을 만들자 - 수퍼바이즈드 러닝의 분류 문제!

구글드라이브 import

from google.colab import drive
drive.mount('/content/drive')

필요한 라이브러리 import

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline

emails.csv

8.54MB

spam_df=pd.read_csv('/content/drive/MyDrive/위치/emails.csv')

스팸이면 1 이고, 아니면 0 입니다.

스팸은 몇개이고, 아닌 것은 몇개인지 확인하기

spam_df['spam']==1
spam_df['spam'].value_counts()

sns.countplot(data=spam_df,x='spam')
plt.show()

이메일의 길이가 스팸과 관련이 있는지 확인해보려고 합니다.

이메일의 문자 길이를 구해서, length라는 컬럼을 만듭니다.

spam_df['length']=spam_df['text'].apply(len)
spam_df

글자 길이를 히스토그램으로 나타냅니다.

spam_df['length'].hist(bins=30)
plt.show()

가장 긴 이메일을 찾아서 스팸인지 아닌지 확인하고, 이메일 내용을 확인합니다.

spam_df['length'].max()

spam_df['length']==spam_df['length'].max()

spam_df.loc[spam_df['length']==spam_df['length'].max(),'text'][2650]

0은 스팸이 아니고, 1은 스팸입니다.

파이차트를 통해, 스팸과 스팸이 아닌 것이 몇 퍼센트인지, 소수점 1자리 까지만 보여줍니다.

spam_count = spam_df['spam'].value_counts()

plt.pie(spam_count,autopct='%.1f',labels=spam_count.index)
plt.legend()
plt.show()

스팸이 아닌 것은 ham 변수로 , 스팸인것은 spam 변수로 저장하겠습니다.

ham = spam_df.loc[spam_df['spam']==0,]

spam = spam_df.loc[spam_df['spam']==1,]

스팸의 이메일 길이를 히스토그램으로 나타내기

spam['length'].hist()
plt.show()

햄의 이메일 길이를 히스토그램으로 나타내기

ham['length'].hist()
plt.show()

쉼표, 마침표 등의 구두점 제거하기

문자열에는 필요없는 글자가 포함되어 있다마침표, 느낌표,물결표시등 ! 이런것을 punctuation (구두점) 이라고 합니다.이것을 먼저 제거합니다.

테스트 문장입니다.

Test = 'Hello Mr. Future, I am so happy to be learning AI now!~'

import string
string.punctuation

Test_punc_removed = []
for char in Test:
  if char not in string.punctuation:
    Test_punc_removed.append(char)
    
print(Test_punc_removed)

위의 리스트에 있는 문자들을, 하나의 문자열로 만듭니다.

''.join(Test_punc_removed)

Test_punc_removed_join =''.join(Test_punc_removed)
Test_punc_removed_join

STOPWORDS(불용어) 제거하기

STOPWORDS(불용어) 란?

https://dbfoot.tistory.com/172

Stopwords (불용어)

언어를 분석할때, stopwords 라는 용어가 나옵니다. stopwords 또는 불용어 란, 우리가 언어를 분석할 때, 의미가 있는 단어와, 의미가 없는 단어나 조사 등이 있습니다. 이렇게 의미가 없는 것들을 stop

dbfoot.tistory.com

import nltk

#불용어 다운로드
nltk.download('stopwords')

from nltk.corpus import stopwords
my_stopwords = stopwords.words('english')
my_stopwords

구두점 제거한 문자열을, 이제 불용어 단어에 해당하지 않는 단어들만 모아서 리스트로 만듭니다.

Test_punc_removed_join_clean =[]
for word in Test_punc_removed_join.split():
  if word.lower() not in my_stopwords:
    Test_punc_removed_join_clean.append(word)
    
print(Test_punc_removed_join_clean)

의미없는 글자도 제거 했으면 이제는 각 단어를 숫자로 바뚸줘야 학습할 수 있습니다.

단어를 숫자로 맵핑시키는 것을 벡터라이징 이라고 합니다. Vectorizing

레이블 인코딩(문자를 문자 순서대로 숫자로 변경)

from sklearn.feature_extraction.text import CountVectorizer

sample_data = ['This is the first document',
               'I loved them',
               'This document is the second document',
               'I am loving you',
               'And this is the third one']
               
Vectorizer = CountVectorizer()
X = Vectorizer.fit_transform(sample_data)

X=X.toarray()
Vectorizer.get_feature_names_out()

이제 우리의 데이터프레임에 있는, 이메일 내용을 Cleaning 합니다.

1. 구두점 제거 (글자 제거)

2. 불용어 제거 (단어 제거)

중요 이 두가지 작업을 하나의 함수로 만들어줍니다 : 파이프 라이닝

def message_cleaning(sentence):
  #1. 구두점 제거
  Test_punc_removed=[char for char in sentence if char not in string.punctuation]
  #2. 각각 떨어져 있는 글자를 다시 원상복구(하나의 문자열로 만든다)한다.
  Test_punc_removed_join=''.join(Test_punc_removed)
  #3. 문자열을 단어로 쪼개서, stopwords에 들어있는지 확인하여, 중요한 단어만 남긴다.
  Test_punc_removed_join_clean = [word for word in Test_punc_removed_join.split() if word.lower() not in my_stopwords]
  #4. 중요한 단어들만 남은 리스트를 리턴해준다.
  return Test_punc_removed_join_clean

message_cleaning('Hello~~! my name, is hehehe! nice to meet you.')

카운트 벡터라이저의 애널라이저 파라미터 위의 구두점제거 + 불용어 제거하는 함수를 설정해주면 알아서 이 함수를 먼저 실행하고 나서 숫자로 바꿔줍니다.

Vectorizer = CountVectorizer(analyzer=message_cleaning)
X=Vectorizer.fit_transform(spam_df['text'])

학습을 위해서 X,y를 세팅해줍니다.

X는 넘파이 어레이여야 하므로, toarray() 함수 이용해서 넘파이로 가져옵니다.

X=X.toarray()

y=spam_df['spam']

나이브 베이즈 모델링

from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=15)
from sklearn.naive_bayes import MultinomialNB,GaussianNB

classifier1 = MultinomialNB()
classifier1.fit(X_train,y_train)
y_pred=classifier1.predict(X_test)

y_test
y_pred

from sklearn.metrics import confusion_matrix,accuracy_score
confusion_matrix(y_test,y_pred)
accuracy_score(y_test,y_pred)

classifier2 = GaussianNB()
classifier2.fit(X_train,y_train)
y_pred = classifier2.predict(X_test)
confusion_matrix(y_test,y_pred)
accuracy_score(y_test,y_pred)

문장 테스트 해보겠습니다.

testing_sample = ['Free money!!!', "Hi Kim, Please let me know if you need any further information. Thanks",'Hello, I am Ryan, I would like to book a hotel in Bali by January 24th', 'money viagara!!!!!']
X_sample = Vectorizer.transform(testing_sample)
X_sample = X_sample.toarray()
classifier1.predict(X_sample)

Stopwords (불용어)

HooSL — Mon, 28 Mar 2022 17:51:55 +0900

언어를 분석할때, stopwords 라는 용어가 나옵니다.

stopwords 또는 불용어 란, 우리가 언어를 분석할 때, 의미가 있는 단어와, 의미가 없는 단어나 조사 등이 있습니다.

이렇게 의미가 없는 것들을 stopwords 라고 합니다.

예를 들어서, 다음 문장이 있으면,

"Family is not an important thing. It's everything."

Family, important, thing, everything 은 의미가 있다고 보고,

나머지 아래 같은 것들은 의미가 없다고 판단하여 stopwords 로 정의합니다.

{'a', 'about', 'above', 'after', 'again', 'against', 'all', 'also', 'am', 'an', 'and', 'any', 'are', "aren't", 'as', 'at', 'be', 'because', 'been', 'before', 'being', 'below', 'between', 'both', 'but', 'by', 'can', "can't", 'cannot', 'com', 'could', "couldn't", 'did', "didn't", 'do', 'does', "doesn't", 'doing', "don't", 'down', 'during', 'each', 'else', 'ever', 'few', 'for', 'from', 'further', 'get', 'had', "hadn't", 'has', "hasn't", 'have', "haven't", 'having', 'he', "he'd", "he'll", "he's", 'her', 'here', "here's", 'hers', 'herself', 'him', 'himself', 'his', 'how', "how's", 'however', 'http', 'i', "i'd", "i'll", "i'm", "i've", 'if', 'in', 'into', 'is', "isn't", 'it', "it's", 'its', 'itself', 'just', 'k', "let's", 'like', 'me', 'more', 'most', "mustn't", 'my', 'myself', 'no', 'nor', 'not', 'of', 'off', 'on', 'once', 'only', 'or', 'other', 'otherwise', 'ought', 'our', 'ours', 'ourselves', 'out', 'over', 'own', 'r', 'said', 'same', 'shall', "shan't", 'she', "she'd", "she'll", "she's", 'should', "shouldn't", 'since', 'so', 'some', 'such', 'than', 'that', "that's", 'the', 'their', 'theirs', 'them', 'themselves', 'then', 'there', "there's", 'these', 'they', "they'd", "they'll", "they're", "they've", 'this', 'those', 'through', 'to', 'too', 'under', 'until', 'up', 'very', 'was', "wasn't", 'we', "we'd", "we'll", "we're", "we've", 'were', "weren't", 'what', "what's", 'when', "when's", 'where', "where's", 'which', 'while', 'who', "who's", 'whom', 'why', "why's", 'with', "won't", 'would', "wouldn't", 'www', 'you', "you'd", "you'll", "you're", "you've", 'your', 'yours', 'yourself', 'yourselves'}

단, 불용어 ( Stopwords )는 그때 그때, 사람이 판단하여, 불용어 리스트에, 원하는 단어를 추가하거나 제거하면서 사용하면 됩니다.