مع النماذج الرائعة ، تأتي المشكلة الكبيرة المتمثلة في تحسين مُدخلات الضبط (Hyperparameter) للحصول على أفضل نتيجة للنموذج. إذن ، ما هو تحسين مُدخلات الضبط؟ 

تحسين مُدخلات الضبط؟

افترض أن هناك خط إنتاج بسيطًا لمشروع التعلم الآلي الخاص بك. توجد مجموعة بيانات ، تقوم بتطبيق النموذج مباشرةً ، ثم تحصل على النتائج. تُعرف المعايير (parameters) التي يمتلكها النموذج هنا مُدخلات الضبط (Hyperparameter) ، أي المعايير التي تتحكم في عملية التدريب / الملائمة للنموذج.

إذا قمنا بتدريب الانحدار الخطي (linear regression) باستخدام SGD ، فإن معايير النموذج هي ميل المستقيم (Slope

) و الإنحياز (Bias) و مُدخل الضبط هو مُعدل التعلم. 

لنفترض أن هناك ثلاث معايير أ ، ب ، ج في النموذج ، ويمكن أن تكون كل هذه المعايير أعدادًا صحيحة بين 1 و 10. سيوفر لك الخليط “الصحيح” من هذه المعايير أفضل نتيجة. لذا ، فهي تشبه حقيبة السفر بقفل مكون من 3 أقراص. و الإختلاف هو أن القفل المكون من 3 أقراص لديه إجابة واحدة صحيحة فقط. أما النموذج فلديه العديد من الإجابات الصحيحة. 

لذا ، كيف تجد أفضل المعايير؟ تتمثل إحدى الطرق في تقييم جميع التركيبات ومعرفة أي منها يعمل على تحسين المقياس. 

دعونا نرى كيف يتم ذلك.

# حدد أفضل دقة لتكون 0
# إذا اخترت الخسارة كمقياس ،
# (np.inf) inf يمكنك تحقيق أفضل خسارة لتكون  

best_accuracy = 0 

best_parameters = {"a": 0, "b": 0 , "c": 0}

# a, b, c إنشاء حلقة لكل القيم

for a in range(1, 11):
    for b in range(1, 11):
        for c in range(1, 11):
            #تهيئة النموذج مع المعايير الحالية 
            model = MODEL(a, b, c)

            #مناسبة بيانات التدريب
            model.fit(training_data)

            #القيام  بالتنبوات 
            preds = model.predict(validation_data)

            #حساب الدقة
            accuracy = metrics.accuracy_score(target, preds)

            # الإحتفاظ بالمعايير لو كانت الدقة
            # أكبر من أفضل دقة
            if accuracy > best_accuracy:
                best_accuracy = accuracy
                best_accuracy["a"] = a
                best_accuracy["b"] = b 
                best_accuracy["c"] = c

في الكود أعلاه ، نمر على جميع المعايير من 1 إلى 10. لذا ، لدينا إجمالي 1000 (10 × 10 × 10) تناسب للنموذج. حسنًا ، قد يكون هذا مكلفًا لأن النموذج قد يستغرق وقتًا طويلاً للتدريب. في هذه الحالة ،لا بأس بذلك، ولكن في سيناريو العالم الحقيقي ، لا توجد ثلاثة معايير فقط وليس فقط عشر قيم لكل معايير. معظم معايير النماذج لها قيمة حقيقية ، ويمكن أن تكون خليط المعايير المختلفة غير محدودة. 

دعونا نلقي نظرة على نموذج الغابة العشوائية من scikit-Learn.

RandomForestClassifier(
 n_estimators=100,
 criterion='gini',
 max_depth=None,
 min_samples_split=2,
 min_samples_leaf=1,
 min_weight_fraction_leaf=0.0,
 max_features='auto',
 max_leaf_nodes=None,
 min_impurity_decrease=0.0,
 min_impurity_split=None,
 bootstrap=True,
 oob_score=False,
 n_jobs=None,
 random_state=None,
 verbose=0,
 warm_start=False,
 class_weight=None,
 ccp_alpha=0.0,
 max_samples=None,
)

