Deep learning with Python by 바죠

Deep learning with Python


결국 텐서플로우와 파이썬이라는 컴퓨터 언어로 딥러닝이 민주화되었다. 매우 많은 사람들이 쉽게 딥러닝을 사용할 수 있게 되었다.  보다 더 정확하게 말하면, 2015년, 구글은 텐서프로우라는 플랫폼을 만들어서 누구나 쉽게 딥러닝을 할 수 있게 만들어버렸다. 
딥러닝과 기계학습 분야를 일반인들도 사용하기 쉽도록 다양한 기능들을 제공한다. 

기본적이고 소모적인 구현들을 CPU/GPU/TPU 에서 공통으로 실행 가능하게 만들어 내었다. 이것은 구글의 엄청난 대외 서비스라고 말할 수 있다. 연구소, 대학교가 하지 못하는 일을 한다. 마치 IBM이 포트란을 만들어 낸 것처럼 말이다. 

Machine learning(ML)은 주어진 많은 데이터를 기계가 학습하여 데이터를 분류(classification)하거나 새로운 데이터를 예측(regression)하는 것이다.  
예를 들어, 측정된 데이터(꽃 받침 길이, 폭, 꽃잎 길이, 폭)를 보고 꽃의 종류를 예측한다. (분류 문제, 예를 들어, 정확도 93%)
측정된 다양한 데이터(X vector)를 보고 당뇨병 발병 여부를(y = 0  or 1) 예측한다. (yes or no, 분류, 정확도, 예를 들어, 정밀도 97%)
잘 알려진 집 주변 정보, 집 내부 정보를 보고 (X vector, 다차원 정보, 예를 들어, 10가지 숫자들), 집값을 예측한다. (회귀 분석, regression, 정밀도 90%, 실거래 가격과 비교해 볼 수있을 것이다.)

딥러닝 방법은 연속적으로 변화하는 데이터에 대해서 아주 강력한 솔루션이 될 수 있다.
하지만, 소위 테이블 데이터에 대한 회귀, 분류는 여전히 의사 결정 트리 기반 알고리듬들이 좋은 성능을 발휘한다.
LightGBM, XGBoost 알고리듬들이 매우 좋은 분류, 회귀 성능을 자랑한다. 특히, LightGBM 방법은 매우 뛰어난 실행 성능과 정밀도를 제공한다.

2012년이 딥러닝의 원년이다.
2011년 Relu 함수의 출현 : vanishing gradient problem 해결, 표현력이 높은 딥러닝이 시작됨.
2012년 Dropout 방법의 출현 : overfitting problem 해결, 정규화된 훈련이 가능함.
2012년 CNN 출현 : 방대한 이미지 데이터 처리 문제 해결, 비대칭 데이터에 대한 처리가 가능함.
2013년 VAE 출현: 생성 모델로서 다양한 가능성을 제안함.
2015년 TensorFlow 구현의 출현과 보급 (오픈소스) : 실질적인 딥러닝의 민주화가 단행됨.
2016년 알파고 출현 : 바둑 정복
2017년 알파고 제로 출현 : tabula rasa, first-principles 방법을 이용하여 바둑 정복, 진정한 바둑의 정복이 가능함. 기보없이 바둑 정복함. 프로기사에게 절대로 지지 않는 사실상 바둑의 신이 탄생함. 5000년 바둑 역사의 이정표 확립
2018년 알파폴드 탄생
2020년 알파폴드 2 탄생, 단백질 구조예측의 신기원을 이루어 냄. 단백질 구조예측 50년 역사 최고의 성적.
 

현재 바둑판에서 흑/백이 이렇게 분포하면, 흑은어느 위치에 돌을 두어야 최종적으로 승리할 수 있을까? alphaGo, alphaGozero……

이런 동영상를 보는 이 사람은 특별히 어떤것을 좋아할 수 있다. 예측을 한다. 광고에 직접적으로 적용된다

유튜브 광고. Netflix 영화 추천.

메일 내용을 주면, 스팸인지 아닌지를 예측한다. Gmail

화면들이 이렇게 들어 오면, 현재 상황에서 자동차 운전을 어떻게 해야하는지를 알아 냄. Google 자율 주행.

이러한 음성이 들어 오면, 대답을 어떻게 해야 하는지 예측함. Alexa, 누구, 시리.

영어 번역, 영어 알아 듣기, 영문법 체크하기….. 번역기

이와 같이 ML은 적용 분야는 매우 넓은것이 특징이다.

전통적으로 해 온 것으로 가장 쉬운 예제가 실험값을 특정한 함수에 fitting 하는 것이다.

많은 파라메터들을 바꾸어 가면서 최대한 데이터들을 잘 설명하는 함수를 찾아내는 것이다.  

