نقوم بتنفيذ ومقارنة 4 محسنات تدريب على الشبكة العصبية الشائعة: مُحسِّن النبضات ، وانتشار rms ، ونزول متدرج دفعة صغيرة ، وتقدير عزم الدوران التكيفي. المستودع ، والكثير من كود Python وإخراجها ، وتصوراتها وصيغها كلها تحت القص.

---

المقدمة

النموذج هو نتيجة خوارزمية التعلم الآلي التي تعمل على بعض البيانات. يمثل النموذج ما تعلمته الخوارزمية. هذا هو "الشيء" الذي يستمر بعد تشغيل الخوارزمية على بيانات التدريب ويمثل القواعد والأرقام وأي هياكل بيانات أخرى خاصة بالخوارزمية وضرورية للتنبؤ.

ما هو المحسن؟

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



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



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

بعض المصطلحات شائعة الاستخدام:

• التكاثر الخلفي

أهداف backpropagation بسيطة: اضبط كل وزن في الشبكة وفقًا لمقدار مساهمته في الخطأ الكلي. إذا قمت بتقليل خطأ كل وزن بشكل متكرر ، فستنتهي بسلسلة من الأوزان التي تعطي تنبؤات جيدة. نجد ميل كل معلمة لوظيفة الخسارة وتحديث المعلمات بطرح الميل (مزيد من المعلومات هنا ).

• نزول متدرج

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

• Hyperparameters

المعلمة الفائقة للنموذج هي تكوين خارجي للنموذج ، لا يمكن تقدير قيمته من البيانات. على سبيل المثال ، عدد الخلايا العصبية المخفية ، ومعدل التعلم ، إلخ. لا يمكننا تقدير معدل التعلم من البيانات (مزيد من المعلومات هنا ).

• معدل التعليم

معدل التعلم (α) هو معلمة ضبط في خوارزمية التحسين التي تحدد حجم الخطوة في كل تكرار أثناء التحرك نحو الحد الأدنى من وظيفة الخسارة (مزيد من المعلومات هنا).

محسنون مشهورون

فيما يلي بعض أشهر مُحسّنات محرّكات البحث:

1. الانحدار العشوائي (SGD).
2. مُحسِّن الزخم.
3. جذر متوسط ​​الانتشار التربيعي (RMSProp).
4. تقدير عزم الدوران التكيفي (آدم).

دعونا نفكر في كل منهم بالتفصيل.

1. نزول التدرج العشوائي (خاصة الدُفعة الصغيرة)

نستخدم مثالًا واحدًا في كل مرة عند تدريب النموذج (في SGD الخالص) وتحديث المعلمة. لكن علينا استخدام واحد آخر للحلقة. سوف يستغرق الكثير من الوقت. لذلك ، نستخدم SGD دفعة صغيرة.



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

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

كيف يمكنني إنشاء حزم صغيرة عشوائية؟

def RandomMiniBatches(X, Y, MiniBatchSize):

    m = X.shape[0]  
    miniBatches = [] 
   
    permutation = list(np.random.permutation(m))
    shuffled_X = X[permutation, :]
    shuffled_Y = Y[permutation, :].reshape((m,1))   #sure for uptpur shape

    num_minibatches = m // MiniBatchSize 
    for k in range(0, num_minibatches):
        miniBatch_X = shuffled_X[k * MiniBatchSize:(k + 1) * MiniBatchSize,:]
        miniBatch_Y = shuffled_Y[k * MiniBatchSize:(k + 1) * MiniBatchSize,:]
        miniBatch = (miniBatch_X, miniBatch_Y)
        miniBatches.append(miniBatch)
    
    #handeling last batch
    if m % MiniBatchSize != 0:
        # end = m - MiniBatchSize * m // MiniBatchSize
        miniBatch_X = shuffled_X[num_minibatches * MiniBatchSize:, :]
        miniBatch_Y = shuffled_Y[num_minibatches * MiniBatchSize:, :]

        miniBatch = (miniBatch_X, miniBatch_Y)
        miniBatches.append(miniBatch)
    
    return miniBatches 