هناك تسعة عشر معييار، وسيكون خليط كل هذه المعايير لجميع القيم التي يمكن أن تفترضها لا نهائية. في العادة ، ليس لدينا الموارد والوقت للقيام بذلك. وبالتالي ، نحدد شبكة (grid) من المعايير. يُعرف البحث عبر هذه الشبكة للعثور على أفضل مجموعة من المعايير باسم بحث الشبكة (grid search) .

بحث الشبكة

يمكننا القول أن n_estimators يمكن أن تكون 100 ، 200 ، 250 ، 300 ، 400 ، 500 ؛ يمكن أن يكون max_depth هو 1 ، 2 ، 5 ، 7 ، 11 ، 15 ويمكن أن يكون criterion أما gini أو entropy. قد لا تبدو هذه الكثير من المعايير ، ولكن الأمر سيستغرق الكثير من الوقت للحساب إذا كانت مجموعة البيانات كبيرة جدًا. يمكننا أن نجعل بحث الشبكة هذا يعمل عن طريق إنشاء ثلاث حلقات for loops . وحساب النتيجة على مجموعة التحقق لدينا ،  وتجدر الإشارة أيضًا إلى أنه إذا كان لديك التحقق المتقاطع  kfold ، فستحتاج إلى المزيد من الحلقات مما يعني مزيدًا من الوقت للعثور على المعايير المثالية

لذلك لا يحظى بحث الشبكة بشعبية كبيرة. دعونا نلقي نظرة على كيفية القيام بذلك من خلال مثال للتنبؤ بنطاق سعر الهاتف المحمول بالنسبة بالمواصفات.

لدينا 20 ميزة مثل بطاقة SIM مزدوجة ، وطاقة البطارية ، وما إلى ذلك ، ومجموعة أسعار بها 4 فئات من 0 إلى 3. هناك 2000 عينة فقط في مجموعة التدريب. يمكننا بسهولة استخدام kfold الطبقي و الدقة كمقياس للتقييم. سنستخدم نموذج الغابة العشوائية (random forest model)  مع نطاقات المعايير المذكورة أعلاه ونرى كيف يمكننا إجراء بحث الشبكة في المثال التالي.

import numpy as np
import pandas as pd

from sklearn import ensemble
from sklearn import  metrics
from sklearn import model_selection


#  قراءة ملف التدريب
df = pd.read_csv("../input/mobile_train.csv")

# prince_range  السمات هي كل الأعمدة ما عدا
# لاحظ أنه لا يوجد عمود معرف في مجموعة البيانات 
# هنا لدينا سمات التدريب 
X = df.drop("price_range", axis=1).values
# أما الأهداف
y = df.price_range.values

#تعريف النموذج
#  n_jobs=-1 سنستخدم الغابة العشوائية مع 
classifier = ensemble.RandomForestClassifier(n_jobs=-1)

# تعريق شبكة من المعايير 
# يمكن أن تكون قاموس أو قائمة قاموس
param_grid = {
    "n_estimators" : [ 100, 200, 250, 300, 400, 500],
    "max_depth" : [1, 2, 5, 7, 11, 15],
    "criterion": ["gini", "entropy"]
}

# تهيئة بحث الشبكة
# هو النموذج الذي حددناه estimator   
# هي شبكة المعلمات param_grid 
# نحن نستخدم الدقة كمقياس لدينا. يمكنك تحديد الخاص بك
#  تشير القيمة الأعلى من الإسهاب إلى طباعة الكثير من التفاصيل

model = model_selection.GridSearchCV(
    estimator=classifier,
    param_grid = param_grid,
    scoring="accuracy",
    verbose = 10,
    n_jobs=1,
    cv=5
)
#مناسبة النموذج و إستخراج أفضل نتيجة
model.fit(X,y)
print(f"Best score : {model.best_score_}")