이학, 공학, 사회학에서도 똑같은 통계학적 처리를 원하고 있다.

X 벡터, y 벡터 사이의 상관 관계를 알아내는것, , 모델을 확립하는 것. 이론을 확립하는 것이 아니다.

 매우 많은 데이터[ big data, {X, y} ]로부터 모델을 알아내는 것이 ML 이다.

남들 보다 더 정밀한 모델을 만드는 것이 ML 의 핵심이다. 가장 정확한 model은 더 높은 예측력이 있기 때문이다.

당연히 이론을 만드는 것은 아니다. 사람이 하는 모든 일들을 기계가 하게하는 것으로 응용분야를 잡을 수 있을 것이다.

당연하게도 예측은 정밀도가 더 높을수록 좋을 것이다.

y 는 일차원 벡터 일수도 있지만, 다차원 벡터일 수도 있음. 문제에 따라서 달라진다.

아무튼 

\[ \vec{X} \rightarrow \vec{y} \]

상관관계를 잘 설명하는 모델을 만들어내는 것이 ML의 핵심이다.

인공신경망은 1940년대에 이미 개발된 방법이었고,

1980년대에 back propagation 방법이라는 최적화 방법이 소개되며 인공신경망 연구가 절정기를 구가한다

이후 인공신경망은 영상처리, 인공지능, 제어 등 다양한 분야에 적용되었지만, 1990년대에 이르러 그 연구가 포화 상태에 이르고, 한계를 지나 암흑기로 들어간다

주된 이유는 많은 은닉층을 쌓으면 성능이 좋아질것으로 예측하지만 실제는 학습이 안된다는 진퇴양난에 봉착하였다.



그렇다면 Deep learning(DL, 2012년 이후)은 무엇인가?


DL ML의 한 분야에 지나지 않는다. 다만, DL기법을 활용하면 기존의 ML 기법보다 더 정밀한 모델을 만들수 있다.

50년간 ML이 발달되어 왔다. 역사적으로 보아서, 하지만, 당초의 기대와 달리 ML은 별로 희망이 없어 보였는데, 갑자기, 2012년 이후최근 희망이 보임. 2011년 RELU 함수 출현한다. 이것으로 back propagation에 따른 훈련의 어려움, 이 문제가 해결이 된다. 과적합 문제도 dropout 방법으로 해결이 된다.

물론, 새로운 희망, 이것이 얼마나 큰 효과를 가져올 지는 아직 알 수 없다. 속단할 수 없는 단계이다.  

2012 DL의 출현 이후, ML 상황은 조금 개선되었다과거 ML 분야에서 응용을 제한하는 몇 가지 문제들이 일부 해결이 되었다.

, 예측력/정밀도를 더욱 더 올릴 수 있음이 다양한 응용에서 보여졌다.

과거에 ML을 많은 사람들이 포기 했었던 이유는 예측의 정밀도가 추가적으로 더 이상 올라가지 않았기 때문이다.  

DL 기법의 발전으로 ML 분야에서 과거 보다 더 정확한 예측을 가능하게 함.  2012년 이후를 DL 시대라고 한다.

(사람 수준으로 이미지를 알아냄. 사람 보다 더 뛰어난 바둑 실력, ....) 

[과거 ML 과 비교하여 매우 많은 데이터를 활용하게 되었다.  

매우 성능이 우수한 컴퓨터를 활용하게되었다더 많은 컴퓨터를 동시에 활용하게 되었다

(심지어, 매우 단순한 계산에서 성능을 발휘하는 GPU를 활용하게 되었다. 전용 계산기가 출현하기도 하였다.)

최근 몇 가지 중요한 ML 기법 자체의 발전이 있었다. 인공신경망 이론 자체의 발전을 의미한다.  

간단하게는 과거 보다 더 많은 신경망을 사용하게 되었다.

과거에는 상상할 수 없었던 수준으로 더 많은 신경망을 사용해 버림. 왜냐하면 계산이 가능하기 때문이다.  

예를 들어, 과거 ML에서는 1만개의 숫자로 모델을 표현 했다면,

최근 DL에서는 1000만개의 숫자를 이용하여 보다 더 정밀한 모델을 만들어낼 수 있다.

동시에 더 좋은 모델이 된다는 것을 보일 수 있게 되었다

이들 조건이 만족되면서 DL이 매우 유망한 연구/활용분야가 되어 버렸다.]

따라서, ML을 확실하게 공부하고 난 이후에, DL을 공부하면 된다. 기본을 할 수 있어야 한다.

ML의 잘 알려진, 기존의 통계 기법들을 모두 익혀야 한다.

아울러, Python 문법을 익혀서 방대한 데이터를 처리할 수 있어야 한다. (numpy, pandas)

