dropout [deep learning] by 바죠


neural network 방법의 최대 문제점인 overfitting 문제, overtraining 문제를 해결하는 간단한 방법들 중 하나: dropout
neural network에서 overfitting을 방지하는 방법들 중 하나: dropout
training 할 때, 시간이 더 많이 걸리는 단점이 있지만, 보다 정확한 training 이 가능하다.
즉, 실제 테스트에서 보다 더 좋은 성능을 발휘한다.

50% dropout을 기본으로 한다.

 

통상, train, validation, test 라고 하는 방식을 활용한다.
또는 train, test로 분리해서 machine learning 의 정밀도와 transferability를 체크한다.
즉, 연습하여 학습하는 셋트가 있고, 연습하지 않은 세트, test 세트에 대해서 그 예측의 정확도를 알아보는 것이다.
당연히 연습, 학습을 한 train 셋에서는 매우 우수한 예측을 수행한다.
하지만, 연습하지 않은 유사한 test 세트에서의 예측 성능은 보장되는 것이 아니다.

통상 validation 셋에 대한 예측 성능이 최적화 되었을 때, 가중치 최적화 작업을 종료한다.
이 부분을 수행하는 것이 validation 단계이다.
최근 알파고와 이세돌 프로의 바둑 승부를 통해서 잘 알려진 항목중 하나가 바로 deep learning 항목이다.
By dropping a unit out, we mean temporarily removing it from the network, along with all its incoming and outgoing connections.
기계학습은 초귀납적 방법을 이용하는 것이다. 특히, 지도학습의 경우 그렇다.
vanishinggradient problem을해결하기 위해 기존에 사용하던 sigmoid 함수대신에 ReLU(RectifiedLinear Unit)라는함수가 새롭게 고안되었으며,dropout layer를사용하여 학습 중일 때 무작위로 뉴런을 비활성화 함으로써 학습이 학습 데이터에 치우치는 overfitting문제를해결하였습니다.





Max-norm regularization

A possible justification is that constraining weight vectors to lie inside a ball of fixed radius makes it possible to use a huge learning rate without the possibility of weights blowing up.

Dropout can be seen as a way of adding noise to the states of hidden units in a neural network.

Dropout introduces an extra hyperparameter|the probability of retaining a unit p.
This hyperparameter controls the intensity of dropout. p = 1, implies no dropout and low values
of p mean more dropout.

Typical values of p for hidden units are in the range 0:5 to 0:8.
For input layers, the choice depends on the kind of input. For real-valued inputs (image
patches or speech frames), a typical value is 0:8.

For hidden layers, the choice of p is coupled with the choice of number of hidden units n.
Smaller p requires big n which slows down the training and leads to underfiting.
Large p may not produce enough dropout to prevent overfitting.


r > p=0.8                 : input layer
r > p= 0.5 ~ 0.8            : hidden layer

p 가 작을 수록, hidden layer 수는 많아야만 한다.




* L1 방식: weight 값들의 절대값 기준으로 weight가 큰 숫자가 되지 못하도록 벌점함수를 도입한다.

* L2 방식: weight 값들의 절대값 제곱 기준으로 weight가 큰 숫자가 되지 못하도록 벌점함수를 도입한다.

--------------------------------------------------------------------------------------------------------------------
dropout 방법
학습할 때는, 30% 쉬게한다.
test 할 때는 100% 다 사용한다.

--------------------------------------------------------------------------------------------------------------------
ensemble

여러 개의 neural work 결과들을 합쳐서 사용함.
4% 성능향상됨.

-------------------------------------------------------------------------------------------------------------------
deep neural network이 성공한 이유:

많은 데이터 확보, 컴퓨터 성능향상 이외에 꼽을 수 있는 것은 대략 아래의 5가지이다.

1.
vanishing gradient 문제 해결,
ReLU 함수의 사용.
hidden layers : sigmoid 대신에 ReLU(rectified linear unit) 함수를 사용: ReLU(x) = max(0., x),
순화된 것도 있다. max(0.1*x, x)
마지막 output layer에서는 여전히 sigmoid 사용
https://en.wikipedia.org/wiki/Rectifier_(neural_networks
layer 수가 많을 수록 소위 vanishing gradient 문제가 발생함.
신호 전달이 잘 안 됨.
https://en.wikipedia.org/wiki/Vanishing_gradient_problem