print("Best parameters ser:")
best_parameters = model.best_estimator_.get_params()
for param_name in sorted(param_grid.keys()):
    print(f"\t{param_name}: {best_parameters[param_name]}")

مما سيطبع الأتي 

[CV] criterion=entropy, max_depth=15, n_estimators=500, score=0.895,
total= 1.0s
[CV] criterion=entropy, max_depth=15, n_estimators=500 ...............
[CV] criterion=entropy, max_depth=15, n_estimators=500, score=0.890,
total= 1.1s
[CV] criterion=entropy, max_depth=15, n_estimators=500 ...............
[CV] criterion=entropy, max_depth=15, n_estimators=500, score=0.910,
total= 1.1s
[CV] criterion=entropy, max_depth=15, n_estimators=500 ...............
[CV] criterion=entropy, max_depth=15, n_estimators=500, score=0.880,
total= 1.1s
[CV] criterion=entropy, max_depth=15, n_estimators=500 ...............
[CV] criterion=entropy, max_depth=15, n_estimators=500, score=0.870,
total= 1.1s
[Parallel(n_jobs=1)]: Done 360 out of 360 | elapsed: 3.7min finished
Best score: 0.889
Best parameters set:
criterion: 'entropy'
max_depth: 15
n_estimators: 500

في النهاية ، نرى أن أفضل درجات دقة الطيات الخمسة لدينا كانت 0.889 ، ولدينا أفضل المعايير من بحث الشبكة لدينا. 

البحث العشوائي 

ثاني أفضل شيء يمكننا استخدامه هو البحث العشوائي. في البحث العشوائي ، نختار عشوائيًا مجموعة من المعايير ونحسب درجة التحقق المتقاطع. الوقت المستغرق هنا أقل من بحث الشبكة لأننا لا نقوم بالتقييم على جميع مجموعات المعايير المختلفة. نختار عدد المرات التي نريد فيها تقييم نماذجنا ، وهذا ما يحدد مقدار الوقت الذي يستغرقه البحث. لا يختلف الكود كثيرًا عما ورد أعلاه. باستثناء GridSearchCV ، نستخدم RandomizedSearchCV.

import numpy as np
import pandas as pd

from sklearn import ensemble
from sklearn import  metrics
from sklearn import model_selection

if __name__ == "__main__":
    #  قراءة ملف التدريب
    df = pd.read_csv("../input/mobile_train.csv")

    # prince_range  السمات هي كل الأعمدة ما عدا
    # لاحظ أنه لا يوجد عمود معرف في مجموعة البيانات 
    # هنا لدينا سمات التدريب 
    X = df.drop("price_range", axis=1).values
    # أما الأهداف
    y = df.price_range.values

    #تعريف النموذج
    #  n_jobs=-1 سنستخدم الغابة العشوائية مع 
    classifier = ensemble.RandomForestClassifier(n_jobs=-1)

    # تعريق شبكة من المعايير 
    # يمكن أن تكون قاموس أو قائمة قاموس
    param_grid = {
        "n_estimators" : [100, 200, 250, 300, 400, 500],
        "max_depth" : [1, 2, 5, 7, 11, 15],
        "criterion" : ["gini", "entropy"]
    }

    # تهيئة بحث الشبكة
    # هو النموذج الذي حددناه estimator   
    # هي شبكة المعلمات param_distributions
    # نحن نستخدم الدقة كمقياس لدينا. يمكنك تحديد الخاص بك
    #  تشير القيمة الأعلى من الإسهاب إلى طباعة الكثير من التفاصيل
    # هو عدد التكرارات التي نريدها n_iter
    #  تحتوي على جميع القيم كقائمة param_distributions إذا 
    # سيتم البحث العشوائي عن طريق أخذ العينات بدون استبدال
    # إذا جاء أي من المعلمات من التوزيع ،
    # يستخدم البحث العشوائي أخذ العينات مع الاستبدا
    model = model_selection.RandomizedSearchCV(
        estimator=classifier,
        param_distributions=param_grid,
        n_iter=20,
        scoring="accuracy",
        verbose = 10,
        n_jobs=1,
        cv=5
    )
    #مناسبة النموذج و إستخراج أفضل نتيجة
    model.fit(X,y)
    print(f"Best score : {model.best_score_}")

    print("Best parameters ser:")
    best_parameters = model.best_estimator_.get_params()
    for param_name in sorted(param_grid.keys()):
        print(f"\t{param_name}: {best_parameters[param_name]}")