ماذا سيكون شكل النموذج؟



أقدم نظرة عامة على النموذج في حال كنت جديدًا في التعلم العميق. يبدو شيء من هذا القبيل:

def model(X,Y,learning_rate,num_iter,hidden_size,keep_prob,optimizer):
    L = len(hidden_size)
    params = initilization(X.shape[1], hidden_size)
    for i in range(1,num_iter):
        MiniBatches = RandomMiniBatches(X, Y, 64)   # GET RAMDOMLY MINIBATCHES
        p , q = MiniBatches[2]
        for MiniBatch in MiniBatches:               #LOOP FOR MINIBATCHES

            (MiniBatch_X, MiniBatch_Y) = MiniBatch

            cache, A = model_forward(MiniBatch_X, params, L,keep_prob)             #FORWARD PROPOGATIONS
            cost = cost_f(A, MiniBatch_Y)                                          #COST FUNCTION
            grad = backward(MiniBatch_X, MiniBatch_Y, params, cache, L,keep_prob)  #BACKWARD PROPAGATION 
            params = update_params(params, grad, beta=0.9,learning_rate=learning_rate)
    return params

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







كيف تقلل الاهتزازات غير المرغوب فيها؟ تعمل المحسنات التالية على تقليلها والمساعدة في تسريع التعلم.

2. الدافع محسن

هناك الكثير من التذبذب في SGD أو النسب المتدرج. أنت بحاجة إلى المضي قدمًا ، وليس لأعلى ولأسفل. نحتاج إلى زيادة معدل التعلم للنموذج في الاتجاه الصحيح وسنفعل ذلك باستخدام مُحسِّن الزخم.







كما ترى في الصورة أعلاه ، فإن الخط الأخضر لمُحسِّن النبض أسرع من الآخرين. يمكن ملاحظة أهمية التعلم بسرعة عندما يكون لديك مجموعات بيانات كبيرة والعديد من التكرارات. كيف يتم تنفيذ هذا المحسن؟





تبلغ القيمة العادية لـ β حوالي 0.9. يمكنك



أن ترى أننا أنشأنا معلمتين - vdW و vdb - من معلمات backpropagation . ضع في اعتبارك القيمة β = 0.9 ، ثم تأخذ المعادلة الشكل:

vdw= 0.9 * vdw + 0.1 * dw
vdb = 0.9 * vdb + 0.1 * db

كما ترى ، يعتمد vdw بشكل أكبر على القيمة السابقة لـ vdw بدلاً من dw. عندما يكون التجسيد رسمًا بيانيًا ، يمكنك أن ترى أن مُحسِّن الزخم يأخذ التدرجات اللونية السابقة في الاعتبار لتسهيل التحديث. هذا هو السبب في أنه من الممكن تقليل التقلبات. عندما استخدمنا SGD ، يتأرجح المسار الذي سلكه هبوط التدرج الصغير للدفعة نحو التقارب. يساعد مُحسِّن الزخم على تقليل هذه التقلبات.