2.
weight 초기화를 다른 방식으로 사용
Xavier 방법, He 방법, RBM
가우시안 분포를 가지는 무작위 숫자들을 사용한다. 이 때, weight들의 평균값은 0이다. weight들의 분산값을 정해줄 수 있다. sqrt(1/ns) 처럼 분산값을 정해 줄 수 있다.
여기서 ns는 앞쪽 layer에 속해 있는 뉴런의 숫자이다. 이러한 정규분포를 가지는 weight들을 training 할 때 사용한다. 

3.
dropout 방법의 적용. 과적합 문제를 해결함.

4. CNN 방법의 적용. 특히, 이미지 부분, 비대칭 데이터 처리

5.
weight 최적화 방법의 개발

deep learning 성공한 분야:
    Near-human-level image classification
 Near-human-level speech recognition
 Near-human-level handwriting transcription
 Improved machine translation
 Improved text-to-speech conversion
 Digital assistants such as Google Now and Amazon Alexa
 Near-human-level autonomous driving
 Improved ad targeting, as used by Google, Baidu, and Bing
 Improved search results on the web
 Ability to answer natural-language questions
 Superhuman Go playing







http://neuralnetworksanddeeplearning.com/chap5.html

--------------------------------------------------------------------------------------------------------------------
fast forward

split and merge

convolutional network

recurrent network


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

https://en.wikipedia.org/wiki/Cross-validation_(statistics)

K-fold cross-validation 방법: 
데이터를 k 개로 분류한다. 이 때, k-1 부분에 해당하는 데이터들을 training set으로 사용하고 나머지 데이터를 test set으로 활용한다. 예를 들어, 1000 개의 데이터가 있다고 가정하자. 또한, K=10으로 가정하자. 그렇게 되면, 1000/10=100 개로 만들어진 데이터가 10개 있게 된다. 이 때, 100개로 만들어진 데이터를 fold라고 한다. 즉, 10개의 fold가 생기게 된다. 처음 9개 fold들에 대해서, 즉, 9*100= 900 개 데이터에 대해서 training 를 수행한다. 그리고, training에 사용하지 않은 100개 데이터가 test set이된다.
그 다음은 자연스럽게 test set 부분을 바꿀 수 있다. 이렇게 10번 neural network의 성능을 측정할 수 있다. 

데이터가 정확하게 같은 크기의 fold들로 만들어지지 않을 수 있다. 이 경우, 최대한 비슷하게 만들어주면 된다.

이런식으로 neural network의 정밀도 (RMSE, MAE, accuracy)를 k (=10) 번 계산할 수 있다. 평균값과 표준편차를 계산할 수 있다.

통상 k=10을 가장 많이 사용한다. 가장 일반적인 경우이다. 


--------------------------------------------------------------------------------------------------------------------
#    mlp with dropout on the two circles dataset
from sklearn.datasets import make_circles
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from matplotlib import pyplot
#    generate 2d classification dataset
X, y = make_circles(n_samples=100, noise=0.1, random_state=1)
#    split into train and test
n_train = 30
trainX, testX = X[:n_train, :], X[n_train:, :]
trainy, testy = y[:n_train], y[n_train:]
#    define model
model = Sequential()
model.add(Dense(500, input_dim=2, activation='relu'))
model.add(Dropout(0.4))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
#    fit model
history = model.fit(trainX, trainy, validation_data=(testX, testy), epochs=4000, verbose=0)
#    evaluate the model
_, train_acc = model.evaluate(trainX, trainy, verbose=0)
_, test_acc = model.evaluate(testX, testy, verbose=0)
print('Train: %.3f, Test: %.3f' % (train_acc, test_acc))
#    plot history
pyplot.plot(history.history['acc'], label='train')
pyplot.plot(history.history['val_acc'], label='test')
pyplot.legend()
pyplot.show()

--------------------------------------------------------------------------------------------------------------------
import lightgbm as lgb
from bayes_opt import BayesianOptimization
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import train_test_split
from numpy import loadtxt
from sklearn.metrics import accuracy_score,confusion_matrix
import numpy as np
def lgb_evaluate(numLeaves, maxDepth, scaleWeight, minChildWeight, subsample, colSam):
    clf = lgb.LGBMClassifier(
        objective = 'binary',
        metric= 'auc',
        reg_alpha= 0,
        reg_lambda= 2,
#       bagging_fraction= 0.999,
        min_split_gain= 0,
        min_child_samples= 10,
        subsample_freq= 3,
#       subsample_for_bin= 50000,
#       n_estimators= 9999999,
        n_estimators= 99,
        num_leaves= int(numLeaves),
        max_depth= int(maxDepth),
        scale_pos_weight= scaleWeight,
        min_child_weight= minChildWeight,
        subsample= subsample,
        colsample_bytree= colSam,
        verbose =-1)
    scores = cross_val_score(clf, train_x, train_y, cv=5, scoring='roc_auc')
    return np.mean(scores)