Matplotlib를 이용한 그림 그리기도 익혀야 한다.

향후, ML, DL을 하던, 하지 않던, 위에서 이야기한 python, ML, 데이터 처리 기법, 그림 그리기 등은 사회학, 공학이학 어느 분야를 가도 마찬가지로 꼭 필요한 항목이다.

결국, python, numpy, matplotlib, pandas, scikit-learn, keras 등을 공부하면 된다. 이것을 한 꺼번에 하는 것은 꿰 어려울 것이다.


파이썬 언어를 어느 정도 알고 있다면 곧바로 ML을 시작할 수 있다.  곧바로 scikit-learn, keras를 공부하면 된다.

 

컴퓨터 언어 항목을 제외하면 scikit-learn 라이버러리를 통해서 ML을 습득할 수 있다.


DL Keras(TensorFlow) API를 통해서 습득할 수있다. 최근 Pytorch도 인기가 있다.


생성 모델들:  ML 에서 데이터들을 학습한 후, 학습한 데이터와 유사한 새로운 데이터를 만들어 내는 모델들을 지칭한다.
즉, 학습을 한 후에 짝퉁을 생산한다. VAE, GAN이 대표적인 기법이다. 이들 내용은 기계학습 입문한 후에 배워도 된다.
사실 이것은
\[ \vec{X} \rightarrow \vec{y} \]
형태의 학습이 아니라, 
\[ \vec{X} \rightarrow \vec{X} \]
형식의 학습에서 시작된다는 점에 주의 해야한다. 


자기 자신을 표헌하는 방법을 열심히 훈련하면, 최종적으로 짝퉁을 만들어 낼 수 있다. 아주 그렇듯한 짝퉁을 만들어 낼 수 있다. 
\[ \vec{X} \rightarrow \vec{X} \]
형식의 학습에서 고의적으로 정보의 양을 줄여준다. 정보의 양을 줄인다음에 다시 원본을 만들어 내는 네트워크를 만든다. 전반적인 인공 네트워크는 정보를 줄이고, 다시 정보를 복구하는 손실 네트워크를 만들어 내는 것이다. 



anaconda --> Environments --> base(root) --> Open Terminal
conda update conda
conda update anaconda
pip install tensorflow #CPU only
pip install tensorflow==1.5.0
pip install tensorflow-gpu #For GPU support
pip install keras

conda update conda
conda create -n testingyourchoice
activate testingyourchoice
conda install tensorflow
conda install tensorflow-gpu
conda install keras
conda install jupyter notebook
jupyter notebook

conda list
conda info --envs
---------------------------------------------------------------------------------------------------------------------
Keras_Cheat_Sheet_Python.pdf   (파이썬 언어용)
keras_cheat_sheet.pdf   (R 언어용)


-------------------------------------------------------------------------------------------------------------------

val_frac = 0.1
sidx=int(len(alldata)*val_frac)
model.fit(alldata[:sidx], alloutcome[:sidx], shuffle=True, validation_data=(alldata[sidx:], alloutcome[sidx:]) )
classifier.fit(X, Y, validation_split=0.2, epochs=150, batch_size=20)

-------------------------------------------------------------------------------------------------------------------
import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation
from keras.optimizers import SGD, Adam
import tensorflow as tf
import random as rn
from sklearn.utils import shuffle
import numpy as np
np.random.seed(123)
rn.seed(1234)
tf.set_random_seed(210)
def datagen(ndata0):
   x=np.zeros(ndata0)
   y=np.zeros(ndata0)
   for i in range(ndata0):
      x[i]=rn.randint(13,100)
      if x[i] < 64:
          y[i]=1.
          if rn.random() < 0.05 :
             y[i]=0.
      else:
          y[i]=0.
          if rn.random() < 0.05:
             y[i]=1.
   scaled=200.
   x=x/scaled
   return x,y
ndata=10000
X, Y = datagen(ndata)
X, Y = shuffle(X,Y,random_state=0)
model=Sequential()
model.add(Dense(32, activation='relu', input_shape=(1,)))
model.add(Dropout(0.1))
model.add(Dense(32, activation='relu'))
model.add(Dropout(0.1))
model.add(Dense(32, activation='relu'))
model.add(Dropout(0.1))
model.add(Dense(32, activation='relu'))
model.add(Dropout(0.1))
model.add(Dense(2, activation='softmax'))

