hyperparameter_hunter
v3.0.0 (Artemis)
บันทึกและเรียนรู้จากผลการทดลองโดยอัตโนมัติซึ่งนำไปสู่การเพิ่มประสิทธิภาพระยะยาวและต่อเนื่องซึ่งจำการทดสอบทั้งหมดของคุณ
HyperParameterhunter จัดเตรียมเครื่องห่อหุ้มสำหรับอัลกอริทึมการเรียนรู้ของเครื่องที่บันทึกข้อมูลสำคัญทั้งหมด ลดความซับซ้อนของกระบวนการทดลองและไฮเปอร์พารามิเตอร์โดยปล่อยให้ Hyperparameterhunter ทำงานอย่างหนักในการบันทึกการจัดระเบียบและการเรียนรู้จากการทดสอบของคุณ - ทั้งหมดในขณะที่ใช้ไลบรารีเดียวกันกับที่คุณทำอยู่แล้ว อย่าปล่อยให้การทดลองใด ๆ ของคุณหายไปและเริ่มทำการเพิ่มประสิทธิภาพพารามิเตอร์ hyperparameter ตามที่มันตั้งใจไว้
pip install hyperparameter-hunterอย่าคิดว่า Hyperparameterhunter เป็นไลบรารีการเพิ่มประสิทธิภาพอื่นที่คุณนำออกมาเฉพาะเมื่อถึงเวลาที่จะทำการเพิ่มประสิทธิภาพ hyperparameter แน่นอนว่ามันเป็นการเพิ่มประสิทธิภาพ แต่ดีกว่าที่จะดู Hyperparameterhunter เป็นกล่องเครื่องมือ/ผู้ช่วยการเรียนรู้ของเครื่องส่วนตัวของคุณเอง
แนวคิดคือการเริ่มใช้ Hyperparameterhunter ทันที เรียกใช้การทดลองมาตรฐาน/การทดลองครั้งเดียวของคุณผ่านมัน
ยิ่งคุณใช้ Hyperparameterhunter มากเท่าไหร่ผลลัพธ์ของคุณก็จะยิ่งดีขึ้นเท่านั้น หากคุณเพิ่งใช้เพื่อการเพิ่มประสิทธิภาพแน่นอนว่ามันจะทำในสิ่งที่คุณต้องการ แต่นั่นก็ขาดจุด Hyperparameterhunter
หากคุณใช้มันเพื่อการทดลองและการปรับให้เหมาะสมตลอดหลักสูตรทั้งหมดของโครงการของคุณเมื่อคุณตัดสินใจที่จะทำการเพิ่มประสิทธิภาพ hyperparameter Hyperparameterhunter ได้ตระหนักถึงสิ่งที่คุณทำอยู่แล้วและนั่นคือเมื่อ Hyperparameterhunter ทำสิ่งที่น่าทึ่ง มันไม่ได้เริ่มต้นการเพิ่มประสิทธิภาพตั้งแต่เริ่มต้นเหมือนห้องสมุดอื่น ๆ มันเริ่มต้นจากการทดลองทั้งหมดและรอบการเพิ่มประสิทธิภาพก่อนหน้านี้ที่คุณผ่านมาแล้ว
ตั้งค่าสภาพแวดล้อมเพื่อจัดระเบียบการทดลองและผลการปรับให้เหมาะสม
การทดลองหรือการเพิ่มประสิทธิภาพรอบใด ๆ ที่เราดำเนินการจะใช้สภาพแวดล้อมที่ใช้งานอยู่ของเรา
from hyperparameter_hunter import Environment , CVExperiment
import pandas as pd
from sklearn . datasets import load_breast_cancer
from sklearn . model_selection import StratifiedKFold
data = load_breast_cancer ()
df = pd . DataFrame ( data = data . data , columns = data . feature_names )
df [ 'target' ] = data . target
env = Environment (
train_dataset = df , # Add holdout/test dataframes, too
results_path = 'path/to/results/directory' , # Where your result files will go
metrics = [ 'roc_auc_score' ], # Callables, or strings referring to `sklearn.metrics`
cv_type = StratifiedKFold , # Class, or string in `sklearn.model_selection`
cv_params = dict ( n_splits = 5 , shuffle = True , random_state = 32 )
)ทำการทดลองกับห้องสมุดที่คุณชื่นชอบเพียงแค่จัดหาเครื่องเริ่มต้นแบบจำลองและไฮเปอร์พารามิเตอร์
# Same format used by `keras.wrappers.scikit_learn`. Nothing new to learn
def build_fn ( input_shape ): # `input_shape` calculated for you
model = Sequential ([
Dense ( 100 , kernel_initializer = 'uniform' , input_shape = input_shape , activation = 'relu' ),
Dropout ( 0.5 ),
Dense ( 1 , kernel_initializer = 'uniform' , activation = 'sigmoid' )
]) # All layer arguments saved (whether explicit or Keras default) for future use
model . compile ( optimizer = 'adam' , loss = 'binary_crossentropy' , metrics = [ 'accuracy' ])
return model
experiment = CVExperiment (
model_initializer = KerasClassifier ,
model_init_params = build_fn , # We interpret your build_fn to save hyperparameters in a useful, readable format
model_extra_params = dict (
callbacks = [ ReduceLROnPlateau ( patience = 5 )], # Use Keras callbacks
batch_size = 32 , epochs = 10 , verbose = 0 # Fit/predict arguments
)
) experiment = CVExperiment (
model_initializer = LinearSVC , # (Or any of the dozens of other SK-Learn algorithms)
model_init_params = dict ( penalty = 'l1' , C = 0.9 ) # Default values used and recorded for kwargs not given
) experiment = CVExperiment (
model_initializer = XGBClassifier ,
model_init_params = dict ( objective = 'reg:linear' , max_depth = 3 , n_estimators = 100 , subsample = 0.5 )
) experiment = CVExperiment (
model_initializer = LGBMClassifier ,
model_init_params = dict ( boosting_type = 'gbdt' , num_leaves = 31 , max_depth = - 1 , min_child_samples = 5 , subsample = 0.5 )
) experiment = CVExperiment (
model_initializer = CatboostClassifier ,
model_init_params = dict ( iterations = 500 , learning_rate = 0.01 , depth = 7 , allow_writing_files = False ),
model_extra_params = dict ( fit = dict ( verbose = True )) # Send kwargs to `fit` and other extra methods
) experiment = CVExperiment (
model_initializer = RGFClassifier ,
model_init_params = dict ( max_leaf = 1000 , algorithm = 'RGF' , min_samples_leaf = 10 )
)เช่นเดียวกับการทดลอง แต่ถ้าคุณต้องการเพิ่มประสิทธิภาพไฮเปอร์พารามิเตอร์ให้ใช้คลาสที่นำเข้าด้านล่าง
from hyperparameter_hunter import Real , Integer , Categorical
from hyperparameter_hunter import optimization as opt def build_fn ( input_shape ):
model = Sequential ([
Dense ( Integer ( 50 , 150 ), input_shape = input_shape , activation = 'relu' ),
Dropout ( Real ( 0.2 , 0.7 )),
Dense ( 1 , activation = Categorical ([ 'sigmoid' , 'softmax' ]))
])
model . compile (
optimizer = Categorical ([ 'adam' , 'rmsprop' , 'sgd' , 'adadelta' ]),
loss = 'binary_crossentropy' , metrics = [ 'accuracy' ]
)
return model
optimizer = opt . RandomForestOptPro ( iterations = 7 )
optimizer . forge_experiment (
model_initializer = KerasClassifier ,
model_init_params = build_fn ,
model_extra_params = dict (
callbacks = [ ReduceLROnPlateau ( patience = Integer ( 5 , 10 ))],
batch_size = Categorical ([ 32 , 64 ]),
epochs = 10 , verbose = 0
)
)
optimizer . go () optimizer = opt . DummyOptPro ( iterations = 42 )
optimizer . forge_experiment (
model_initializer = AdaBoostClassifier , # (Or any of the dozens of other SKLearn algorithms)
model_init_params = dict (
n_estimators = Integer ( 75 , 150 ),
learning_rate = Real ( 0.8 , 1.3 ),
algorithm = 'SAMME.R'
)
)
optimizer . go () optimizer = opt . BayesianOptPro ( iterations = 10 )
optimizer . forge_experiment (
model_initializer = XGBClassifier ,
model_init_params = dict (
max_depth = Integer ( low = 2 , high = 20 ),
learning_rate = Real ( 0.0001 , 0.5 ),
n_estimators = 200 ,
subsample = 0.5 ,
booster = Categorical ([ 'gbtree' , 'gblinear' , 'dart' ]),
)
)
optimizer . go () optimizer = opt . BayesianOptPro ( iterations = 100 )
optimizer . forge_experiment (
model_initializer = LGBMClassifier ,
model_init_params = dict (
boosting_type = Categorical ([ 'gbdt' , 'dart' ]),
num_leaves = Integer ( 5 , 20 ),
max_depth = - 1 ,
min_child_samples = 5 ,
subsample = 0.5
)
)
optimizer . go () optimizer = opt . GradientBoostedRegressionTreeOptPro ( iterations = 32 )
optimizer . forge_experiment (
model_initializer = CatBoostClassifier ,
model_init_params = dict (
iterations = 100 ,
eval_metric = Categorical ([ 'Logloss' , 'Accuracy' , 'AUC' ]),
learning_rate = Real ( low = 0.0001 , high = 0.5 ),
depth = Integer ( 4 , 7 ),
allow_writing_files = False
)
)
optimizer . go () optimizer = opt . ExtraTreesOptPro ( iterations = 10 )
optimizer . forge_experiment (
model_initializer = RGFClassifier ,
model_init_params = dict (
max_leaf = 1000 ,
algorithm = Categorical ([ 'RGF' , 'RGF_Opt' , 'RGF_Sib' ]),
l2 = Real ( 0.01 , 0.3 ),
normalize = Categorical ([ True , False ]),
learning_rate = Real ( 0.3 , 0.7 ),
loss = Categorical ([ 'LS' , 'Expo' , 'Log' , 'Abs' ])
)
)
optimizer . go () นี่เป็นภาพประกอบง่ายๆของโครงสร้างไฟล์ที่คุณสามารถคาดหวังได้ว่า Experiment ของคุณจะสร้าง สำหรับคำอธิบายเชิงลึกของโครงสร้างไดเรกทอรีและเนื้อหาของไฟล์ต่าง ๆ ดูส่วนภาพรวมโครงสร้างไฟล์ในเอกสาร อย่างไรก็ตามสิ่งจำเป็นมีดังนี้:
Experiment เพิ่มไฟล์ให้กับไดเรกทอรี experiment_id /hyperparameterhunterassets/ExperimentExperiment แต่ละครั้งยังเพิ่มรายการไปยัง HyperParameterhunterassets/Leadyboards/globalleaderboard.csvfile_blacklist ของ Environment และ do_full_save KWARGS (บันทึกไว้ที่นี่) HyperparameterHunterAssets
| Heartbeat.log
|
└───Experiments
| |
| └───Descriptions
| | | <Files describing Experiment results, conditions, etc.>.json
| |
| └───Predictions<OOF/Holdout/Test>
| | | <Files containing Experiment predictions for the indicated dataset>.csv
| |
| └───Heartbeats
| | | <Files containing the log produced by the Experiment>.log
| |
| └───ScriptBackups
| | <Files containing a copy of the script that created the Experiment>.py
|
└───Leaderboards
| | GlobalLeaderboard.csv
| | <Other leaderboards>.csv
|
└───TestedKeys
| | <Files named by Environment key, containing hyperparameter keys>.json
|
└───KeyAttributeLookup
| <Files linking complex objects used in Experiments to their hashes>
pip install hyperparameter-hunter
หากคุณชอบอยู่ในช่วงล้ำสมัยและคุณต้องการการพัฒนาล่าสุดทั้งหมดรัน:
pip install git+https://github.com/HunterMcGushion/hyperparameter_hunter.git
หากคุณต้องการมีส่วนร่วมใน Hyperparameterhunter เริ่มต้นที่นี่
ไม่เป็นไร อย่ารู้สึกแย่ มันแปลกนิดหน่อยที่จะโอบศีรษะไปรอบ ๆ นี่คือตัวอย่างที่แสดงให้เห็นว่าทุกอย่างเกี่ยวข้องกันอย่างไร:
from hyperparameter_hunter import Environment , CVExperiment , BayesianOptPro , Integer
from hyperparameter_hunter . utils . learning_utils import get_breast_cancer_data
from xgboost import XGBClassifier
# Start by creating an `Environment` - This is where you define how Experiments (and optimization) will be conducted
env = Environment (
train_dataset = get_breast_cancer_data ( target = 'target' ),
results_path = 'HyperparameterHunterAssets' ,
metrics = [ 'roc_auc_score' ],
cv_type = 'StratifiedKFold' ,
cv_params = dict ( n_splits = 10 , shuffle = True , random_state = 32 ),
)
# Now, conduct an `Experiment`
# This tells HyperparameterHunter to use the settings in the active `Environment` to train a model with these hyperparameters
experiment = CVExperiment (
model_initializer = XGBClassifier ,
model_init_params = dict (
objective = 'reg:linear' ,
max_depth = 3
)
)
# That's it. No annoying boilerplate code to fit models and record results
# Now, the `Environment`'s `results_path` directory will contain new files describing the Experiment just conducted
# Time for the fun part. We'll set up some hyperparameter optimization by first defining the `OptPro` (Optimization Protocol) we want
optimizer = BayesianOptPro ( verbose = 1 )
# Now we're going to say which hyperparameters we want to optimize.
# Notice how this looks just like our `experiment` above
optimizer . forge_experiment (
model_initializer = XGBClassifier ,
model_init_params = dict (
objective = 'reg:linear' , # We're setting this as a constant guideline - Not one to optimize
max_depth = Integer ( 2 , 10 ) # Instead of using an int like the `experiment` above, we provide a space to search
)
)
# Notice that our range for `max_depth` includes the `max_depth=3` value we used in our `experiment` earlier
optimizer . go () # Now, we go
assert experiment . experiment_id in [ _ [ 2 ] for _ in optimizer . similar_experiments ]
# Here we're verifying that the `experiment` we conducted first was found by `optimizer` and used as learning material
# You can also see via the console that we found `experiment`'s saved files, and used it to start optimization
last_experiment_id = optimizer . current_experiment . experiment_id
# Let's save the id of the experiment that was just conducted by `optimizer`
optimizer . go () # Now, we'll start up `optimizer` again...
# And we can see that this second optimization round learned from both our first `experiment` and our first optimization round
assert experiment . experiment_id in [ _ [ 2 ] for _ in optimizer . similar_experiments ]
assert last_experiment_id in [ _ [ 2 ] for _ in optimizer . similar_experiments ]
# It even did all this without us having to tell it what experiments to learn from
# Now think about how much better your hyperparameter optimization will be when it learns from:
# - All your past experiments, and
# - All your past optimization rounds
# And the best part: HyperparameterHunter figures out which experiments are compatible all on its own
# You don't have to worry about telling it that KFold=5 is different from KFold=10,
# Or that max_depth=12 is outside of max_depth=Integer(2, 10) นี่คือบางสิ่งที่อาจ "getcha"
OptPro ได้หรือไม่?CVExperiment ก่อนที่จะเริ่มต้น OptPro ของคุณExperiment พอดีภายในพื้นที่การค้นหาที่กำหนดโดย OptPro ของคุณเครื่องมือเพิ่มประสิทธิภาพจะค้นหาและอ่านในผลลัพธ์ของ ExperimentExperiment หลังจากที่คุณทำครั้งเดียวเนื่องจากผลลัพธ์ได้รับการบันทึก การทิ้งไว้จะมีเพียง Experiment เดียวกันซ้ำแล้วซ้ำอีกActivation แยกต่างหากและจัดหาเลเยอร์ Dense ด้วย activation KwargDense(10, activation='sigmoid')Dense(10); Activation('sigmoid')Activation แยกต่างหากหรือให้ activation kwargs กับเลเยอร์อื่น ๆ และติดกับมัน!model.compile อาร์กิวเมนต์คอมไพล์: optimizer และ optimizer_params ในเวลาเดียวกัน?optimizers ของ Keras คาดว่าจะมีข้อโต้แย้งที่แตกต่างกันoptimizer=Categorical(['adam', 'rmsprop']) มีคำสั่งที่แตกต่างกันสองประการของ optimizer_params ที่เป็นไปได้optimizer และ optimizer_params แยกกันoptimizer_params ด้วยวิธีนี้แต่ละ optimizer จะใช้พารามิเตอร์เริ่มต้นoptimizer ที่ดีที่สุดและตั้งค่า optimizer=<best optimizer> จากนั้นไปยังการปรับแต่ง optimizer_params โดยมีอาร์กิวเมนต์เฉพาะกับ optimizer ที่คุณเลือก__init__ มีการกำหนดที่อื่นและค่าตัวยึดตำแหน่งของ None ในลายเซ็นของพวกเขาNone จริงหากคุณไม่ได้ให้ค่าสำหรับอาร์กิวเมนต์นั้นอย่างชัดเจน