def update_params_with_momentum(params, grads, v, beta, learning_rate):
    
    # grads has the dw and db parameters from backprop
    # params  has the W and b parameters which we have to update 
    for l in range(len(params) // 2 ):

        # HERE WE COMPUTING THE VELOCITIES 
        v["dW" + str(l + 1)] = beta * v["dW" + str(l + 1)] + (1 - beta) * grads['dW' + str(l + 1)]
        v["db" + str(l + 1)] = beta * v["db" + str(l + 1)] + (1 - beta) * grads['db' + str(l + 1)]
        
        #updating parameters W and b
        params["W" + str(l + 1)] = params["W" + str(l + 1)] - learning_rate * v["dW" + str(l + 1)]
        params["b" + str(l + 1)] = params["b" + str(l + 1)] - learning_rate * v["db" + str(l + 1)]
    return params

المستودع هنا

3. الجذر يعني انتشار مربع

جذر الجذر يعني التربيع (RMSprop) هو متوسط ​​التدهور الأسي. الخاصية الأساسية لـ RMSprop هي أنك لست مقيدًا فقط بمجموع التدرجات اللونية السابقة ، لكنك مقيد بدرجة أكبر بتدرجات الخطوات الأخيرة. يساهم RMSprop في متوسط ​​التدهور الأسي لـ "تدرجات القانون التربيعي" السابقة. في RMSProp ، نحاول تقليل الحركة الرأسية باستخدام المتوسط ​​، لأنها تضيف ما يصل إلى حوالي 0 ، مع الأخذ في الاعتبار المتوسط. يوفر RMSprop المتوسط ​​للتحديث.





مصدر







ألق نظرة على الكود أدناه. سيعطيك هذا فهمًا أساسيًا لكيفية تنفيذ هذا المحسن. كل شيء كما هو الحال مع SGD ، علينا تغيير وظيفة التحديث.

def initilization_RMS(params):
    s = {}
    for i in range(len(params)//2 ):
        s["dW" + str(i)] = np.zeros(params["W" + str(i)].shape)
        s["db" + str(i)] = np.zeros(params["b" + str(i)].shape)
    return s

def update_params_with_RMS(params, grads,s, beta, learning_rate):
    
    # grads has the dw and db parameters from backprop
    # params  has the W and b parameters which we have to update 
    for l in range(len(params) // 2 ):
        # HERE WE COMPUTING THE VELOCITIES 
        s["dW" + str(l)]= beta * s["dW" + str(l)] + (1 - beta) * np.square(grads['dW' + str(l)])
        s["db" + str(l)] = beta * s["db" + str(l)] + (1 - beta) * np.square(grads['db' + str(l)])
        
        #updating parameters W and b
        params["W" + str(l)] = params["W" + str(l)] - learning_rate * grads['dW' + str(l)] / (np.sqrt( s["dW" + str(l)] )+ pow(10,-4))
        params["b" + str(l)] = params["b" + str(l)] - learning_rate * grads['db' + str(l)] / (np.sqrt( s["db" + str(l)]) + pow(10,-4))

    return params

4. آدم محسن

Adam هي واحدة من أكثر خوارزميات التحسين كفاءة في تدريب الشبكة العصبية. فهو يجمع بين أفكار RMSProp و Pulse Optimizer. بدلاً من تكييف معدل التعلم للمعلمات بناءً على متوسط ​​اللحظة الأولى (الوسط) كما هو الحال في RMSProp ، يستخدم Adam أيضًا متوسط ​​اللحظات الثانية من التدرجات. على وجه التحديد، الخوارزمية بحساب المتوسط المتحرك الأسي من التدرج والتدرج من الدرجة الثانية، والمعلمات beta1و beta2الضوابط معدل التحلل من هذه المتوسطات المتحركة. كيف؟

def initilization_Adam(params):
    s = {}
    v = {}
    for i in range(len(params)//2 ):

        v["dW" + str(i)] = np.zeros(params["W" + str(i)].shape)
        v["db" + str(i)] = np.zeros(params["b" + str(i)].shape)

        s["dW" + str(i)] = np.zeros(params["W" + str(i)].shape)
        s["db" + str(i)] = np.zeros(params["b" + str(i)].shape)
    return v, s
    
def update_params_with_Adam(params, grads,v, s, beta1,beta2, learning_rate,t):
    epsilon = pow(10,-8)
    v_corrected = {}                         
    s_corrected = {} 
    # grads has the dw and db parameters from backprop
    # params  has the W and b parameters which we have to update 
    for l in range(len(params) // 2 ):
        # HERE WE COMPUTING THE VELOCITIES 

        v["dW" + str(l)] = beta1 * v["dW" + str(l)] + (1 - beta1) * grads['dW' + str(l)]
        v["db" + str(l)] = beta1 * v["db" + str(l)] + (1 - beta1) * grads['db' + str(l)]

        v_corrected["dW" + str(l)] = v["dW" + str(l)] / (1 - np.power(beta1, t))
        v_corrected["db" + str(l)] = v["db" + str(l)] / (1 - np.power(beta1, t))


        s["dW" + str(l)] = beta2 * s["dW" + str(l)] + (1 - beta2) * np.power(grads['dW' + str(l)], 2)
        s["db" + str(l)] = beta2 * s["db" + str(l)] + (1 - beta2) * np.power(grads['db' + str(l)], 2)

        s_corrected["dW" + str(l)] = s["dW" + str(l)] / (1 - np.power(beta2, t))
        s_corrected["db" + str(l)] = s["db" + str(l)] / (1 - np.power(beta2, t))

        params["W" + str(l)] = params["W" + str(l)] - learning_rate * v_corrected["dW" + str(l)] / np.sqrt(s_corrected["dW" + str(l)] + epsilon)
        params["b" + str(l)] = params["b" + str(l)] - learning_rate * v_corrected["db" + str(l)] / np.sqrt(s_corrected["db" + str(l)] + epsilon)
    return params

Hyperparameters

• تبلغ قيمة β1 (beta1) تقريبًا 0.9
• β2 (بيتا 2) - 0.999 تقريبًا
• ε - منع القسمة على الصفر (10 ^ -8) (لا تؤثر على التعلم كثيرًا)

لماذا هذا المحسن؟



مزاياه:

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

دعونا نبني نموذجًا ونرى كيف تعمل المعلمات الفائقة على تسريع التعلم

لنقم بعرض توضيحي عملي لكيفية تسريع التعلم. في هذه المقالة لن نشرح الأشياء الأخرى (التهيئة ، العروض ، forward_prop، back_propالنسب المتدرج ، وهكذا د.). الوظائف المطلوبة للتدريب مدمجة بالفعل في NumPy. إذا كنت تريد إلقاء نظرة عليها ، فإليك الرابط !

لنبدأ!

أقوم بإنشاء دالة نموذج عامة تعمل لجميع المحسّنين الذين تمت مناقشتهم هنا.



1. التهيئة:



نقوم بتهيئة المعلمات باستخدام وظيفة التهيئة التي تأخذ مدخلات مثل features_size (في حالتنا 12288) ومجموعة مخفية من الأحجام (استخدمنا [100 ، 1]) وهذا الإخراج كمعلمات تهيئة. هناك طريقة أخرى للتهيئة. أنا أشجعك على قراءة هذا المقال.

def initilization(input_size,layer_size):
    params = {}
    np.random.seed(0) 
    params['W' + str(0)] = np.random.randn(layer_size[0], input_size) * np.sqrt(2 / input_size)
    params['b' + str(0)] = np.zeros((layer_size[0], 1))
    for l in range(1,len(layer_size)):
        params['W' + str(l)] = np.random.randn(layer_size[l],layer_size[l-1]) * np.sqrt(2/layer_size[l])
        params['b' + str(l)] = np.zeros((layer_size[l],1))
    return params

2. Forward Propagation:



في هذه الوظيفة ، يكون الإدخال هو X ، وكذلك المعلمات ومدى الطبقات المخفية والتسرب ، والتي تستخدم في تقنية التسرب.



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



نحسب قيمة التنشيط لكل طبقة باستخدام وظيفة forward_activation.

#activations-----------------------------------------------
def forward_activation(A_prev, w, b, activation):
    z = np.dot(A_prev, w.T) + b.T
    if activation == 'relu':
        A = np.maximum(0, z)
    elif activation == 'sigmoid':
        A = 1/(1+np.exp(-z))
    else:
        A = np.tanh(z)
    return A


#________model forward ____________________________________________________________________________________________________________
def model_forward(X,params, L,keep_prob):
    cache = {}
    A =X

    for l in range(L-1):
        w = params['W' + str(l)]
        b = params['b' + str(l)]
        A = forward_activation(A, w, b, 'relu')
        if l%2 == 0:
            cache['D' + str(l)] = np.random.randn(A.shape[0],A.shape[1]) < keep_prob
            A = A * cache['D' + str(l)] / keep_prob
        cache['A' + str(l)] = A
    w = params['W' + str(L-1)]
    b = params['b' + str(L-1)]
    A = forward_activation(A, w, b, 'sigmoid')
    cache['A' + str(L-1)] = A
    return cache, A

3. Backpropagation:



هنا نكتب وظيفة backpropagation. سيعود غراد ( المنحدر ). نستخدمها gradعند تحديث المعلمات (إذا كنت لا تعرف عنها). أوصي بقراءة هذا المقال.

def backward(X, Y, params, cach,L,keep_prob):
    grad ={}
    m = Y.shape[0]

    cach['A' + str(-1)] = X
    grad['dz' + str(L-1)] = cach['A' + str(L-1)] - Y
    cach['D' + str(- 1)] = 0
    for l in reversed(range(L)):
        grad['dW' + str(l)] = (1 / m) * np.dot(grad['dz' + str(l)].T, cach['A' + str(l-1)])
        grad['db' + str(l)] = 1 / m * np.sum(grad['dz' + str(l)].T, axis=1, keepdims=True)
        if l%2 != 0:
            grad['dz' + str(l-1)] = ((np.dot(grad['dz' + str(l)], params['W' + str(l)]) * cach['D' + str(l-1)] / keep_prob) *
                                 np.int64(cach['A' + str(l-1)] > 0))
        else :
            grad['dz' + str(l - 1)] = (np.dot(grad['dz' + str(l)], params['W' + str(l)]) *
                                       np.int64(cach['A' + str(l - 1)] > 0))

    return grad

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

def model(X,Y,learning_rate,num_iter,hidden_size,keep_prob,optimizer):
    L = len(hidden_size)
    params = initilization(X.shape[1], hidden_size)
    costs = []
    itr  = []

    if optimizer == 'momentum':
        v = initilization_moment(params)

    elif optimizer == 'rmsprop':
        s = initilization_RMS(params)

    elif optimizer == 'adam' :
        v,s = initilization_Adam(params)

    for i in range(1,num_iter):
        MiniBatches = RandomMiniBatches(X, Y, 32)   # GET RAMDOMLY MINIBATCHES
        p , q = MiniBatches[2]
        for MiniBatch in MiniBatches:               #LOOP FOR MINIBATCHES

            (MiniBatch_X, MiniBatch_Y) = MiniBatch

            cache, A = model_forward(MiniBatch_X, params, L,keep_prob)     #FORWARD PROPOGATIONS
            cost = cost_f(A, MiniBatch_Y)                                  #COST FUNCTION
            grad = backward(MiniBatch_X, MiniBatch_Y, params, cache, L,keep_prob) #BACKWARD PROPAGATION 

            if optimizer == 'momentum':
                params = update_params_with_momentum(params, grad, v, beta=0.9,learning_rate=learning_rate)

            elif optimizer == 'rmsprop':
               params = update_params_with_RMS(params, grad, s, beta=0.9,learning_rate=learning_rate)

            elif optimizer == 'adam' :
                params = update_params_with_Adam(params, grad,v, s, beta1=0.9,beta2=0.999,  learning_rate=learning_rate,t=i)                                         #UPDATE PARAMETERS
            elif optimizer == "minibatch":
                params = update_params(params, grad,learning_rate=learning_rate) 

           
        
        if i%5 == 0:
            costs.append(cost)
            itr.append(i)
            if i % 100 == 0 :
                print('cost of iteration______{}______{}'.format(i,cost))
    return params,costs,itr

التدريب مع حزم صغيرة

params, cost_sgd,itr = model(X_train, Y_train, learning_rate = 0.01,
               num_iter=500, hidden_size=[100, 1],keep_prob=1,optimizer='minibatch')
Y_train_pre = predict(X_train, params, 2)
print('train_accuracy------------', accuracy_score(Y_train_pre, Y_train))

الخلاصة عند الاقتراب من الحزم الصغيرة:

cost of iteration______100______0.35302967575683797 
cost of iteration______200______0.472914548745098 
cost of iteration______300______0.4884728238471557 
cost of iteration______400______0.21551100063345618
 
train_accuracy------------ 0.8494208494208494

تدريب محسن النبض

params,cost_momentum, itr = model(X_train, Y_train, learning_rate = 0.01,
               num_iter=500, hidden_size=[100, 1],keep_prob=1,optimizer='momentum')
Y_train_pre = predict(X_train, params, 2)
print('train_accuracy------------', accuracy_score(Y_train_pre, Y_train))

خرج محسن النبض:

cost of iteration______100______0.36278494129038086 
cost of iteration______200______0.4681552335189021 
cost of iteration______300______0.382226159384529 
cost of iteration______400______0.18219310793752702 train_accuracy------------ 0.8725868725868726

التدريب مع RMSprop

params,cost_rms,itr = model(X_train, Y_train, learning_rate = 0.01,
               num_iter=500, hidden_size=[100, 1],keep_prob=1,optimizer='rmsprop')
Y_train_pre = predict(X_train, params, 2)
print('train_accuracy------------', accuracy_score(Y_train_pre, Y_train))

إخراج RMSprop:

cost of iteration______100______0.2983858963793841 
cost of iteration______200______0.004245700579927428 
cost of iteration______300______0.2629426607580565 
cost of iteration______400______0.31944824707807556 train_accuracy------------ 0.9613899613899614

تدريب مع آدم

params,cost_adam, itr = model(X_train, Y_train, learning_rate = 0.01,
               num_iter=500, hidden_size=[100, 1],keep_prob=1,optimizer='adam')
Y_train_pre = predict(X_train, params, 2)
print('train_accuracy------------', accuracy_score(Y_train_pre, Y_train))

استنتاج آدم:

cost of iteration______100______0.3266223660473619 
cost of iteration______200______0.08214547683157716 
cost of iteration______300______0.0025645257286439583 
cost of iteration______400______0.058015188756586206 train_accuracy------------ 0.9845559845559846

هل رأيت الفرق في الدقة بين الاثنين؟ استخدمنا نفس معلمات التهيئة ونفس معدل التعلم ونفس عدد التكرارات ؛ فقط المحسن هو مختلف ، لكن انظر إلى النتيجة!

Mini-batch accuracy : 0.8494208494208494
momemtum accuracy   : 0.8725868725868726
Rms accuracy        : 0.9613899613899614
adam accuracy       : 0.9845559845559846

تصور رسومي للنموذج





يمكنك التحقق من المستودع إذا كانت لديك شكوك حول الكود.

ملخص

المصدر

كما رأينا ، يعطي مُحسِّن آدم دقة جيدة مقارنة بالمحسِّنين الآخرين. توضح الصورة أعلاه كيف يتعلم النموذج من خلال التكرارات. يعطي Momentum سرعة SGD ويعطي RMSProp المتوسط ​​الأسي للأوزان للمعلمات المحدثة. لقد استخدمنا بيانات أقل في النموذج أعلاه ، لكننا سنرى فائدة أكبر من المحسّنين عند العمل مع مجموعات البيانات الكبيرة والعديد من التكرارات. لقد ناقشنا الفكرة الأساسية للمُحسِنين ، وآمل أن يمنحك هذا بعض الدافع لمعرفة المزيد حول المحسّنين واستخدامها!





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

• دورة تعلم الآلة
• دورة "الرياضيات والتعلم الآلي لعلوم البيانات"
• دورة متقدمة "التعلم الآلي + التعلم العميق"
• المعسكر التدريبي عبر الإنترنت لعلوم البيانات
• تدريب مهنة محلل البيانات من الصفر
• المعسكر التدريبي لتحليلات البيانات على الإنترنت
• تدريس مهنة علوم البيانات من الصفر
• دورة بايثون لتطوير الويب

مقالات مقترحة

• كيف تصبح عالم بيانات بدون دورات عبر الإنترنت
• 450
• Machine Learning 5 9
• : 2020
• Machine Learning Computer Vision