def bayesOpt(train_x, train_y):
    lgbBO = BayesianOptimization(lgb_evaluate, {
                                                'numLeaves':  (5, 90),
                                                'maxDepth': (2, 90),
                                                'scaleWeight': (1, 10000),
                                                'minChildWeight': (0.01, 70),
                                                'subsample': (0.4, 1),
                                                'colSam': (0.4, 1)
                                            })
    lgbBO.maximize(init_points=5, n_iter=50)
    print(lgbBO.res)
dataset = loadtxt('pima-indians-diabetes.csv', delimiter=",")
X = dataset[:,0:8]
y = dataset[:,8]
train_x, X_test, train_y, y_test = train_test_split(X, y, test_size=0.2)
bayesOpt(train_x, train_y)

--------------------------------------------------------------------------------------------------------------------
#     Example of Dropout on the Sonar Dataset: Hidden Layer
from pandas import read_csv
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.wrappers.scikit_learn import KerasClassifier
from keras.constraints import maxnorm
from keras.optimizers import SGD
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import StratifiedKFold
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
#     load dataset
dataframe = read_csv("sonar.csv", header=None)
dataset = dataframe.values
#     split into input (X) and output (Y) variables
X = dataset[:,0:60].astype(float)
Y = dataset[:,60]
# encode class values as integers
encoder = LabelEncoder()
encoder.fit(Y)
encoded_Y = encoder.transform(Y)

#     dropout in hidden layers with weight constraint
def create_model():
        #     create model
        model = Sequential()
        model.add(Dense(60, input_dim=60, activation='relu', kernel_constraint=maxnorm(3)))
        model.add(Dropout(0.2))
        model.add(Dense(30, activation='relu', kernel_constraint=maxnorm(3)))
        model.add(Dropout(0.2))
        model.add(Dense(1, activation='sigmoid'))
        #     Compile model
        sgd = SGD(lr=0.1, momentum=0.9)
        model.compile(loss='binary_crossentropy', optimizer=sgd, metrics=['accuracy'])
        return model

estimators = []
estimators.append(('standardize', StandardScaler()))
estimators.append(('mlp', KerasClassifier(build_fn=create_model, epochs=300, batch_size=16, verbose=0)))
pipeline = Pipeline(estimators)
kfold = StratifiedKFold(n_splits=10, shuffle=True)
results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)
print("Hidden: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

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


핑백

덧글

  • 바죠 2018/10/01 08:28 # 답글

    In machine learning, a category in a classification problem is called a class. Data
    points are called samples. The class associated with a specific sample is called a
    label.

    Don’t confuse regression and the algorithm logistic regression. Confusingly,
    logistic regression isn’t a regression algorithm—it’s a classification
    algorithm.

    Attributes (the variables being used to make predictions) are also known as the following:
    * Predictors
    * Features
    * Independent variables
    * Inputs

    Labels are also known as the following:
    * Outcomes
    * Targets
    * Dependent variables
    * Responses
  • 2018/10/02 08:02 # 답글 비공개

    비공개 덧글입니다.
  • 2019/11/08 09:17 # 답글 비공개

    비공개 덧글입니다.
  • 바죠 2019/12/23 10:34 # 답글

    vanishing gradient problem을 해결하기 위해 기존에 사용하던 sigmoid 함수 대신에 ReLU(Rectified Linear Unit)라는 함수가 새롭게 고안되었으며, dropout layer를 사용하여 학습 중일 때 무작위로 뉴런을 비활성화 함으로써 학습이 학습 데이터에 치우치는 overfitting 문제를 해결하였습니다.
  • 바죠 2020/12/20 21:12 # 답글

    Looks like in Keras + Tensorflow 2.0 val_acc was renamed to val_accuracy
  • 바죠 2021/08/26 18:11 # 삭제 답글

    dropout(0.5)
    maxpooling 두가지가 디폴트
댓글 입력 영역

최근 포토로그



MathJax