لقد قمنا بتغيير شبكة المعايير للبحث العشوائي ، ويبدو أننا قمنا بتحسين النتائج قليلاً.

Best score: 0.8905
Best parameters set:
     criterion: entropy
     max_depth: 25
     n_estimators: 300

البحث العشوائي أسرع من بحث الشبكة إذا كان عدد التكرارات أقل. باستخدام هذين ، يمكنك العثور على المعايير المثلى (؟) لجميع أنواع النماذج طالما أن لها وظيفة مناسبة (fit) وتوقع (predict) .

في بعض الأحيان ، قد ترغب في استخدام خط الإنتاج. على سبيل المثال ، لنفترض أننا نتعامل مع مشكلة تصنيف متعدد الفئات. في هذه المشكلة ، تتكون بيانات التدريب من عمودين نصيين ، وأنت مطالب ببناء نموذج للتنبؤ بالفئة. لنفترض أن خط الإنتاج الذي تختاره هو تطبيق tf-idf أولاً بطريقة شبه خاضعة للإشراف ثم استخدام SVD مع مصنف SVM. الآن ، المشكلة أنه يتعين علينا تحديد مكونات SVD ونحتاج أيضًا إلى ضبط معايير SVM. يتم عرض كيفية القيام بذلك في المقتطف التالي.

import numpy as np
import pandas as pd

from sklearn import metrics
from sklearn import model_selection
from sklearn import pipeline

from sklearn.decomposition import  TruncatedSVD
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.preprocessing import  StandardScaler
from sklearn.svm import  SVC

def quadratic_weighted_kappa(y_true, y_pred):
    return metrics.cohen_kappa_score(
        y_true,
        y_pred,
        weights = "quadratic"
    )

if __name__ =='__main__': 
    # تحميل البيانات 
    train = pd.read_csv('../input/train.csv')

    # لا نحتاج عامود التعريف
    idx = test.id.values.astype(int)
    train = train.drop('id', axis=1)
    test = test.drop('id', axis=1)

    # إنشاء مسميات و التخلص من الأعمدة الغير مهمة 
    y = train.relevance.values

    traindata = list(
        train.apply(lambda x :'%s %s' % (x['text1'], x['text2']),axis=1)
    )
    testdata = list(
        test.apply(lambda x :'%s %s' % (x['text1'], x['text2']),axis=1)
    )

    #tfidf
    tfv = TfidfVectorizer(
        min_df = 3,
        max_features = NONE,
        strip_accents = 'unicode',
        analyzer='word',
        token_pattern=r'\w{1,}',
        ngram_range=(1, 3),
        use_idf=1,
        smooth_idf=1,
        sublinear_tf=1,
        stop_words='english'
    )

    #TFIDF  مناسبت
    tfv.fit(traindata)
    x = tfv.transform(traindata)
    X_test = tfv.transform(testdata)

    # SVD  تهيئة
    svd = TruncatedSVD()

    # scl
    scl = StandardScaler()

    # هنا svm سنستخدم 
    svm_model = SVC()

    #إنشاء خط الإنتاج
    clf = pipeline.Pipeline(
        [
            ('svd', svd),
            ('scl', scl),
            ('svm', svm_model)
        ]
    )

    # إنشاء شبكة المعايير لتبحث عن أفضل المعايير
    # في كل شيئ في خط الإنتاج
    param_grid = {
        'svd_n_components' : [200, 300],
        'svm_C':[10, 12]
    }

    #  نتيجة كابا
    kappa_scorer = metrics.make_scorer(
        quadratic_weighted_kappa,
        greater_is_better=True
    )

    # تهئية نموذج شبكة البحث 
    model = model_selection.GridSearchCV(
        estimator=clf,
        param_grid=param_grid,
        scoring=kappa_scorer,
        verbose=10,
        n_jobs=-1,
        refit=True,
        cv=5
    )

    #مناسبة نموذج شبكة البحث
    model.fit(x,y)
    print("best score: %0.3f" % model.best_score_)
    print("Best parameters set :")
    best_parameters = model.best_estimator_.get_params()
    for param_name in sorted(param_grid.keys()):
        print("\t%s: %r" % (param_name, best_parameters[param_name]))

    # احصل على أفضل نموذح
    best_model = model.best_estimator_

    # مناسبة النموذج مع أفضل المعايير
    best_model.fit(x,y)
    pred = best_model.predict(...)