model.summary()
model.compile(Adam(lr=0.001), loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(X, Y, validation_split=0.1, epochs=10, batch_size=10, shuffle=True, verbose=2)
nprd=10
x, y = datagen(nprd)
for i in range(nprd):
    print(y[i])
predictions=model.predict(x, batch_size=nprd,verbose=2)
print(predictions)
rounded_predictions=model.predict_classes(x, batch_size=nprd,verbose=2)
for i in rounded_predictions:
    print(i)
-------------------------------------------------------------------------------------------------------------------
#           Regression Example With Boston Dataset: Standardized and Wider
import numpy
import random
import tensorflow as tf
from pandas import read_csv
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasRegressor
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
numpy.random.seed(123)
random.seed(1234)
tf.set_random_seed(210)
#          load dataset
dataframe = read_csv("housing.csv", delim_whitespace=True, header=None)
dataset = dataframe.values
#           split into input (X) and output (Y) variables
X = dataset[:,0:13]
Y = dataset[:,13]
#         define wider model
def wider_deeper_model():
        #        create model
        model = Sequential()
        model.add(Dense(25, input_dim=13, kernel_initializer='normal', activation='relu'))
        model.add(Dense(18, kernel_initializer='normal', activation='relu'))
        model.add(Dense(7,  kernel_initializer='normal', activation='relu'))
        model.add(Dense(1, kernel_initializer='normal'))

        #        Compile model
        model.compile(loss='mean_squared_error', optimizer='adam')
        return model
#      fix random seed for reproducibility
seed = 7
numpy.random.seed(seed)
#      evaluate model with standardized dataset
estimators = []
estimators.append(('standardize', StandardScaler()))
estimators.append(('mlp', KerasRegressor(build_fn=wider_deeper_model, epochs=100, batch_size=5, verbose=0)))
pipeline = Pipeline(estimators)
kfold = KFold(n_splits=10, random_state=seed)
results = cross_val_score(pipeline, X, Y, cv=kfold)
print("Wider: %.2f (%.2f) MSE" % (results.mean(), results.std()))
-------------------------------------------------------------------------------------------------------------------
import numpy as np
np.random.seed(1337)  # for reproducibility
from keras.models import Sequential
from keras.layers import Dense
#      create some data
X = np.linspace(-1, 1, 200)
np.random.shuffle(X)    # randomize the data
Y = 0.5 * X + 2 + np.random.normal(0, 0.05, (200, ))
#      train test split
X_train, Y_train = X[:160], Y[:160]    
X_test, Y_test = X[160:], Y[160:]  
model = Sequential()
model.add(Dense(output_dim=1, input_dim=1))

model.compile(loss='mse', optimizer='sgd')
print('Training -----------')
for step in range(301):
    cost = model.train_on_batch(X_train, Y_train)
    if step % 100 == 0:
        print('train cost: ', cost)
print('nTesting ------------')
cost = model.evaluate(X_test, Y_test, batch_size=40)
print('test cost:', cost)
W, b = model.layers[0].get_weights()
print('Weights=', W, 'nbiases=', b)
-------------------------------------------------------------------------------------------------------------------
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from keras.models import Sequential
from keras.layers import Dense
import keras
#       Load the data from the CSV file
abalone_df = pd.read_csv('abalone.csv',names=['Sex','Length','Diameter','Height',
                                             'Whole Weight','Shucked Weight',
                                             'Viscera Weight','Shell Weight',
                                             'Rings'])
#      Transform sex into a dummy variable using one-hot encoding
abalone_df['Male'] = (abalone_df['Sex']=='M').astype(int)
abalone_df['Female'] = (abalone_df['Sex']=='F').astype(int)
abalone_df['Infant'] = (abalone_df['Sex']=='I').astype(int)
abalone_df = abalone_df[abalone_df['Height']>0]
#      Split the data into training and testing
#      Don't make the mistake I did and try a pandas DataFrame here; it must be a
#      numpy array

train, test = train_test_split(abalone_df, train_size=0.7)
x_train = train.drop(['Rings','Sex'], axis=1).values
y_train = pd.DataFrame(train['Rings']).values
x_test = test.drop(['Rings','Sex'], axis=1).values
y_test = pd.DataFrame(test['Rings']).values
#      abalone_model = Sequential([Dense(20, input_dim=10, activation='tanh'), Dense(5, activation='tanh'), Dense(1), ])
abalone_model = Sequential([Dense(20, input_dim=10, activation='relu'),
Dense(10, activation='relu'),
Dense(5, activation='relu'),
Dense(1), ])
abalone_model.compile(optimizer='rmsprop',loss='mse', metrics=['mean_absolute_error'])
tb = keras.callbacks.TensorBoard(log_dir='./logs', histogram_freq=0, write_graph=True, write_images=False)
results = abalone_model.fit(x_train, y_train, nb_epoch=200, verbose=2, callbacks=[tb])
score = abalone_model.evaluate(x_test, y_test)
#     The second entry in the array is the MAE
print("nTesting MAE: {}".format(score[1]))

-------------------------------------------------------------------------------------------------------------------
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from keras.models import Sequential
from keras.layers import Dense
import keras
#      Load the data from the CSV file
abalone_df = pd.read_csv('abalone.csv',names=['Sex','Length','Diameter','Height',
                                             'Whole Weight','Shucked Weight',
                                             'Viscera Weight','Shell Weight',
                                             'Rings'])
#     Transform sex into a dummy variable using one-hot encoding
abalone_df['Male'] = (abalone_df['Sex']=='M').astype(int)
abalone_df['Female'] = (abalone_df['Sex']=='F').astype(int)
abalone_df['Infant'] = (abalone_df['Sex']=='I').astype(int)
abalone_df = abalone_df[abalone_df['Height']>0]
#     Split the data into training and testing
#     Don't make the mistake I did and try a pandas DataFrame here; it must be a
#     numpy array

train, test = train_test_split(abalone_df, train_size=0.7)
x_train = train.drop(['Rings','Sex'], axis=1).values
y_train = pd.DataFrame(train['Rings']).values
x_test = test.drop(['Rings','Sex'], axis=1).values
y_test = pd.DataFrame(test['Rings']).values
abalone_model = Sequential([
    Dense(20, input_dim=10, activation='relu'),
    Dense(5, activation='relu'),
    Dense(1), ])
abalone_model.compile(optimizer='rmsprop',loss='mse', metrics=['mean_absolute_error'])
tb = keras.callbacks.TensorBoard(log_dir='./logs', histogram_freq=0, write_graph=True, write_images=False)
results = abalone_model.fit(x_train, y_train, nb_epoch=200, verbose=0, callbacks=[tb])
score = abalone_model.evaluate(x_test, y_test)
#      The second entry in the array is the MAE
print("nTesting MAE: {}".format(score[1]))

-------------------------------------------------------------------------------------------------------------------
from keras.models import Sequential
from keras.layers import Dense
from sklearn.model_selection import train_test_split
import pandas as pd
df = pd.read_csv('housing.csv', delim_whitespace=True, header=None)
data_set = df.values
X = data_set[:, 0:13]
Y = data_set[:, 13]
X_train, X_validation, Y_train, Y_validation = train_test_split(X, Y, test_size=0.2)
model = Sequential()
model.add(Dense(30, input_dim=13, activation='relu'))
model.add(Dense(20, activation='relu'))
model.add(Dense(10, activation='relu'))
model.add(Dense(6, activation='relu'))
model.add(Dense(6, activation='relu'))
model.add(Dense(1))

model.summary()
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(X_train, Y_train, epochs=200, batch_size=10)
Y_prediction = model.predict(X_validation).flatten()
for i in range(10):
  real_price = Y_validation[i]
  predicted_price = Y_prediction[i]
  print('Real Price: {:.3f}, Predicted Price: {:.3f}'.format(real_price, predicted_price))
-------------------------------------------------------------------------------------------------------------------
import numpy as np
from tensorflow import keras
from tensorflow.keras import layers
# Model / data parameters
num_classes = 10
input_shape = (28, 28, 1)

# the data, split between train and test sets
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# Scale images to the [0, 1] range
x_train = x_train.astype("float32") / 255
x_test = x_test.astype("float32") / 255
# Make sure images have shape (28, 28, 1)
x_train = np.expand_dims(x_train, -1)
x_test = np.expand_dims(x_test, -1)
print("x_train shape:", x_train.shape)
print(x_train.shape[0], "train samples")
print(x_test.shape[0], "test samples")


# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
model = keras.Sequential(
    [
        keras.Input(shape=input_shape),
        layers.Conv2D(32, kernel_size=(3, 3), activation="relu"),
        layers.MaxPooling2D(pool_size=(2, 2)),
        layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
        layers.MaxPooling2D(pool_size=(2, 2)),
        layers.Flatten(),
        layers.Dropout(0.5),
        layers.Dense(num_classes, activation="softmax"),
    ]
)

model.summary()
batch_size = 128
epochs = 15

model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])

