잠시 빌려쓰고, 낡아지면 버려지는 이 한몸. 빈손으로 태어나 결국 빈손으로 털고 돌아가는, 이 인생의 고갯길은, 그 어떤것도 내 것이 될 수 없고, 누구의 것도 될 수 없는, 구름과 바람같은 덧없는 인생살이인데, 하물며 이 마음은 오죽하랴. 그냥 잠시 허허 웃고 살다가리
이 설정 파일을 이용하여, Kubeflow를 설치하면 멀티 사용자 기능을 사용할 수 있습니다. 사용자 인증을 위하여 dex 라는 것을 이용하고 있습니다. dex 는 OpenID Connect 를 지원하는 식별 서비스로서, LDAP, Github, SAML 등의 여러 가지의 인증 방식과 연동이 가능합니다. 기존에 사용하고 있는 인증 방식을 Kubeflow에 연동할 수 있습니다. 즉, 회사에서 LDAP 이라는 인증 방식을 사용하고 있었다면, dex와 LDAP 을 연동해서, LDAP에서 사용하던 계정으로, kubeflow에 로그인할 수 있다는 것입니다.
사용자 확인하기
Kubeflow와 함께 설치되는 dex 는 사용자 정보를 파일에 직접 저장하고 있습니다. 이 파일은 ConfigMap에 저장되어 있습니다.
dex는 쿠버네티스의 auth 라는 네임스페이스 설치됩니다. dex 라는 ConfigMap을 조회하면 설정 정보를 볼 수 있습니다.
staticPasswords 필드를 보면 사용자 이메일과 패스워드의 해시값을 확인할 수 있습니다. 패스워드는 “BCrypt”를 이용하여 해시값을 생성한 후 사용하고 있습니다. 참고로 설치할때 기본으로 생성되는 이메일은 “admin@kubeflow.org“이고, 패스워드는 “12341234”입니다.
이 정보를 이용해서 다음과 같은 화면에서 로그인할 수 있습니다.
만약, kubeflow를 외부망에 노출시킬것이라면, 꼭 이 기본 계정의 패스워드를 변경해야합니다.
패스워드 해시값 생성하기
패스워드 해시값은 다양한 방법으로 만들수 있습니다.
만약 파이썬을 사용하고 있다면 bcrypt 라이브러리를 사용할 수 있습니다.
다음은 bcrypt 패키지를 설치하고, “PASSWORD”의 해시값을 생성하는 예제입니다.
앞서 하이퍼 파라미터 튜닝에서 사용했던 메트릭 수집기는 기본 수집기인 StdOut 메트릭 수집기였습니다. 이번에는 StdOud 메트릭 수집기에 필터를 적용하는 방법과 TensorFlowEvent, File 그리고 Custom 메트릭 수집기에 대해서 알아보겠습니다.
StdOud 메트릭 수집기에 필터 적용하기
StdOut 메트릭 수집기에 필터를 적용하는 방법에 대해서 알아보겠습니다. 기존 예제에서는 StdOut 으로 출력되는 메트릭을 수집하기 위해서 {{MetricsName}}={{MetricsValue}} 형태로 출력을 하였습니다. 필터를 사용하면 메트릭을 나타내는 형식을 지정할 수 있기 때문에, 모델 학습시 출력되는 기본적인 로그를 그대로 사용할 수 있습니다.
로그를 보면, 메트릭이 “accuracy: 0.9055 “, “val_accuracy: 0.9574” 이런 형식으로 출력되는 것을 확인 할 수 있습니다. 필터에 {{MetricsName}}:{{MetricsValue}} 형식을 추가해서 기본 로그에서 메트릭을 추출하도록 하겠습니다. 형식은 go 언어의 정규표현식을 사용할 수 있습니다.
다음은 {{MetricsName}}:{{MetricsValue}} 형식을 필터로 사용하는 metricsCollectorSpec 입니다.
TensorFlowEvent 메트릭 수집기를 사용해 보겠습니다. TensorFlowEvent 메트릭 수집기는 텐서플로우에서 생성하는 이벤트를 추출해서 메트릭을 수집합니다. 그래서 기존의 텐서플로우 코드를 사용할 때 유용합니다. 다만 혀재는 텐서플로우 1 버전만을 지원하기 때문에, 텐서플로우 2 버전에 사용하기에는 약간의 문제가 있습니다.
다음은 TensorFlowEvent 메트릭 수집기를 사용하는 metricsCollectorSpec 입니다. fileSystemPath 필드를 사용해서 이벤트가 저장되어 있는 경로를 지정해 주어야합니다.
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import argparse
import os
import sys
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
FLAGS = None
def train():
# Import data
mnist = input_data.read_data_sets(FLAGS.data_dir,
fake_data=FLAGS.fake_data)
sess = tf.InteractiveSession()
# Create a multilayer model.
# Input placeholders
with tf.name_scope('input'):
x = tf.placeholder(tf.float32, [None, 784], name='x-input')
y_ = tf.placeholder(tf.int64, [None], name='y-input')
with tf.name_scope('input_reshape'):
image_shaped_input = tf.reshape(x, [-1, 28, 28, 1])
tf.summary.image('input', image_shaped_input, 10)
# We can't initialize these variables to 0 - the network will get stuck.
def weight_variable(shape):
"""Create a weight variable with appropriate initialization."""
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
def bias_variable(shape):
"""Create a bias variable with appropriate initialization."""
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)
def variable_summaries(var):
"""Attach a lot of summaries to a Tensor (for TensorBoard visualization)."""
with tf.name_scope('summaries'):
mean = tf.reduce_mean(var)
tf.summary.scalar('mean', mean)
with tf.name_scope('stddev'):
stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))
tf.summary.scalar('stddev', stddev)
tf.summary.scalar('max', tf.reduce_max(var))
tf.summary.scalar('min', tf.reduce_min(var))
tf.summary.histogram('histogram', var)
def nn_layer(input_tensor, input_dim, output_dim, layer_name, act=tf.nn.relu):
"""Reusable code for making a simple neural net layer.
It does a matrix multiply, bias add, and then uses ReLU to nonlinearize.
It also sets up name scoping so that the resultant graph is easy to read,
and adds a number of summary ops.
"""
# Adding a name scope ensures logical grouping of the layers in the graph.
with tf.name_scope(layer_name):
# This Variable will hold the state of the weights for the layer
with tf.name_scope('weights'):
weights = weight_variable([input_dim, output_dim])
variable_summaries(weights)
with tf.name_scope('biases'):
biases = bias_variable([output_dim])
variable_summaries(biases)
with tf.name_scope('Wx_plus_b'):
preactivate = tf.matmul(input_tensor, weights) + biases
tf.summary.histogram('pre_activations', preactivate)
activations = act(preactivate, name='activation')
tf.summary.histogram('activations', activations)
return activations
hidden1 = nn_layer(x, 784, 500, 'layer1')
with tf.name_scope('dropout'):
keep_prob = tf.placeholder(tf.float32)
tf.summary.scalar('dropout_keep_probability', keep_prob)
dropped = tf.nn.dropout(hidden1, keep_prob)
# Do not apply softmax activation yet, see below.
y = nn_layer(dropped, 500, 10, 'layer2', act=tf.identity)
with tf.name_scope('cross_entropy'):
# The raw formulation of cross-entropy,
#
# tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(tf.softmax(y)),
# reduction_indices=[1]))
#
# can be numerically unstable.
#
# So here we use tf.losses.sparse_softmax_cross_entropy on the
# raw logit outputs of the nn_layer above, and then average across
# the batch.
with tf.name_scope('total'):
cross_entropy = tf.losses.sparse_softmax_cross_entropy(
labels=y_, logits=y)
tf.summary.scalar('cross_entropy', cross_entropy)
with tf.name_scope('train'):
train_step = tf.train.AdamOptimizer(FLAGS.learning_rate).minimize(
cross_entropy)
with tf.name_scope('accuracy'):
with tf.name_scope('correct_prediction'):
correct_prediction = tf.equal(tf.argmax(y, 1), y_)
with tf.name_scope('accuracy'):
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
tf.summary.scalar('accuracy', accuracy)
# Merge all the summaries and write them out to
# /tmp/tensorflow/mnist/logs/mnist_with_summaries (by default)
merged = tf.summary.merge_all()
train_writer = tf.summary.FileWriter(FLAGS.log_dir + '/train', sess.graph)
test_writer = tf.summary.FileWriter(FLAGS.log_dir + '/test')
tf.global_variables_initializer().run()
# Train the model, and also write summaries.
# Every 10th step, measure test-set accuracy, and write test summaries
# All other steps, run train_step on training data, & add training summaries
def feed_dict(train): # pylint: disable=redefined-outer-name
"""Make a TensorFlow feed_dict: maps data onto Tensor placeholders."""
if train or FLAGS.fake_data:
xs, ys = mnist.train.next_batch(FLAGS.batch_size, fake_data=FLAGS.fake_data)
k = FLAGS.dropout
else:
xs, ys = mnist.test.images, mnist.test.labels
k = 1.0
return {x: xs, y_: ys, keep_prob: k}
for i in range(FLAGS.max_steps):
if i % 10 == 0: # Record summaries and test-set accuracy
summary, acc = sess.run([merged, accuracy], feed_dict=feed_dict(False))
test_writer.add_summary(summary, i)
print('Accuracy at step %s: %s' % (i, acc))
else: # Record train set summaries, and train
if i % 100 == 99: # Record execution stats
run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
summary, _ = sess.run([merged, train_step],
feed_dict=feed_dict(True),
options=run_options,
run_metadata=run_metadata)
train_writer.add_run_metadata(run_metadata, 'step%03d' % i)
train_writer.add_summary(summary, i)
print('Adding run metadata for', i)
else: # Record a summary
summary, _ = sess.run([merged, train_step], feed_dict=feed_dict(True))
train_writer.add_summary(summary, i)
train_writer.close()
test_writer.close()
def main(_):
if tf.gfile.Exists(FLAGS.log_dir):
tf.gfile.DeleteRecursively(FLAGS.log_dir)
tf.gfile.MakeDirs(FLAGS.log_dir)
train()
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--fake_data', nargs='?', const=True, type=bool,
default=False,
help='If true, uses fake data for unit testing.')
parser.add_argument('--max_steps', type=int, default=1000,
help='Number of steps to run trainer.')
parser.add_argument('--learning_rate', type=float, default=0.001,
help='Initial learning rate')
parser.add_argument('--batch_size', type=int, default=100,
help='Training batch size')
parser.add_argument('--dropout', type=float, default=0.9,
help='Keep probability for training dropout.')
parser.add_argument(
'--data_dir',
type=str,
default=os.path.join(os.getenv('TEST_TMPDIR', '/tmp'),
'tensorflow/mnist/input_data'),
help='Directory for storing input data')
parser.add_argument(
'--log_dir',
type=str,
default=os.path.join(os.getenv('TEST_TMPDIR', '/tmp'),
'tensorflow/mnist/logs/mnist_with_summaries'),
help='Summaries log directory')
FLAGS, unparsed = parser.parse_known_args()
tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)
모델 컨테이너 이미지 만들기
모델 학습용 컨테이너 이미지를 만들기 위해서 Dockerfile을 생성하겠습니다.
다음은 텐서플로우 1.11을 기반 이미지로 해서, 모델 파일을 추가하는 Dockerfile 입니다.
Dockerfile
FROM tensorflow/tensorflow:1.11.0
RUN mkdir -p /app
ADD mnist-with-summaries.py /app/
다음 명령어로 “kangwoo/mnist-simple:katib” 라는 이름으로 컨테이너 이미지를 빌드할 수 있습니다.
File 메트릭 수집기를 사용해 보겠습니다. File 메트릭 수집기는 파일로 출력되는 로그를 추출해서 메트릭을 수집합니다. File 메트릭 수집기도 필터를 사용하여 메트릭 형식을 지정할 수 있습니다. 메트릭 형식을 지정하지 않으면, 기본 형식인 “([\w|-]+)\s*=\s*((-?\d+)(\.\d+)?)” 즉 {{MetricsName}}={{MetricsValue}} 을 사용합니다.
다음은 File 메트릭 수집기를 사용하는 metricsCollectorSpec 입니다. fileSystemPath 필드를 사용해서 로그가 저장되어 있는 파일 경로를 지정해 주어야 합니다. 파일 경로를 지정하지 않으면 기본 경로인 “/var/log/katib/metrics.log”을 사용합니다.
하이퍼 파라미터는 모델 학습 프로세스를 제어하는 변수로서, 학습을 수행하기 위해 사전에 설정해야 하는 값들입니다. 예를 든다면 Learning rate, Batch Size, Regularization Strength 등이 있습니다.
하이퍼 파라미터 값은 학습되지 않습니다. 즉, 가중치 같은 학습 매개 변수와는 달리, 모델 학습 프로세스에서 하이퍼 파라미터 값을 조정하지 않습니다. 그래서 휴리스틱한 방법이나 경험 법칙에 의해서 결정하는 경우가 많습니다.
하이퍼 파라미터 튜닝은 최적의 하이퍼 파라미터 값을 탐색하여, 모델의 예측 정확도를 최대화하는 프로세스입니다. 만일 Katib 같은 자동화된 하이퍼 파라미터 튜닝 시스템이 없다면, 최적의 값을 찾기 위해 하이퍼 파라미터를 수동으로 조정하여, 많은 학습 작업을 사림이 직접 실행해야할것
자동화된 하이퍼 파라미터 튜닝 시스템은 대상의 목표 값을 이루기 위한 최적의 변수 값을 찾기 위해서 노력합니다. 일반적으로 모델의 정확성(accuracy)을 대상으로 사용합니다.
예를 들어 Katib의 다음 그래프는 다양한 하이퍼 파라미터 값의 조합 (learning_rate, dropout)에 따른 정확도를 보여 줍니다.
Katib는 Experiment이라 부르는 하이퍼 파라미터 튜닝 작업을 실행합니다. 실행된 Experiment는 Trial 이라고 부르는 학습 작업을 여러번 실행합니다.
random 알고리즘과 job을 이용한 하이퍼 파라미터 튜닝
하이퍼 파라미터 튜닝에 사용할 학습 모델 컨테이너 이미지를 만들어 보겠습니다.
모델 코드 작성하기
mnist 숫자를 판별하는 모델을 텐서플로우 케라스로 작성해 보겠습니다.
하이퍼 파라메터를 입력 받기 위해서 argparse 라이브러를 이용하였습니다. learning_rate와 dropout 값을 입력할 수 있습니다.
parser = argparse.ArgumentParser()
parser.add_argument('--learning_rate', default=0.01, type=float)
parser.add_argument('--dropout', default=0.2, type=float)
args = parser.parse_args()
케라스의 콜백을 이용해서, 매 에폭(epoch)마다 accuracy, loss, Validation-accuracy 그리고 Validation-loss를 StdOut 으로 출력하도록 하였습니다. Katib의 StdOutCollector를 사용해서 메트릭을 수집할 것이기 때문에, StdOut으로 {{MetricsName}}={{MetricsValue}} 형태로 메트릭을 StdOut 으로 출력하면 됩니다. 그리고 라인의 맨 앞부분에 RFC-3339 형식의 시간을 출력하면, 메트릭의 시간도 같이 수집이 됩니다.
katib_metric_log_callback = KatibMetricLog()
training_history = model.fit(x_train, y_train, batch_size=64, epochs=10,
validation_data=(x_val, y_val),
callbacks=[katib_metric_log_callback])
…
class KatibMetricLog(tf.keras.callbacks.Callback):
def on_epoch_end(self, epoch, logs=None):
# RFC 3339
local_time = datetime.now(timezone.utc).astimezone().isoformat()
print(“\nEpoch {}”.format(epoch+1))
print(“{} accuracy={:.4f}”.format(local_time, logs[‘acc’]))
print(“{} loss={:.4f}”.format(local_time, logs[‘loss’]))
print(“{} Validation-accuracy={:.4f}”.format(local_time, logs[‘val_acc’]))
print(“{} Validation-loss={:.4f}”.format(local_time, logs[‘val_loss’]))
grid 알고리즘을 사용하여 하이퍼 파리미터 튜닝을 해 보겠습니다. 모델 컨테이너 이미지는 radnom 하이퍼 파라미터 튜닝에서 사용한 kangwoo/mnist:katib 을 그대로 사용하겠습니다.
grid 알고리즘을 사용하려면 algorithmName 필드에 grid 라고 설정하면 됩니다.
algorithm:
algorithmName: grid
주의해할 점은 categorical 타입의 파라미터는 지원하지 않습니다. 그래서 다음과 같은 파라미터는 사용할 수 없습니다
parameters:
# Grid doesn't support categorical, refer to <https://chocolate.readthedocs.io/api/sample.html#chocolate.Grid>
- name: --optimizer
parameterType: categorical
feasibleSpace:
list:
- sgd
- adam
- ftrl
그리고 double 타입의 파라미터를 사용할 때는 step을 정의해줘야 합니다. 값을 얼마만큼의 간격으로 증가시킬지를 지정하는 것입니다. int 타입의 파라미터인 경우에도 setup 값을 정의할 수 있습니다. int 타입인 경우 별도로 정의하지 않으면 기본값인 1일 사용합니다.
hyperband 알고리즘을 사용하여 하이퍼 파리미터 튜닝을 해 보겠습니다. 모델 컨테이너 이미지는 radnom 하이퍼 파라미터 튜닝에서 사용한 kangwoo/mnist:katib 을 그대로 사용하겠습니다.
r_l and resource_name must be set.
r_l must be a positive float number.
if "eta" in setting_dict:
eta = int(float(setting_dict["eta"]))
if eta <= 0:
eta = 3
else:
eta = 3
smax = int(math.log(rl)/math.log(eta))
max_parallel = int(math.ceil(eta**smax))
if request.experiment.spec.parallel_trial_count < max_parallel:
return self._set_validate_context_error(context,
"parallelTrialCount must be not less than %d." % max_parallel)
parallel_trial_count 는 eta**log(rl)/log(eta) 값보다 커야 합니다.
hyperband 알고리즘을 사용하려면 algorithmName 필드에 hyperband 라고 설정하면 됩니다. 그리고 algorithmSettings 필드를 사용해서 알고리즘을 설정할 수 있습니다.
Katib는 Kubeflow 컴포넌트로서, 하이퍼 파라미터(Hyperparameter) 튜닝 및 신경망 아키텍처 탐색(Neural Architecture Search)을 위한 쿠버네티스 기반의 시스템입니다. Katib는 TensorFlow, PyTorch, Apache MXNet, XGBoost 등 다양한 머신러닝 프레임워크를 지원합니다.
Kubeflow의 컴포넌트인 Katib 시스템에 대해서 이해하고, 하이퍼 파라미터 튜닝하는 방법에 대해서 알아 보도록 하겠습니다. 예제에 사용한 Katib 버전은 0.8 입니다.
Katib의 개념
Katib에는 실험(Experiment), 제안(Suggestion), 시도(Trial) 및 작업(Job) 이라는 개념이 있습니다.
Experiment
Experiment 란 목표로 하는 대상 값을 찾기 위해서, 하이퍼 파라미터 값들을 찾는 일련의 탐색 작업을 의미합니다. Experiment에는 다음과 같은 구성 요소가 포함되어 있습니다
목표 (Objective) : 하이퍼 파라미터 튜닝 작업 통해서, 이루고자 하는 목표를 정의해야 합니다. 예를 든다면, 모델의 정확성(accuracy)의 최대값을 0.91 로 목표로 한다고 정의할 수 있습니다
탐색 범위 (Search Space) : 하이퍼 파라미터 튜닝 작업시 사용해야 할 모든 하이퍼 파라미터 값과 하이퍼 파라미터의 제약 조건을 정의해야 합니다. 예를 든다면, Learning rate는 0.1부터 0.5까지의 값을 사용하고, optimizer는 sgd와 adam을 사용한다고 정의할 수 있습니다.
탐색 알고리즘 (Search Algorithm) : 하이퍼 파라미터 튜닝 작업시 사용할 알고리즘을 정의해야 합니다. Random Search, Grid Search, Bayesian Optimization 등 다용한 알고리즘을 사용할 수 있습니다.
Katib를 사용해서 최적의 하이퍼 파라미터를 찾으려면, Experiment 라는 사용자 리소스를 생성하면 됩니다.
Suggestion
Katib는 각 Experiment 사용자 리소스 마다 하나의 Suggestion 사용자 리소스를 생성합니다. Suggestion 은 탐색 알고리즘이 제안한 하이퍼 파라미터 값들의 세트를 가지고 있습니다. Katib 는 제안된 하이퍼 파라미터 값들을 세트별로 평가하기 위한 Trial을 작성합니다.
Trial
Trial은 제안된 하이퍼 파리미터 값들을 평가하기 위한 하나의 작업을 의미하는 사용자 리소스입니다. 제안된 매개 변수 값들을 Woker Job 인스턴스 할당해서 실행합니다.
각 Experiment 는 여러 번의 Trial을 수행합니다. Experiment 는 목표나 설정한 최대 시도 횟수에 도달 할 때까지 Trial 을 계속 실행합니다.
Worker Job
Worker Job은 Trial을 평가하고 목표 값을 계산하는 프로세스를 의미합니다. 제안된 하이퍼 파라미터 값들을 넘겨 받아서 실제로 모델을 학습하게 됩니다.
다음은 사용 가능한 Worker Job의 유형입니다.
Kubernetes Job
Kubeflow TFJob (분산 처리 지원)
Kubeflow PyTorchJob (분산 처리 지원)
Metrics Collector
하이퍼 파라미터 튜닝 작업 통해서, 목표로 하는 대상 값을 찾기 위해서는 대상 값을 수집하고 저장해야 합니다. Katib에서는 이러한 메트릭들을 저장하기 위해서 Metrics Collector를 사용합니다.
Job, TFJob, PytorchJob 등과 같은 실제 모델 학습을 진행하는 포드가 실행 될 때, 학습에 관련된 결과 값들을 수집하기 위해서 Metrics Collector가 포함된 Collector 컨테이너를 사이드카로 포드에 주입합니다. Collector 컨테이너는 메트릭 소스의 구문을 분석하여, Worker 컨테이너의 메트릭을 수집하고 Katib-manager의 katib-db 와 같은 영구 저장소에 메트릭을 저장합니다.
Katib에서 지원하고 있는 Metrics Collector는 다음과 같습니다.
StdOut : 운영 체제의 기본 출력인 StdOut으로 출력되는 메트릭을 수집합니다. 별도의 수집기를 정의하지 않으면 StdOut가 사용됩니다.
File : 지정한 파일을 이용해서 메트릭을 수집합니다. source 필드에 경로를 지정해야합니다.
TensorFlowEvent : 지정한 디렉토리에 저장된 tf.Event 를 이용해서 메트릭을 수집합니다. 현재는 텐서플로우 1 버전만 지원합니다. source 필드에 경로를 지정해야합니다.
Custom : 사용자가 정의한 메트릭 수집기를 사용합니다.
None : Katib의 메트릭 수집기를 사용하지 않을 때 사용합니다.
탐색 알고리즘
Katib에서 제공하는 탐색 알고리즘은 다음과 같습니다.
Hyperparameter Tuning
Grid Search (grid) : 그리드 탐색은 하이퍼 파라미터 최적화를 수행하는 전통적인 방법 중 하나로서, 하이퍼 파라미터 공간에서 수동으로 지정한 하위 집합을 모두 조합해서 전부 탐색하는 것을 말합니다. 이러한 작업은 학습 세트에 대한 교차 검증(cross-validation)이나 보류(held-out) 된 검증 세트에 대한 평가에 따라 진행됩니다. 균등한 공간의 시작점들로부터 시작해서, 이 점들의 목적 함수 값(objective functions)을 계산하여 최적의 조합을 선택하게 됩니다. 그리드 탐색은 모든 가능성에 대해 탐색을 수행하기 때문에, 중간 규모의 문제에 대해서도 탐색 프로세스를 매우 길게 만듭니다. 그래서 그리드 탐색은 만들어낼 수 있는 파라미터들의 탐색 조합이 적은 경우에만 유용하게 사용할 수 있습니다.
Random Search (random) : 무작위 탐색은 그리드 탐색의 대안으로서, 조합할 수 있는 파라미터의 수가 많을 때 사용하면 좋습니다. 무작위 탐색은 무작위로 파라미터를 선택하여 조합을 만들어냅니다. 하이퍼 파라미터 공간에서 수동으로 하위 집합을 지정할 필요가 없기 때문에 간단하게 적용 할 수 있습니다. 그렇기 때문에 무작위 탐색은 모든 가능성에 대한 탐색이 불가능할 때 사용하기 좋은 알고리즘입니다. Katib는 hyperopt 라는 최적화 프레임워크를 사용해서 무작위 탐색 알고리즘을 지원합니다.
Tree of Parzen Estimators (tpe) : Katib 는 hyperopt 를 사용해서 Tree of Parzen Estimators (TPE) 알고리즘을 지원합니다 . 이 방법은 “정방향 및 역방향 그라디언트 기반” 탐색을 제공합니다.
Hyperband (hyperbadn): 하이퍼밴드는 반복 알고리즘을 조정하는 비교적 새로운 방법으로서, 최적화 탐색 속도에 중점을 두었습니다. 리소스 할당을 최적화하여 평가 할 수 있는 조합의 수를 최대화 합니다. 그래서 빠르게 목적에 도달해서 해서 조기 중지(early stopping)에 이르게 하고 있습니다.
Bayesian Optimization (skopt-bayesian-optimization) : ‘베이지안 최적화’방법은 가우시안 프로세스 회귀를 사용하여 탐색 공간을 모델링합니다. 이 기법은 탐색 공간의 모든 지점에서 손실 함수의 추정치와 해당 추정치의 불확실성을 계산합니다. 즉, 현재 모델을 기반으로 유망한 하이퍼 파라미터 구성을 반복적으로 평가해서, 최적의 위치에 대한 정보를 나타내는 관측치를 수집하는 등의 확률적 추정 결과를 바탕으로 최적의 값을 찾습니다. 이 방법은 탐색 공간의 차원 수가 적은 경우에 적합합니다. 이 방법은 예상 손실과 불확실성을 모두 모델링하므로 탐색 알고리즘이 몇 단계로 수렴되므로 , 매개 변수 구성 평가를 완료하는 데 시간이 오래 걸릴 경우 사용하면 좋습니다. Katib는 Scikit-Optimize (skopt) 라는 라이브러리를 사용해서 베이지안 탐색을 지원합니다.