يحتوي خط  الإنتاج الموضح هنا على نموذج تحليل القيمة المفردة (Singular Value Decomposition) أو  SVD  والقياس القياسي ونموذج ألية متجهة الدعم (Support Vector Machines) أو  SVM. يرجى ملاحظة أنك لن تكون قادرًا على تشغيل الكود أعلاه كما هو لأن بيانات التدريب غير متوفرة. 

 تحسين مُدخلات الضبط المدخلة 

تقليل الوظائف (minimization of functions) 

عندما ندخل في تقنيات تحسين مُدخلات الضبط (hyperparameter) المتقدمة  ، يمكننا إلقاء نظرة على تقليل الوظائف  (minimization of functions) باستخدام أنواع مختلفة من خوارزميات التصغير. 

يمكن تحقيق ذلك باستخدام العديد من وظائف التصغير مثل خوارزمية الانحدار البسيط ، وتحسين Nelder-Mead ، باستخدام تقنية بيشان مع العملية الغاوسية  للعثور على المعايير المثلى أو غيرها. 

 تحسين بيشان مع العملية الغاوسية

أولاً ، دعنا نرى كيف يمكن استخدام العملية الغاوسية (gaussian process) لتحسين مُدخلات الضبط. تحتاج هذه الأنواع من الخوارزميات إلى وظيفة يمكنها تحسينها. في معظم الأحيان ، يتعلق الأمر بتقليل هذه الوظيفة ، مثل تقليل الخسارة. 

لذلك ، لنفترض أنك تريد العثور على أفضل المعايير للحصول على أفضل دقة ، ومن الواضح أنه كلما كانت الدقة أعلى كلما كان هذا  أفضل. الآن لا يمكننا تقليل الدقة ، لكن يمكننا تقليلها عندما نضربها في -1. بهذه الطريقة ، نقوم بتقليل سلبية الدقة ، ولكن في الواقع ، نحن نقوم بتعظيم الدقة. بإستخدام تحسين بيشان مع العملية الغاوسية (Bayesian optimization with gaussian process) مع وظيفة gp_minimize من مكتبة scikit-optimize (skopt)  . دعنا نلقي نظرة على كيفية ضبط معايير نموذج الغابة العشوائية باستخدام هذه الوظيفة.

import numpy as np
import pandas as pd 

from functools import partial

from sklearn import ensemble
from sklearn import metrics
from sklearn import model_selection

from skopt import  gp_minimize
from skopt import space