model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.1)
-------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------
import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation
from keras.optimizers import SGD, Adam
import tensorflow as tf
import random as rn
from sklearn.utils import shuffle
import numpy as np
np.random.seed(123)
rn.seed(1234)
tf.set_random_seed(210)
def datagen(ndata0):
   x=np.zeros(ndata0)
   y=np.zeros(ndata0)
   for i in range(ndata0):
      x[i]=rn.randint(13,100)
      if x[i] < 64:
          y[i]=1.
          if rn.random() < 0.05 :
             y[i]=0.
      else:
          y[i]=0.
          if rn.random() < 0.05:
             y[i]=1.
   scaled=200.
   x=x/scaled
   return x,y
ndata=10000
X, Y = datagen(ndata)
X, Y = shuffle(X,Y,random_state=0)
model=Sequential()
model.add(Dense(32, activation='relu', input_shape=(1,)))
model.add(Dropout(0.1))
model.add(Dense(32, activation='relu'))
model.add(Dropout(0.1))
model.add(Dense(32, activation='relu'))
model.add(Dropout(0.1))
model.add(Dense(32, activation='relu'))
model.add(Dropout(0.1))
model.add(Dense(2, activation='softmax'))

model.summary()
model.compile(Adam(lr=0.001), loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(X, Y, validation_split=0.1, epochs=10, batch_size=10, shuffle=True, verbose=2)
nprd=10
x, y = datagen(nprd)
for i in range(nprd):
    print(y[i])
predictions=model.predict(x, batch_size=nprd,verbose=2)
print(predictions)
rounded_predictions=model.predict_classes(x, batch_size=nprd,verbose=2)
for i in rounded_predictions:
    print(i)
-------------------------------------------------------------------------------------------------------------------
#       Regression Example With Boston Dataset: Standardized and Wider
import numpy
import random
import tensorflow as tf
from pandas import read_csv
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasRegressor
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
numpy.random.seed(123)
random.seed(1234)
tf.set_random_seed(210)
#      load dataset
dataframe = read_csv("housing.csv", delim_whitespace=True, header=None)
dataset = dataframe.values
#       split into input (X) and output (Y) variables
X = dataset[:,0:13]
Y = dataset[:,13]
#       define wider model
def wider_deeper_model():
        #          create model
        model = Sequential()
        model.add(Dense(25, input_dim=13, kernel_initializer='normal', activation='relu'))
        model.add(Dense(18, kernel_initializer='normal', activation='relu'))
        model.add(Dense(7,  kernel_initializer='normal', activation='relu'))
        model.add(Dense(1, kernel_initializer='normal'))

        #         Compile model
        model.compile(loss='mean_squared_error', optimizer='adam')
        return model
#      fix random seed for reproducibility
seed = 7
numpy.random.seed(seed)
#      evaluate model with standardized dataset
estimators = []
estimators.append(('standardize', StandardScaler()))
estimators.append(('mlp', KerasRegressor(build_fn=wider_deeper_model, epochs=100, batch_size=5, verbose=0)))
pipeline = Pipeline(estimators)
kfold = KFold(n_splits=10, random_state=seed)
results = cross_val_score(pipeline, X, Y, cv=kfold)
print("Wider: %.2f (%.2f) MSE" % (results.mean(), results.std()))
-------------------------------------------------------------------------------------------------------------------
import numpy as np
np.random.seed(1337)  # for reproducibility
from keras.models import Sequential
from keras.layers import Dense
#      create some data
X = np.linspace(-1, 1, 200)
np.random.shuffle(X)    # randomize the data
Y = 0.5 * X + 2 + np.random.normal(0, 0.05, (200, ))
#      train test split
X_train, Y_train = X[:160], Y[:160]    
X_test, Y_test = X[160:], Y[160:]  
model = Sequential()
model.add(Dense(output_dim=1, input_dim=1))

model.compile(loss='mse', optimizer='sgd')
print('Training -----------')
for step in range(301):
    cost = model.train_on_batch(X_train, Y_train)
    if step % 100 == 0:
        print('train cost: ', cost)
print('nTesting ------------')
cost = model.evaluate(X_test, Y_test, batch_size=40)
print('test cost:', cost)
W, b = model.layers[0].get_weights()
print('Weights=', W, 'nbiases=', b)
-------------------------------------------------------------------------------------------------------------------
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from keras.models import Sequential
from keras.layers import Dense
import keras
#         Load the data from the CSV file
abalone_df = pd.read_csv('abalone.csv',names=['Sex','Length','Diameter','Height',
                                             'Whole Weight','Shucked Weight',
                                             'Viscera Weight','Shell Weight',
                                             'Rings'])
#       Transform sex into a dummy variable using one-hot encoding
abalone_df['Male'] = (abalone_df['Sex']=='M').astype(int)
abalone_df['Female'] = (abalone_df['Sex']=='F').astype(int)
abalone_df['Infant'] = (abalone_df['Sex']=='I').astype(int)
abalone_df = abalone_df[abalone_df['Height']>0]
#      Split the data into training and testing
#      Don't make the mistake I did and try a pandas DataFrame here; it must be a
#      numpy array

train, test = train_test_split(abalone_df, train_size=0.7)
x_train = train.drop(['Rings','Sex'], axis=1).values
y_train = pd.DataFrame(train['Rings']).values
x_test = test.drop(['Rings','Sex'], axis=1).values
y_test = pd.DataFrame(test['Rings']).values
#abalone_model = Sequential([Dense(20, input_dim=10, activation='tanh'), Dense(5, activation='tanh'), Dense(1), ])
abalone_model = Sequential([Dense(20, input_dim=10, activation='relu'),
Dense(10, activation='relu'),
Dense(5, activation='relu'),
Dense(1), ])
abalone_model.compile(optimizer='rmsprop',loss='mse', metrics=['mean_absolute_error'])
tb = keras.callbacks.TensorBoard(log_dir='./logs', histogram_freq=0, write_graph=True, write_images=False)
results = abalone_model.fit(x_train, y_train, nb_epoch=200, verbose=2, callbacks=[tb])
score = abalone_model.evaluate(x_test, y_test)
#       The second entry in the array is the MAE
print("nTesting MAE: {}".format(score[1]))
-------------------------------------------------------------------------------------------------------------------
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from keras.models import Sequential
from keras.layers import Dense
import keras
#         Load the data from the CSV file
abalone_df = pd.read_csv('abalone.csv',names=['Sex','Length','Diameter','Height',
                                             'Whole Weight','Shucked Weight',
                                             'Viscera Weight','Shell Weight',
                                             'Rings'])
#       Transform sex into a dummy variable using one-hot encoding
abalone_df['Male'] = (abalone_df['Sex']=='M').astype(int)
abalone_df['Female'] = (abalone_df['Sex']=='F').astype(int)
abalone_df['Infant'] = (abalone_df['Sex']=='I').astype(int)
abalone_df = abalone_df[abalone_df['Height']>0]
#      Split the data into training and testing
#      Don't make the mistake I did and try a pandas DataFrame here; it must be a
#      numpy array

train, test = train_test_split(abalone_df, train_size=0.7)
x_train = train.drop(['Rings','Sex'], axis=1).values
y_train = pd.DataFrame(train['Rings']).values
x_test = test.drop(['Rings','Sex'], axis=1).values
y_test = pd.DataFrame(test['Rings']).values
abalone_model = Sequential([
    Dense(20, input_dim=10, activation='relu'),
    Dense(5, activation='relu'),
    Dense(1), ])
abalone_model.compile(optimizer='rmsprop',loss='mse', metrics=['mean_absolute_error'])
tb = keras.callbacks.TensorBoard(log_dir='./logs', histogram_freq=0, write_graph=True, write_images=False)
results = abalone_model.fit(x_train, y_train, nb_epoch=200, verbose=0, callbacks=[tb])
score = abalone_model.evaluate(x_test, y_test)
#     The second entry in the array is the MAE
print("nTesting MAE: {}".format(score[1]))
-------------------------------------------------------------------------------------------------------------------
from keras.models import Sequential
from keras.layers import Dense
from sklearn.model_selection import train_test_split
import pandas as pd
df = pd.read_csv('housing.csv', delim_whitespace=True, header=None)
data_set = df.values
X = data_set[:, 0:13]
Y = data_set[:, 13]
X_train, X_validation, Y_train, Y_validation = train_test_split(X, Y, test_size=0.2)
model = Sequential()
model.add(Dense(30, input_dim=13, activation='relu'))
model.add(Dense(20, activation='relu'))
model.add(Dense(10, activation='relu'))
model.add(Dense(6, activation='relu'))
model.add(Dense(6, activation='relu'))
model.add(Dense(1))

model.summary()
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(X_train, Y_train, epochs=200, batch_size=10)
Y_prediction = model.predict(X_validation).flatten()
for i in range(10):
  real_price = Y_validation[i]
  predicted_price = Y_prediction[i]
  print('Real Price: {:.3f}, Predicted Price: {:.3f}'.format(real_price, predicted_price))
-------------------------------------------------------------------------------------------------------------------
#      Create your first MLP in Keras
from keras.models import Sequential
from keras.layers import Dense
import numpy
#       fix random seed for reproducibility
numpy.random.seed(7)
#       load pima indians dataset
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
#       split into input (X) and output (Y) variables
X = dataset[:,0:8]
Y = dataset[:,8]
#       create model
model = Sequential()
model.add(Dense(12, input_dim=8, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))

#        Compile model
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
#        Fit the model
model.fit(X, Y, epochs=150, batch_size=10)
#        evaluate the model
scores = model.evaluate



-------------------------------------------------------------------------------------------------------------------



------------------------------------------------------------------------------------------------------------------------


------------------------------------------------------------------------------------------------------------------------

from tensorflow.keras.preprocessing.image import ImageDataGenerator

datagen = ImageDataGenerator(
        samplewise_center=True,  # set each sample mean to 0
        rotation_range=10,  # randomly rotate images in the range (degrees, 0 to 180)
        zoom_range = 0.1, # Randomly zoom image 
        width_shift_range=0.1,  # randomly shift images horizontally (fraction of total width)
        height_shift_range=0.1,  # randomly shift images vertically (fraction of total height)
        horizontal_flip=True,  # randomly flip images
        vertical_flip=False) # we don't expect Bo to be upside-down so we will not flip vertically

# load and iterate training dataset
train_it = datagen.flow_from_directory('./COVID/train/', 
                                       target_size=(224, 224), 
                                       color_mode='rgb', 
                                       class_mode='binary', 
                                       batch_size=8)
# load and iterate validation dataset
valid_it = datagen.flow_from_directory('./COVID/test/', 
                                      target_size=(224, 224), 
                                      color_mode='rgb', 
                                      class_mode='binary', 
                                      batch_size=8)

------------------------------------------------------------------------------------------------------------------------



multi-class classification의 경우, 5종 분류인 경우, 폴더 5개를 만들어서 준비한다.

from keras.preprocessing.image import ImageDataGenerator
from keras.utils import np_utils
from keras.models import Sequential
from keras.preprocessing.image import array_to_img, img_to_array, load_img
from keras.layers import *
from keras.callbacks import ModelCheckpoint, EarlyStopping
import os
import pandas as pd
import numpy as np
from sklearn.metrics import accuracy_score

trainDataGen = ImageDataGenerator(rescale=1./255,
rotation_range = 30,  width_shift_range=0.1,   height_shift_range=0.1,  shear_range=0.2,  zoom_range=0.2,  horizontal_flip=False,   vertical_flip=False,   fill_mode='nearest')
trainGenSet = trainDataGen.flow_from_directory( path + 'train',    batch_size=32,    target_size =(28,28), class_mode='categorical')

model = Sequential()
model.add(Conv2D(64, kernel_size=(3,3), padding='same', input_shape=(28,28,3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Dropout(0.25))
model.add(Conv2D(128, kernel_size=(3,3),padding='same', activation='relu'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Dropout(0.25))
model.add(Conv2D(256, kernel_size=(3,3), padding='same', activation='relu'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.25))
model.add(Dense(5, activation='softmax'))
model.summary()
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit_generator(   trainGenSet, steps_per_epoch=20, epochs=200,    validation_data=testGenSet, validation_steps=10)
scores = model.evaluate_generator(testGenSet)
print(scores)



-------------------------

from tensorflow.keras.preprocessing.image import ImageDataGenerator

datagen = ImageDataGenerator(
    rotation_range=10,  # randomly rotate images in the range (degrees, 0 to 180)
    zoom_range=0.1,  # Randomly zoom image
    width_shift_range=0.1,  # randomly shift images horizontally (fraction of total width)
    height_shift_range=0.1,  # randomly shift images vertically (fraction of total height)
    horizontal_flip=True,  # randomly flip images horizontally
    vertical_flip=False, # Don't randomly flip images vertically
)

batch_size = 32
img_iter = datagen.flow(x_train_conv, y_train, batch_size=batch_size)
model.fit(x_train_conv, y_train, epochs=20, verbose=1, validation_data=(x_test_conv, y_test))

# show the first five filters
filters, biases = model.layers[0].get_weights()
print(filters.shape)
plt.subplot(151)
plt.imshow(filters[:,:,0,0], cmap='gray')
plt.subplot(152)
plt.imshow(filters[:,:,0,1], cmap='gray')
plt.subplot(153)
plt.imshow(filters[:,:,0,2], cmap='gray')
plt.subplot(154)
plt.imshow(filters[:,:,0,3], cmap='gray')
plt.subplot(155)
plt.imshow(filters[:,:,0,4], cmap='gray')
plt.show()



------------------------------------------------------------------------------------------------------------------------

ImageDataGenerator  는 폴더을 알아보고 classes를 스스로 정의한다.
정확하게은 메소드가 그 일을 하는데, flow_from_directory

핑백

덧글

  • 2019/03/21 16:07 # 답글 비공개

    비공개 덧글입니다.
  • 2019/03/21 16:15 # 답글 비공개

    비공개 덧글입니다.
  • 바죠 2019/09/18 15:22 # 답글

    Ensemble,
    ResNext
  • 바죠 2019/11/08 14:44 # 답글

    https://github.com/keras-team/keras/blob/master/examples/variational_autoencoder.py


  • 바죠 2019/11/08 15:14 # 답글

    https://raw.githubusercontent.com/keras-team/keras/master/examples/variational_autoencoder.py

  • 2019/11/09 16:37 # 답글 비공개

    비공개 덧글입니다.
  • 바죠 2019/11/10 10:13 # 답글

    GPU 사용

    https://stackoverflow.com/questions/45662253/can-i-run-keras-model-on-gpu
댓글 입력 영역

최근 포토로그



MathJax