טיש פון קאָנטענץ[באַהאַלטן][ווייַזן]
דער מאַרך איז פאַרגלייַכלעך צו נעוראַל נעטוואָרקס. דאָס איז די אַנאַלאַדזשי וואָס איז טיפּיקלי געניצט צו אַרוישעלפן עמעצער נייַ צו די טעמע צו פֿאַרשטיין די געדאנקען הינטער מאַשין לערנען און קינסטלעך נעוראַל נעטוואָרקס.
ווייַל עס זענען עטלעכע לייַערס פון מאַטאַמאַטיקאַל און סטאַטיסטיש קאַמפּיוטיישאַנז הינטער די סינז, דיפיינינג די נעטוואָרקס ווי אַ מאַטאַמאַטיקאַל פֿונקציע איז אַ מער אַוואַנסירטע אופֿן.
דאָס איז פֿאַר די מענטשן וואָס זענען אַקשלי אינטערעסירט אין מאַשין לערנען און ווילן צו זען ווי פּיטהאָן נעוראַל נעץ קאָד איז געשריבן.
אין דעם אַרטיקל, מיר וועט באַווייַזן ווי צו בויען אַ גאָר קאָננעקטעד טיף נעוראַל נעץ (DNN) פֿון קראַצן אין פּיטהאָן 3.
אַן איבערבליק פון דער טעקע סטרוקטור פֿאַר אונדזער פּיטהאָן נעוראַל נעטוואָרק קאָד
עס וועט זיין באשאפן דריי טעקעס דאָ. דער ערשטער איז די פּשוט nn.py טעקע, וואָס וועט זיין דיסקאַסט אין "סעטטינג העלפּער פאַנגקשאַנז" און "בויינג די נעוראַל נעץ פֿון קראַצן."
מיר וועלן אויך האָבן אַ טעקע מיטן נאָמען mnist loader.py צו לאָדן די פּראָבע דאַטן, ווי דיסקרייבד אין "לאָודינג MNIST דאַטן."
צום סוף, מיר וועלן האָבן אַ טעקע געהייסן test.py וואָס וועט זיין לאָנטשט אין די וואָקזאַל צו פּרובירן אונדזער נעוראַל נעץ.
דער טעקע איז דיסקרייבד אין דעטאַל אין "לויפן טעסץ."
ינסטאַלירונג
די NumPy Python ביבליאָטעק מוזן זיין דאַונלאָודיד צו נאָכפאָלגן דעם טוטאָריאַל. איר קענען ויספירן דעם דורך ניצן די פאלגענדע באַפֿעל אויף די וואָקזאַל:
ימפּאָרטינג מאָדולעס און באַשטעטיקן די העלפּער פונקציע
די בלויז צוויי לייברעריז וואָס מיר דאַרפן זענען טראַפ און NumPy, וואָס מיר וועלן אַרייַנפיר גלייך. פֿאַר די ערשט ווייץ פון אונדזער נעוראַל נעץ, מיר שאַרן זיי מיט די טראַפ - ביבליאָטעק.
אין סדר צו פאַרגיכערן אונדזער קאַמפּיאַטיישאַנז, מיר נוצן NumPy אָדער np (דורך קאַנווענשאַן, עס איז אָפט ימפּאָרטיד ווי np). אונדזער צוויי העלפּער פאַנגקשאַנז וועט זיין געמאכט נאָך אונדזער ימפּאָרץ. צוויי סיגמאָיד פאַנגקשאַנז: איינער און סיגמאָיד פּריים.
לאָגיסטיק ראַגרעשאַן וועט קלאַסיפיצירן דאַטן מיט די סיגמאָיד פונקציע, בשעת באַקפּראָפּאַגאַטיאָן וועט רעכענען די דעלטאַ אָדער גראַדיענט מיט די סיגמאָיד הויפּט פֿונקציע.
שאפן נעטוואָרק קלאַס
בנין אַ גאָר לינגקט נעוראַל נעץ איז דער בלויז פאָקוס פון דעם אָפּטיילונג. דער נעץ קלאַס וועט ענקאַמפּאַס אַלע די פאַנגקשאַנז וואָס קומען נאָך. די פֿונקציע אָבדזשעקט () { [געבוירן קאָד] } וועט זיין באשאפן טכילעס אין אונדזער נעץ קלאַס.
איין אַרגומענט, סיזעס, איז פארלאנגט דורך די פֿונקציע אָבדזשעקט () { [געבוירן קאָד] }. די סיזעס בייַטעוודיק איז אַ זאַמלונג פון נומעריק וואַלועס וואָס רעפּראַזענץ די נומער פון אַרייַנשרייַב נאָודז פאָרשטעלן אין יעדער שיכטע פון אונדזער נעוראַל נעץ.
מיר ינישאַלייז פיר פּראָפּערטיעס אין אונדזער __יניט__ אופֿן. די אַרייַנשרייַב וועריאַבאַלז, סיזעס, זענען געניצט צו שטעלן די רשימה פון שיכטע סיזעס און די נומער פון לייַערס, נומער לייַערס, ריספּעקטיוולי.
דער ערשטער שריט איז צו ראַנדאַמלי באַשטימען די ערשט בייאַסיז פון אונדזער נעץ צו יעדער שיכטע וואָס גייט נאָך די אַרייַנשרייַב שיכטע.
צום סוף, יעדער לינק צווישן די אַרייַנשרייַב און רעזולטאַט לייַערס האט זיין ווייץ ראַנדאַמלי דזשענערייטאַד. Np.Random.Randn() גיט אַ טראַפ מוסטער ציען פֿון דער נאָרמאַל פאַרשפּרייטונג פֿאַר קאָנטעקסט.
פיטער פֿאָרווערטס פֿונקציע
אין אַ נעוראַל נעץ, אינפֿאָרמאַציע איז געשיקט פאָרויס דורך די פיעדפאָרווערד פֿונקציע. איין אַרגומענט, אַ, וואָס ינדיקייץ דעם קראַנט אַקטאַוויישאַן וועקטאָר, וועט זיין פארלאנגט דורך דעם פֿונקציע.
די פֿונקציע עסטאַמאַץ די אַקטאַוויישאַנז אין יעדער שיכטע דורך יטערייטינג איבער אַלע בייאַסיז און ווייץ אין די נעץ. דער ענטפער איז די פּראָגנאָז, וואָס איז די אַקטאַוויישאַנז פון די לעצטע שיכטע.
מיני פּעקל גראַדיענט אַראָפּגאַנג
די ווערקכאָרס פון אונדזער נעטוואָרק קלאַס איז גראַדיענט אַראָפּגאַנג. אין דעם ווערסיע, מיר נוצן מיני-פּעקל (סטאָטאַסטיק) גראַדיענט אַראָפּגאַנג, אַ מאַדאַפייד ווערייישאַן פון גראַדיענט אַראָפּגאַנג.
דאָס ינדיקייץ אַז אַ קליין פּעקל פון דאַטן ווייזט וועט זיין געוויינט צו דערהייַנטיקן אונדזער מאָדעל. פיר פארלאנגט און איין אַפּשאַנאַל אַרגומענט זענען דורכגעגאנגען צו דעם אופֿן. די פיר פארלאנגט וועריאַבאַלז זענען די טריינינג דאַטן שטעלן, די נומער פון עפּאָס, די גרייס פון די מיני באַטשאַז און די לערנען קורס (עטאַ).
טעסט דאַטן זענען בנימצא אויף בעטן. מיר וועלן צושטעלן פּראָבע דאַטן ווען מיר יווענטשאַוואַלי אָפּשאַצן דעם נעץ. די נומער פון סאַמפּאַלז אין דעם פֿונקציע איז טכילעס באַשטימט צו די לענג פון דער רשימה אַמאָל די טריינינג דאַטן איז פארוואנדלען אין אַ רשימה טיפּ.
מיר אויך צולייגן די זעלבע פּראָצעס צו פּרובירן דאַטן וואָס איז געגעבן אין. דאָס איז ווייַל אַנשטאָט פון זיין אומגעקערט צו אונדז ווי רשימות, זיי זענען טאַקע זיפּס פון רשימות. ווען מיר לאָדן די MNIST דאַטן סאַמפּאַלז שפּעטער, מיר וועלן לערנען מער וועגן דעם.
אויב מיר קענען מאַכן זיכער אַז מיר צושטעלן ביידע סאָרץ פון דאַטן ווי רשימות, דעם טיפּ קאַסטינג איז ניט דאַווקע יקערדיק.
אַמאָל מיר האָבן די דאַטן, מיר גיין איבער די טריינינג עפּאָס אין אַ שלייף. א טריינינג צייַט איז בלויז איין קייַלעכיק פון נעוראַל נעץ טריינינג. מיר ערשטער שאַרן די דאַטן אין יעדער עפּאָס צו ענשור ראַנדאַמנאַס איידער מיר מאַכן אַ רשימה פון מיני-באַטשאַז.
דער דערהייַנטיקן מיני פּעקל פונקציע, וואָס איז דיסקאַסט אונטן, וועט זיין גערופֿן פֿאַר יעדער מיני פּעקל. די פּרובירן אַקיעראַסי וועט אויך זיין אומגעקערט אויב די פּרובירן דאַטן זענען בנימצא.
פּרייַז-דעריוואַטיוו העלפּער פֿונקציע
לאָמיר אַנטוויקלען אַ העלפער פֿונקציע גערופֿן קאָס דעריוואַטיוו ערשטער איידער מיר טאַקע מאַכן די באַקפּראָפּאַגאַטיאָן קאָד. אויב מיר מאַכן אַ גרייַז אין אונדזער רעזולטאַט שיכטע, די פּרייַז דעריוואַט פונקציע וועט ווייַזן עס.
עס ריקווייערז צוויי ינפּוץ: די פּראָדוקציע אַקטאַוויישאַנז מענגע און די י-קאָאָרדאַנאַץ פון די אַנטיסאַפּייטיד רעזולטאַט וואַלועס.
באַקפּראָפּאַגאַטיאָן פונקציע
אונדזער פאָרשטעלן אַקטאַוויישאַן וועקטאָר, אַקטאַוויישאַן, ווי געזונט ווי קיין אנדערע אַקטאַוויישאַן וועקטאָרס, אַקטאַוויישאַנז, און ז-וועקטאָרס, זס, מוזן אַלע זיין געהאלטן אין גייַסט. א שיכטע גערופן די אַרייַנשרייַב שיכטע איז אַקטיווייטיד ערשטער.
מיר וועלן דורכגיין יעדער פאָרורטייל און וואָג נאָך שטעלן זיי אַרויף. יעדער שלייף ינוואַלווז קאַלקיאַלייטינג די ז וועקטאָר ווי די פּונקט פּראָדוקט פון די ווייץ און די אַקטאַוויישאַן, אַדינג עס צו דער רשימה פון זס, ריקאַלקיאַלייטינג די אַקטאַוויישאַן און אַדינג די דערהייַנטיקט אַקטאַוויישאַן צו דער רשימה פון אַקטאַוויישאַנז.
צום סוף, די מאטעמאטיק. די דעלטאַ, וואָס איז גלייַך צו דער טעות פון די פריערדיקע שיכטע געמערט מיט די סיגמאָיד פּריים פון די לעצטע עלעמענט פון די זס וועקטאָרס, איז קאַמפּיוטאַד איידער מיר אָנהייבן אונדזער צוריק פאָרן.
די לעצטע שיכטע פון נאַבלאַ ב איז באַשטימט צו זיין די דעלטאַ, און די לעצט שיכטע פון נאַבלאַ וו איז באַשטימט צו זיין די פּונקט פּראָדוקט פון די דעלטאַ און די רגע-צו-לעצטע שיכטע פון אַקטאַוויישאַנז (טראַנספּאָסט אַזוי מיר קענען אַקטשאַוואַלי טאָן די מאַט) .
מיר גיינ ווייַטער ווי פריער, סטאַרטינג מיט די רגע שיכטע און קאַנקלודינג מיט די לעצטע, און איבערחזרן דעם פּראָצעס נאָך קאַמפּליטינג די לעצטע לייַערס. די נאַבלאַס זענען דעמאָלט געגעבן צוריק ווי אַ טופּלע.
אַפּדייטינג מיני-פּעקל גראַדיענט אַראָפּגאַנג
אונדזער SGD (סטאָטאַסטיק גראַדיענט אַראָפּגאַנג) אופֿן פון פריער ינקאָרפּערייץ מיני-פּעקל אַפּדייטינג. זינט עס איז יוטאַלייזד אין SGD אָבער אויך ריקווייערז באַקפּראָפּ, איך דעבאַטעד ווו צו שטעלן דעם פֿונקציע.
צום סוף, איך געמאכט די ברירה צו פּאָסטן עס דאָ. עס הייבט זיך אן מיט דזשענערייטינג 0 וועקטאָרס פון די בייאַסיז און ווייץ 'נאַבלאַס, פּונקט ווי אונדזער באַקקפּראָפּ פונקציע.
עס ריקווייערז די מיני-פּעקל און די עטאַ לערנען קורס ווי די צוויי ינפּוץ. אין די מיני-פּעקל, מיר נוצן די באַקפּראָפּ פֿונקציע צו באַקומען די דעלטאַ פון יעדער נאַבלאַ מענגע פֿאַר יעדער אַרייַנשרייַב, X, און רעזולטאַט, י. די נאַבלאַ רשימות זענען דערהייַנטיקט מיט די דעלטאַס.
צום סוף, מיר נוצן די לערנען קורס און די נאַבאַלז צו דערהייַנטיקן די ווייץ און בייאַסיז פון די נעץ. יעדער ווערט איז דערהייַנטיקט צו די מערסט פריש ווערט, ווייניקער די לערנען קורס, געמערט מיט די מיניבאַטש גרייס, און דערנאָך צוגעגעבן צו די נאַבלאַ ווערט.
אָפּשאַצן פֿונקציע
די אָפּשאַצן פֿונקציע איז די לעצט וואָס מיר דאַרפֿן צו שרייַבן. די פּראָבע דאַטן איז דער בלויז אַרייַנשרייַב פֿאַר דעם פֿונקציע. אין דעם פֿונקציע, מיר נאָר פאַרגלייַכן די אַוטפּוץ פון די נעץ מיט די אַנטיסאַפּייטיד רעזולטאַט, י. דורך פידינג די אַרייַנשרייַב, X, פאָרויס, די אַוטפּוץ פון די נעץ זענען באשלאסן.
גאַנץ קאָד
ווען מיר פאַרבינדן אַלע די קאָד, דאָס איז ווי עס אויס.
טעסטינג נעוראַל נעטוואָרק
לאָודינג MNIST דאַטן
די MNIST דאַטן איז אין .pkl.gz פֿאָרמאַט, וואָס מיר וועלן עפֿענען מיט GZIP און לאָדן מיט זויערע וגערקע. לאָמיר שרייַבן אַ שנעל אופֿן צו לאָדן די דאַטן ווי אַ טופּלע פון גרייס דריי, צעטיילט אין טריינינג, וואַלאַדיישאַן און פּרובירן דאַטן.
צו מאַכן אונדזער דאַטן גרינגער צו פירן, מיר שרייַבן אן אנדער פֿונקציע צו ענקאָוד די י אין אַ 10-נומער מענגע. די מענגע וועט זיין אַלע 0 ס אַחוץ פֿאַר אַ 1 וואָס גלייַכן די בילד ס געהעריק ציפֿער.
מיר וועלן נוצן די יקערדיק לאָדן דאַטן און איין הייס ענקאָוד אופֿן צו לאָדן אונדזער דאַטן אין אַ ליינעוודיק פֿאָרמאַט. אן אנדער פֿונקציע וועט זיין געשריבן וואָס וועט גער אונדזער X וואַלועס אין אַ רשימה פון גרייס 784, וואָס ריכטן זיך צו די בילד ס 784 בילדצעלן, און אונדזער י וואַלועס אין זייער איין הייס ענקאָודיד וועקטאָר פאָרעם.
דערנאָך מיר פאַרבינדן די X און y וואַלועס אַזוי אַז איין אינדעקס גלייַכן די אנדערע. דאָס אַפּלייז צו די טריינינג, וואַלאַדיישאַן און פּרובירן דאַטן שטעלט. מיר דעמאָלט צוריקקומען די געביטן דאַטן.
פליסנדיק טעסץ
מיר וועלן מאַכן אַ נייַע טעקע גערופֿן "מניסט לאָודער" וואָס וועט אַרייַנפיר ביידע די נעוראַל נעץ וואָס מיר האָבן געגרינדעט פריער (פּשוט נן) און די MNIST דאַטן סעט לאָודער איידער מיר אָנהייבן טעסטינג.
אין דעם טעקע, אַלע מיר דאַרפֿן צו טאָן איז אַרייַנפיר די דאַטן, בויען אַ נעץ מיט אַ אַרייַנשרייַב שיכטע גרייס פון 784 און אַ רעזולטאַט שיכטע גרייס פון 10, לויפן די נעץ SGD פונקציע אויף די טריינינג דאַטן, און פּרובירן עס מיט די פּראָבע דאַטן.
האַלטן אין מיינונג אַז פֿאַר אונדזער רשימה פון אַרייַנשרייַב לייַערס, עס מאכט קיין חילוק וואָס קיין פון די נומערן זענען צווישן 784 און 10. מיר קענען טוישן די אנדערע לייַערס ווי מיר ווי; נאָר די אַרייַנשרייַב און רעזולטאַט סיזעס זענען פאַרפעסטיקט.
דריי לייַערס זענען ניט נייטיק; מיר קענען נוצן פיר, פינף אָדער אפילו בלויז צוויי. האָבן שפּאַס עקספּערימענטינג מיט אים.
סאָף
דאָ, ניצן Python 3, מיר שאַפֿן אַ נעוראַל נעץ פֿון קראַצן. צוזאמען מיט הויך-מדרגה מאַט, מיר אויך דיסקאַסט די ספּיסיפיקס פון ימפּלאַמענטיישאַן.
מיר אנגעהויבן מיט ימפּלאַמענינג העלפּער פאַנגקשאַנז. פֿאַר די נוראַנז צו אַרבעטן, די סיגמאָיד און סיגמאָיד הויפּט פאַנגקשאַנז זענען קריטיש. דערנאָך מיר נוצן די פיעדפאָרווערד פונקציע, וואָס איז די פונדאַמענטאַל פּראָצעס פֿאַר פידינג דאַטן אין די נעוראַל נעץ.
דערנאָך, מיר באשאפן די גראַדיענט אַראָפּגאַנג פונקציע אין פּיטהאָן, דער מאָטאָר וואָס דרייווז אונדזער נעוראַל נעץ. אין סדר צו געפֿינען "היגע מינימאַ" און אַפּטאַמייז זייער ווייץ און בייאַסיז, אונדזער נעוראַל נעץ ניצט גראַדיענט אַראָפּגאַנג. מיר באשאפן די באַקפּראָפּאַגאַטיאָן פונקציע ניצן גראַדיענט אַראָפּגאַנג.
דורך דעליווערינג דערהייַנטיקונגען ווען די אַוטפּוץ טאָן ניט גלייַכן די געהעריק לאַבעלס, די פונקציע ינייבאַלז די נעוראַל נעץ צו "לערנען."
צום סוף, מיר שטעלן אונדזער שפּאָגל נייַ פּיטהאָן נעוראַל נעץ צו די פּראָבע ניצן די MNIST דאַטן שטעלן. אַלץ פֿונקציאָנירט גלאַט.
מזל קאָדירונג!
לאָזן אַ ענטפֿערן