def optimize(params, param_names, x, y):
    """
    وظيفة التحسين الرئيسية.
    تأخذ هذه الوظيفة جميع الحجج من مساحة البحث
    وميزات التدريب والأهداف. ثم يتم التهيئة
    النماذج من خلال تحديد المعلمات المختارة والتشغيل
    عبر التحقق من الصحة وإرجاع درجة دقة سلبية
    : param params: قائمة المعلمات من gp_minimize
    : param param_names: قائمة أسماء المعلمات. الطلب مهم!
    : param y: بيانات التدريب
    : param y: التسميات / الأهداف
    : العودة: دقة سلبية بعد 5 طيات
    """

    # تحويل المعايير إلى قاموس 
    params = dict(zip(param_names, params))

    # تهيئة النموذج مع المعايير الحالية 
    model = ensemble.RandomForestClassifier(**params)

    # تهيئة الطيات الطبقية 
    kf = model_selection.StratifiedKFold(n_splits=5)

    # تهيئة قائمة الدقة
    accuracies = []

    # إنشاء حلقة لكل الطيات
    for idx in kf.split(X=x, y=y):
        train_idx, test_idx = idx[0], idx[1]
        xtrain = x[train_idx]
        ytrain = y[train_idx]

        xtest = x[test_idx]
        ytest = y[test_idx]

        # مناسبة النموذج مع الطيه الحالية 
        model.fit(xtrain, ytrain)

        #إنشاء التنبوات 
        preds = model.predict(xtest)

        # حساب و إضافة الدقة
        fold_accuracy = metrics.accuracy_score(
            ytest,
            preds
        )
        accuracies.append(fold_accuracy)
    
    # إخراج الدقة السالبه
    return -1 * np.mean(accuracies)

if __name__ == "__main__":
    # قراءة بيانات التدريب 
    df = pd.read_csv("input\mobile_train.csv")

    # price_range  السمات هي كل الأعمدة ما عدا 
    # لا يوجد عامود تعريف في هذه البيانات 
    # هنا لدينا سمات التدريب 
    X = df.drop("price_range", axis=1).values
    # الأهداف
    y = df.price_range.values

    # تعريف فضاء المعايير
    param_space = [
        # هو رقم صحيح بين 3 و 10 max_depth
        space.Integer(3, 15, name="max_depth"),
        #  هو رقم صحيح بين 50 و 1500 n_estimators
        space.Integer(100, 1500, name="n_estimators"),
        # هو فئة وهنا نعرف قائمة الفئات criterion 
        space.Categorical(["gini", "entropy"], name="criterion"),
        # يمكنك أيضًا الحصول على مساحة مرقمة حقيقية وتحديد ملف
        # توزيع تريد الإختيار منه
        space.Real(0.01, 1 , prior="uniform", name="max_features")
    ]

    # إنشاء قائمة بأسماء المعايير
    # و التي لها نفس ترتيب فضاء البحث
    param_names = [
        "max_depth",
        "n_estimators",
        "criterion",
        "max_features"
    ]

    #نقوم بإنشاء functools partial عن طريق إستخدام
    # وظيفة جديدة و التي لديها نفس معايير  مثل
    # وظيفة التحسين بإستسثناء 
    # "params"  معييار واحد كمثال معييار
    # gp_minimize  مطلوب ، و هذه هي الطريقة التي تتوقع فيها 
    # أن تكون وظيفة التحسين  ، ويمكن التخلص من هذا 
    # من خلال البيانات داخل وظيفة التحسين أو 
    # بواسطة ننحديد وظيفة التحسين هنا
    optimization_function = partial(
         optimize,
         param_names = param_names,
         x = X,
         y=y
    )

    # gp_minimize هنا نستدعي 
    # و الذي يستخدم التحسين البيشان
    # من أجل تقليل دالة التحسين
    # نحتاج إلى فضاء  من المعايير ، الوظيفة نفسها ،
    # عدد النداءات / التكرارات التي نريد الحصول عليها 
    result = gp_minimize(
        optimization_function,
        dimensions=param_space,
        n_calls= 15,
        n_random_starts=10,
        verbose= 10
    )

    #  إنشاء قاموس لأفضل المعايير 
    best_params = dict(
        zip(
            param_names,
            result.x
        )
    )
    print(best_params)

    from skopt.plots import plot_convergence
    plot_convergence(result)

