אַרטיפיסיאַל ינטעלליגענסע (AI) האט פארדינט אַ באַטייטיק סומע פון פּאָפּולאַריטעט אין די לעצטע יאָרן.
אויב איר זענט אַ ווייכווארג ינזשעניר, קאָמפּיוטער געלערנטער אָדער דאַטן וויסנשאַפֿט ענטוזיאַסט אין אַלגעמיין, איר זענט מיסטאָמע ינטריגד דורך די אַמייזינג אַפּלאַקיישאַנז פון בילד פּראַסעסינג, מוסטער דערקענונג און כייפעץ דיטעקשאַן צוגעשטעלט דורך דעם פעלד.
די מערסט וויכטיק סובפיעלד פון אַי וואָס איר מיסטאָמע געהערט וועגן איז דיפּ לערנען. דעם פעלד פאָוקיסיז אויף שטאַרק אַלגערידאַמז (קאָמפּיוטער פּראָגראַם ינסטראַקשאַנז) מאָדעלעד נאָך מענטש מאַרך פאַנגקשאַנאַליטי באקאנט ווי נעוראַל נעטוואָרקס.
אין דעם אַרטיקל, מיר וועלן גיין איבער דעם באַגריף פון נעוראַל נעטוואָרקס און ווי צו בויען, צונויפנעמען, פּאַסיק און אָפּשאַצן די מאָדעלס ניצן פּיטהאָן.
נעוראַל נעטוואָרקס
נעוראַל נעטוואָרקס, אָדער NNs, זענען אַ סעריע פון אַלגערידאַמז מאָדעלעד נאָך די בייאַלאַדזשיקאַל טעטיקייט פון דעם מענטש מאַרך. נעוראַל נעטוואָרקס צונויפשטעלנ זיך פון נאָודז, אויך גערופן נוראַנז.
א זאַמלונג פון ווערטיקאַל נאָודז זענען באקאנט ווי לייַערס. דער מאָדעל באשטייט פון איין אַרייַנשרייַב, איין רעזולטאַט און אַ נומער פון פאַרבאָרגן לייַערס. יעדער שיכטע באשטייט פון נאָודז, אויך גערופן נוראַנז, ווו די חשבונות נעמען אָרט.
אין די פאלגענדע דיאַגראַמע, די קרייזן פאָרשטעלן די נאָודז און די ווערטיקאַל זאַמלונג פון נאָודז פאָרשטעלן די לייַערס. עס זענען דריי לייַערס אין דעם מאָדעל.
די נאָודז פון איין שיכטע זענען פארבונדן צו דער ווייַטער שיכטע דורך טראַנסמיסיע שורות ווי געוויזן אונטן.
אונדזער דאַטאַבייס באשטייט פון לייבאַלד דאַטן. דעם מיטל אַז יעדער דאַטן ענטיטי איז אַסיינד אַ זיכער נאָמען ווערט.
אַזוי פֿאַר אַ כייַע קלאַסאַפאַקיישאַן דאַטאַסעט מיר וועלן האָבן בילדער פון קאַץ און הינט ווי אונדזער דאַטן, מיט 'קאַץ' און 'הונט' ווי אונדזער לאַבעלס.
עס איז וויכטיק צו טאָן אַז לאַבעלס דאַרפֿן צו זיין קאָנווערטעד צו נומעריקאַל וואַלועס פֿאַר אונדזער מאָדעל צו מאַכן זינען פון זיי, אַזוי אונדזער כייַע לאַבעלס ווערן '0' פֿאַר קאַץ און '1' פֿאַר הונט. ביידע די דאַטן און די לאַבעלס זענען דורכגעגאנגען דורך די מאָדעל.
וויסן
דאַטן זענען פאסטעכער צו די מאָדעל איין ענטיטי אין אַ צייַט. די דאַטן זענען צעבראכן אין טשאַנגקס און דורכגעגאנגען דורך יעדער נאָדע פון די מאָדעל. נאָדעס דורכפירן מאַטאַמאַטיקאַל אַפּעריישאַנז אויף די שטיקער.
איר טאָן ניט דאַרפֿן צו וויסן די מאַטאַמאַטיקאַל פאַנגקשאַנז אָדער חשבונות פֿאַר דעם טוטאָריאַל, אָבער עס איז וויכטיק צו האָבן אַ גענעראַל געדאַנק פון ווי די מאָדעלס אַרבעט. נאָך אַ סעריע פון חשבונות אין איין שיכטע, דאַטן זענען דורכגעגאנגען אויף דער ווייַטער שיכטע און אַזוי אויף.
אַמאָל געענדיקט, אונדזער מאָדעל פּרידיקס די דאַטן פירמע אין די רעזולטאַט שיכטע (למשל, אין אַ כייַע קלאַסאַפאַקיישאַן פּראָבלעם מיר באַקומען אַ פּראָגנאָז '0' פֿאַר אַ קאַץ).
דער מאָדעל דעמאָלט לייזונג צו פאַרגלייַכן דעם פּרעדיקטעד ווערט מיט די פון די פאַקטיש פירמע ווערט.
אויב די וואַלועס גלייַכן, אונדזער מאָדעל וועט נעמען די ווייַטער אַרייַנשרייַב אָבער אויב די וואַלועס אַנדערש, דער מאָדעל וועט רעכענען די חילוק צווישן ביידע וואַלועס, גערופֿן אָנווער, און סטרויערן די נאָדע חשבונות צו פּראָדוצירן וואָס ריכטן לאַבעלס ווייַטער מאָל.
דיפּ לערנען פראַמעוואָרקס
צו בויען נעוראַל נעטוואָרקס אין קאָד, מיר דאַרפֿן צו אַרייַנפיר טיף לערנען פראַמעוואָרקס באקאנט ווי לייברעריז ניצן אונדזער ינטעגראַטעד אנטוויקלונג סוויווע (IDE).
די פראַמעוואָרקס זענען אַ זאַמלונג פון פאַר-געשריבן פאַנגקשאַנז וואָס וועט העלפֿן אונדז אין דעם טוטאָריאַל. מיר וועלן נוצן די Keras פריימווערק צו בויען אונדזער מאָדעל.
Keras איז אַ פּיטהאָן ביבליאָטעק וואָס ניצט אַ טיף לערנען און קינסטלעך סייכל באַקענד גערופן טענסאָרפלאָוו צו שאַפֿן NNs אין די פאָרעם פון פּשוט סאַקווענטשאַל מאָדעלס מיט יז.
Keras אויך קומט מיט זיין אייגענע פּרייגזיסטינג מאָדעלס וואָס קענען זיין געוויינט ווי געזונט. פֿאַר דעם טוטאָריאַל, מיר וועלן שאַפֿן אונדזער אייגענע מאָדעל מיט Keras.
איר קענט לערנען מער וועגן דעם Deep Learning פריימווערק פֿון די Keras וועבזייטל.
בויען אַ נעוראַל נעץ (טוטאָריאַל)
לאָמיר פאָרזעצן צו בויען אַ נעוראַל נעטוואָרק ניצן פּיטהאָן.
פּראָבלעם סטאַטעמענט
נעוראַל נעטוואָרקס זענען אַ טיפּ פון לייזונג צו אַי-באזירט פּראָבלעמס. פֿאַר דעם טוטאָריאַל מיר וועלן גיין איבער די פּימאַ ינדיאַנס צוקערקרענק דאַטאַ, וואָס איז בנימצא דאָ.
ICU מאַשין לערנען האט צונויפגעשטעלט דעם דאַטאַסעט און כּולל אַ מעדיציניש רעקאָרד פון ינדיאַן פּאַטיענץ. אונדזער מאָדעל דאַרף פאָרויסזאָגן צי דער פּאַציענט האט אַן אָנסעט פון צוקערקרענק אין 5 יאָר אָדער נישט.
לאָודינג דאַטאַסעט
אונדזער דאַטאַסעט איז אַ איין קסוו טעקע גערופֿן 'diabetes.csv' וואָס קענען זיין מאַניפּיאַלייטיד מיט Microsoft Excel.
איידער קריייטינג אונדזער מאָדעל, מיר דאַרפֿן צו אַרייַנפיר אונדזער דאַטאַסעט. ניצן די פאלגענדע קאָד איר קענען טאָן דאָס:
אַרייַנפיר פּאַנדאַס ווי פּד
דאַטן = pd.read_csv('diabetes.csv')
x = data.drop ("אַוטקאַם")
י = דאַטן ["אַוטקאַם"]
דאָ מיר זענען ניצן די פּאַנדאַס ביבליאָטעק צו קענען מאַניפּולירן אונדזער CSV טעקע דאַטן, read_csv () איז אַ געבויט-אין פונקציע פון פּאַנדאַס וואָס אַלאַוז אונדז צו קראָם די וואַלועס אין אונדזער טעקע צו אַ בייַטעוודיק גערופֿן 'דאַטן'.
די בייַטעוודיק X כּולל אונדזער דאַטאַסעט אָן די אַוטקאַם (לאַבעלס) דאַטן. מיר דערגרייכן דעם מיט די data.drop() פֿונקציע וואָס רימוווז די לאַבעלס פֿאַר X, בשעת י כּולל בלויז די אַוטקאַם (לייבל) דאַטן.
בנין סאַקווענטשאַל מאָדעל
שריט 1: ימפּאָרטינג ליבראַריעס
ערשטער, מיר דאַרפֿן צו אַרייַנפיר TensorFlow און Keras, צוזאַמען מיט זיכער פּאַראַמעטערס פארלאנגט פֿאַר אונדזער מאָדעל. די פאלגענדע קאָד אַלאַוז אונדז צו טאָן דאָס:
אַרייַנפיר טענסאָרפלאָוו ווי tf
פֿון טענסאָרפלאָוו אַרייַנפיר קעראַס
פון tensorflow.keras.models אַרייַנפיר סאַקווענטשאַל
פֿון tensorflow.keras.layers אַרייַנפיר אַקטיוואַטיאָן, דענס
פֿון tensorflow.keras.optimizers אַרייַנפיר אַדאַם
פֿון tensorflow.keras.metrics אַרייַנפיר קאַטאַגאָריקאַל_קראָססענטראָפּי
פֿאַר אונדזער מאָדעל מיר זענען ימפּאָרטינג געדיכט לייַערס. דאס זענען גאָר פארבונדן לייַערס; הייסט, יעדער נאָדע אין אַ שיכטע איז גאָר קאָננעקטעד מיט אן אנדער נאָדע אין דער ווייַטער שיכטע.
מיר זענען אויך ימפּאָרטינג אַ אַקטאַוויישאַן פונקציע דארף פֿאַר סקיילינג דאַטן געשיקט צו נאָודז. אָפּטימיזערס האָבן אויך געווען ימפּאָרטיד צו מינאַמייז אָנווער.
Adam איז אַ באַרימט אָפּטימיזער וואָס מאכט אונדזער מאָדעל דערהייַנטיקן נאָדע חשבונות מער יפישאַנטלי, צוזאַמען מיט categorical_crossentropy וואָס איז דער טיפּ פון אָנווער פונקציע (קאַלקיאַלייץ די חילוק צווישן פאַקטיש און פּרעדיקטעד פירמע וואַלועס) וואָס מיר וועלן נוצן.
שריט 2: דיזיינינג אונדזער מאָדעל
דער מאָדעל איך קריייטינג האט איין אַרייַנשרייַב (מיט 16 וניץ), איינער פאַרבאָרגן (מיט 32 וניץ) און איין רעזולטאַט (מיט 2 וניץ) שיכטע. די נומערן זענען נישט פאַרפעסטיקט און וועט אָפענגען לעגאַמרע אויף די געגעבן פּראָבלעם.
באַשטעטיקן די רעכט נומער פון וניץ און לייַערס איז אַ פּראָצעס וואָס קענען זיין ימפּרוווד אָוווערטיים דורך פיר. אַקטאַוויישאַן קאָראַספּאַנדז צו די טיפּ פון סקיילינג מיר וועלן דורכפירן אויף אונדזער דאַטן איידער זיי פאָרן דורך אַ נאָדע.
Relu און Softmax זענען באַרימט אַקטאַוויישאַן פאַנגקשאַנז פֿאַר דעם אַרבעט.
מאָדעל = סאַקווענטשאַל ([
געדיכט (וניץ = 16, input_shape = (1,), אַקטאַוויישאַן = 'רעלו'),
געדיכט (וניץ = 32, אַקטאַוויישאַן = 'רעלו'),
געדיכט (וניץ = 2, אַקטאַוויישאַן = 'סאָפטמאַקס')
])
דאָ איז ווי די קיצער פון די מאָדעל זאָל קוקן ווי:
טריינינג די מאָדעל
אונדזער מאָדעל וועט זיין טריינד אין צוויי סטעפּס, דער ערשטער איז קאַמפּיילינג די מאָדעל (שטעלן די מאָדעל צוזאַמען) און דער ווייַטער איז צופּאַסן די מאָדעל אויף אַ געגעבן דאַטאַסעט.
דעם קענען זיין געטאן מיט די model.compile () פֿונקציע נאכגעגאנגען דורך די model.fit () פֿונקציע.
model.compile (אָפּטימיזער = אַדאַם (לערנינג_ראַטע = 0.0001), אָנווער = 'בינאַרי_קראָססענטראָפּי', מעטריקס = ['פּינטלעכקייט'])
model.fit (רענטגענ, י, עפּאָס = 30, באַטש_סייז = 10)
ספּעציפיצירן די 'פּינטלעכקייַט' מעטריק אַלאַוז אונדז צו אָבסערווירן די אַקיעראַסי פון אונדזער מאָדעל בעשאַס טריינינג.
זינט אונדזער לאַבעלס זענען אין די פאָרעם פון 1 ס און 0 ס, מיר וועלן נוצן אַ ביינערי אָנווער פונקציע צו רעכענען די חילוק צווישן פאַקטיש און פּרעדיקטעד לאַבעלס.
די דאַטאַסעט איז אויך שפּאַלטן אין באַטשאַז פון 10 (באַטש_סייז) און וועט זיין דורכגעגאנגען דורך די מאָדעל 30 מאל (עפּאָקס). פֿאַר אַ געגעבן דאַטאַסעט, x וואָלט זיין די דאַטן און י וואָלט זיין די לאַבעלס קאָראַספּאַנדינג צו די דאַטן.
טעסטינג מאָדעל ניצן פּרעדיקטיאָנס
צו אָפּשאַצן אונדזער מאָדעל, מיר מאַכן פֿאָרויסזאָגן אויף די פּראָבע דאַטן מיט די פאָרויסזאָגן () פֿונקציע.
פֿאָרויסזאָגן = מאָדעל.פּרעדיקט (רענטגענ)
און דאָס איז עס!
איר זאָל איצט האָבן אַ גוט פארשטאנד פון די Deep Learning אַפּלאַקיישאַן, נעוראַל נעטוואָרקס, ווי זיי אַרבעט אין אַלגעמיין און ווי צו בויען, באַן און פּרובירן אַ מאָדעל אין פּיטהאָן קאָד.
איך האָפֿן דעם טוטאָריאַל גיט איר די קיקקסטאַרט צו שאַפֿן און צעוויקלען דיין אייגענע דיפּ לערנען מאָדעלס.
לאָזן אונדז וויסן אין די באַמערקונגען אויב דער אַרטיקל איז נוציק.
לאָזן אַ ענטפֿערן