مرة أخرى ، ينتج عن هذا الكثير من الإنتاج ، ويتم عرض الجزء الأخير منه أدناه.

Iteration No: 14 started. Searching for the next optimal point.
Iteration No: 14 ended. Search finished for the next optimal point.
Time taken: 4.7793
Function value obtained: -0.9075
Current minimum: -0.9075
Iteration No: 15 started. Searching for the next optimal point.
Iteration No: 15 ended. Search finished for the next optimal point.
Time taken: 49.4186
Function value obtained: -0.9075
Current minimum: -0.9075
{'max_depth': 12, 'n_estimators': 100, 'criterion': 'entropy',
'max_features': 1.0}

يبدو أننا تمكنا من الحصول على دقة 0.90. هذا رائع! يمكننا أيضًا أن نرى (رسم) كيف حققنا التقارب باستخدام المقتطف التالي.

from skopt.plots import plot_convergence
plot_convergence(result)

إستخدام hyperopt 

هناك العديد من المكتبات المتاحة التي تقدم تحسين مُدخلات الضبط . scikitoptimize هي إحدى هذه المكتبات التي يمكنك استخدامها. مكتبة أخرى مفيدة هي hyperopt. يستخدم hyperopt مقدر بارزين ذو البنية الشجرية (Tree-structured Parzen Estimator) أو (TPE) للعثور على أفضل المعايير. ألق نظرة على المقتطف التالي حيث أستخدم hyperopt مع الحد الأدنى من التغييرات على الكود السابق.

import numpy as np
import pandas as pd 

from functools import partial

from sklearn import ensemble
from sklearn import metrics
from sklearn import model_selection

from hyperopt import hp, fmin, tpe, Trials
from hyperopt.pyll.base import scope
from skopt import space

def optimize(params, x, y):
    """
    وظيفة التحسين الرئيسية.
    تأخذ هذه الوظيفة جميع الحجج من مساحة البحث
    وميزات التدريب والأهداف. ثم يتم التهيئة
    النماذج من خلال تحديد المعلمات المختارة والتشغيل
    عبر التحقق من الصحة وإرجاع درجة دقة سلبية
    : param params: قائمة المعلمات من gp_minimize
    : param param_names: قائمة أسماء المعلمات. الطلب مهم!
    : param y: بيانات التدريب
    : param y: التسميات / الأهداف
    : العودة: دقة سلبية بعد 5 طيات
    """


    # تهيئة النموذج مع المعايير الحالية 
    model = ensemble.RandomForestClassifier(**params)

    # تهيئة الطيات الطبقية 
    kf = model_selection.StratifiedKFold(n_splits=5)

    # تهيئة قائمة الدقة
    accuracies = []

    # إنشاء حلقة لكل الطيات
    for idx in kf.split(X=x, y=y):
        train_idx, test_idx = idx[0], idx[1]
        xtrain = x[train_idx]
        ytrain = y[train_idx]

        xtest = x[test_idx]
        ytest = y[test_idx]

        # مناسبة النموذج مع الطيه الحالية 
        model.fit(xtrain, ytrain)

        #إنشاء التنبوات 
        preds = model.predict(xtest)

        # حساب و إضافة الدقة
        fold_accuracy = metrics.accuracy_score(
            ytest,
            preds
        )
        accuracies.append(fold_accuracy)
    
    # إخراج الدقة السالبه
    return -1 * np.mean(accuracies)

if __name__ == "__main__":
    # قراءة بيانات التدريب 
    df = pd.read_csv("input\mobile_train.csv")

    # price_range  السمات هي كل الأعمدة ما عدا 
    # لا يوجد عامود تعريف في هذه البيانات 
    # هنا لدينا سمات التدريب 
    X = df.drop("price_range", axis=1).values
    # الأهداف
    y = df.price_range.values

    # تعريف فضاء المعايير
    param_space = {
        # quniform gives round(uniform(low, high) / q) * q
        #  نرغب في أرقام صحيحة للعمق و المقدرات
        "max_depth": scope.int(hp.quniform("max_depth", 1, 15, 1)),
        "n_estimators": scope.int(
            hp.quniform("n_estimators", 100, 1500, 1)
        ),
        # الإختيار من قائمة القيم
        "criterion" : hp.choice("criterion", ["gini", "entropy"]),

        # المنظم يختارب قيمة بين قيمتين
        "max_features": hp.uniform("max_features", 0, 1)
    }

    # الدالة الجزئية 
    optimization_function = partial(
        optimize,
        x=X,
        y=y
    )

    # لتسجيل المعلومات trials تهيئة 
    trials = Trials()

    #hyperpot إستخدام 
    hopt = fmin(
        fn=optimization_function,
        space= param_space,
        algo=tpe.suggest,
        max_evals=15,
        trials = trials
    )

    print(hopt)

كما ترى ، هذا لا يختلف كثيرًا عن الكود السابق. يجب عليك تحديد مساحة المعلمة بتنسيق مختلف ، وتحتاج أيضًا إلى تغيير جزء التحسين الفعلي باستخدام hyperopt بدلاً من gp_minimize. النتائج جيدة جدا!

نحصل على دقة أفضل قليلاً من ذي قبل ومجموعة من المعايير التي يمكننا استخدامها. يرجى ملاحظة أن المعيار هو 1 في النتيجة النهائية.

 هذا يعني أنه تم اختيار الخيار 1 ، أي الانتروبيا. تعد طرق ضبط معايير مدخلات الضبط الموضحة أعلاه هي الأكثر شيوعًا ، وستعمل هذه مع جميع النماذج تقريبًا: الانحدار الخطي ، والانحدار اللوجستي ، والطرق القائمة على الأشجار ، ونماذج تعزيز التدرج مثل xgboost ، و lightgbm ، وحتى الشبكات العصبية!

على الرغم من وجود هذه الأساليب ، للتعلم ، يجب على المرء أن يبدأ بضبط مدخلات الضبط  يدويًا ، أي باليد. سيساعدك الضبط اليدوي على تعلم الأساسيات ، على سبيل المثال ، في تعزيز التدرج (gradient boosting) ، عندما تقوم بزيادة العمق ، يجب عليك تقليل معدل التعلم. لن يكون من الممكن معرفة هذا إذا كنت تستخدم أدوات آلية. 

راجع الجدول التالي لمعرفة ما يجب ضبطه. تشير RS * إلى أن البحث العشوائي يجب أن يكون أفضل. 

بمجرد أن تتحسن مهاراتك في الضبط اليدوي للمعايير ، قد لا تحتاج حتى إلى أي ضبط آلي للمعايير مدخلات الضبط. عند إنشاء نماذج كبيرة أو تقديم الكثير من السمات، فإنك تجعلها أيضًا عرضة  لفرط التخصيص بشكل زائد. لتجنب ذلك ،  تحتاج إلى إدخال ضوضاء في سمات بيانات التدريب أو معاقبة دالة الخسارة . هذا العقاب يسمى التنظيم (regularization) ويساعد في تعميم النموذج. 

في النماذج الخطية ، أكثر أنواع التنظيمات شيوعًا هي L1 و L2. يُعرف L1 أيضًا باسم انحدار لاسو (Lasso regression ) و L2 باسم انحدار ريدج (Ridge regression). عندما يتعلق الأمر بالشبكات العصبية ، فإننا نستخدم الإسقاط (dropouts) وإضافة التعزيزات والضوضاء وما إلى ذلك لتنظيم نماذجنا. باستخدام تحسين مُدخلات الضبط ، يمكنك أيضًا العثور على العقوبة الصحيحة لاستخدامها.