ML-For-Beginners/translations/he/3-Web-App/1-Web-App

בניית אפליקציית אינטרנט לשימוש במודל למידת מכונה

בשיעור הזה, תאמנו מודל למידת מכונה על סט נתונים יוצא דופן: תצפיות עב"מים במאה האחרונה, שנאספו ממאגר הנתונים של NUFORC.

תלמדו:

• איך 'לשמר' מודל מאומן
• איך להשתמש במודל הזה באפליקציית Flask

נמשיך להשתמש במחברות לניקוי נתונים ולאימון המודל שלנו, אבל תוכלו לקחת את התהליך צעד אחד קדימה על ידי חקר השימוש במודל "בשדה", כלומר: באפליקציית אינטרנט.

כדי לעשות זאת, תצטרכו לבנות אפליקציית אינטרנט באמצעות Flask.

שאלון לפני השיעור

בניית אפליקציה

ישנן מספר דרכים לבנות אפליקציות אינטרנט לצריכת מודלים של למידת מכונה. הארכיטקטורה של האינטרנט שלכם עשויה להשפיע על הדרך שבה המודל שלכם מאומן. דמיינו שאתם עובדים בעסק שבו קבוצת מדעני הנתונים אימנה מודל שהם רוצים שתשתמשו בו באפליקציה.

שיקולים

ישנן שאלות רבות שעליכם לשאול:

• האם זו אפליקציית אינטרנט או אפליקציה לנייד? אם אתם בונים אפליקציה לנייד או צריכים להשתמש במודל בהקשר של IoT, תוכלו להשתמש ב-TensorFlow Lite ולהשתמש במודל באפליקציות אנדרואיד או iOS.
• היכן המודל יימצא? בענן או מקומית?
• תמיכה לא מקוונת. האם האפליקציה צריכה לעבוד במצב לא מקוון?
• איזו טכנולוגיה שימשה לאימון המודל? הטכנולוגיה שנבחרה עשויה להשפיע על הכלים שתצטרכו להשתמש בהם.
  • שימוש ב-TensorFlow. אם אתם מאמנים מודל באמצעות TensorFlow, למשל, האקוסיסטם הזה מספק את היכולת להמיר מודל TensorFlow לשימוש באפליקציית אינטרנט באמצעות TensorFlow.js.
  • שימוש ב-PyTorch. אם אתם בונים מודל באמצעות ספרייה כמו PyTorch, יש לכם אפשרות לייצא אותו בפורמט ONNX (Open Neural Network Exchange) לשימוש באפליקציות אינטרנט JavaScript שיכולות להשתמש ב-Onnx Runtime. אפשרות זו תיחקר בשיעור עתידי עבור מודל שאומן באמצעות Scikit-learn.
  • שימוש ב-Lobe.ai או Azure Custom Vision. אם אתם משתמשים במערכת SaaS (תוכנה כשירות) ללמידת מכונה כמו Lobe.ai או Azure Custom Vision לאימון מודל, סוג זה של תוכנה מספק דרכים לייצא את המודל לפלטפורמות רבות, כולל בניית API מותאם אישית שניתן לשאול בענן על ידי האפליקציה המקוונת שלכם.

יש לכם גם את האפשרות לבנות אפליקציית אינטרנט שלמה ב-Flask שתוכל לאמן את המודל בעצמה בדפדפן אינטרנט. ניתן לעשות זאת גם באמצעות TensorFlow.js בהקשר של JavaScript.

למטרותינו, מכיוון שעבדנו עם מחברות מבוססות Python, בואו נחקור את השלבים שעליכם לבצע כדי לייצא מודל מאומן ממחברת כזו לפורמט שניתן לקריאה על ידי אפליקציית אינטרנט שנבנתה ב-Python.

כלי

למשימה זו, תצטרכו שני כלים: Flask ו-Pickle, שניהם פועלים על Python.

✅ מהו Flask? מוגדר כ'מיקרו-פריימוורק' על ידי יוצריו, Flask מספק את התכונות הבסיסיות של פריימוורקים לאינטרנט באמצעות Python ומנוע תבניות לבניית דפי אינטרנט. עיינו ב-מודול הלמידה הזה כדי לתרגל בנייה עם Flask.

✅ מהו Pickle? Pickle 🥒 הוא מודול Python שמבצע סריאליזציה ודס-סריאליזציה של מבנה אובייקט ב-Python. כשאתם 'משמרים' מודל, אתם מבצעים סריאליזציה או משטחים את המבנה שלו לשימוש באינטרנט. שימו לב: Pickle אינו בטוח באופן אינהרנטי, אז היו זהירים אם תתבקשו 'לפרוק' קובץ. קובץ משומר מסומן בסיומת .pkl.

תרגיל - ניקוי הנתונים שלכם

בשיעור הזה תשתמשו בנתונים מ-80,000 תצפיות עב"מים, שנאספו על ידי NUFORC (המרכז הלאומי לדיווח על עב"מים). לנתונים האלה יש תיאורים מעניינים של תצפיות עב"מים, לדוגמה:

• תיאור ארוך לדוגמה. "אדם יוצא מקרן אור שמאירה על שדה דשא בלילה ורץ לכיוון מגרש החניה של Texas Instruments".
• תיאור קצר לדוגמה. "האורות רדפו אחרינו".

גיליון הנתונים ufos.csv כולל עמודות על עיר, מדינה וארץ שבהן התצפית התרחשה, צורה של האובייקט וקו רוחב וקו אורך.

ב-מחברת הריקה שמצורפת לשיעור הזה:

1. ייבאו את pandas, matplotlib, ו-numpy כפי שעשיתם בשיעורים קודמים וייבאו את גיליון הנתונים של עב"מים. תוכלו להסתכל על דוגמת סט נתונים:

   import pandas as pd
   import numpy as np
   
   ufos = pd.read_csv('./data/ufos.csv')
   ufos.head()
   

2. המירו את נתוני העב"מים למסגרת נתונים קטנה עם כותרות חדשות. בדקו את הערכים הייחודיים בשדה Country.

   ufos = pd.DataFrame({'Seconds': ufos['duration (seconds)'], 'Country': ufos['country'],'Latitude': ufos['latitude'],'Longitude': ufos['longitude']})
   
   ufos.Country.unique()
   

3. עכשיו, תוכלו לצמצם את כמות הנתונים שעלינו להתמודד איתם על ידי הסרת ערכים ריקים וייבוא תצפיות בין 1-60 שניות בלבד:

   ufos.dropna(inplace=True)
   
   ufos = ufos[(ufos['Seconds'] >= 1) & (ufos['Seconds'] <= 60)]
   
   ufos.info()
   

4. ייבאו את ספריית LabelEncoder של Scikit-learn כדי להמיר את ערכי הטקסט של מדינות למספר:

   ✅ LabelEncoder מקודד נתונים לפי סדר אלפביתי

   from sklearn.preprocessing import LabelEncoder
   
   ufos['Country'] = LabelEncoder().fit_transform(ufos['Country'])
   
   ufos.head()
   

   הנתונים שלכם צריכים להיראות כך:

   	Seconds	Country	Latitude	Longitude
   2	20.0	3		53.200000	-2.916667
   3	20.0	4		28.978333	-96.645833
   14	30.0	4		35.823889	-80.253611
   23	60.0	4		45.582778	-122.352222
   24	3.0		3		51.783333	-0.783333
   

תרגיל - בניית המודל שלכם

עכשיו תוכלו להתכונן לאמן מודל על ידי חלוקת הנתונים לקבוצת אימון ובדיקה.

1. בחרו את שלושת המאפיינים שתרצו לאמן עליהם כוקטור X שלכם, והוקטור y יהיה Country. אתם רוצים להיות מסוגלים להזין Seconds, Latitude ו-Longitude ולקבל מזהה מדינה להחזרה.

   from sklearn.model_selection import train_test_split
   
   Selected_features = ['Seconds','Latitude','Longitude']
   
   X = ufos[Selected_features]
   y = ufos['Country']
   
   X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
   

2. אימנו את המודל שלכם באמצעות רגרסיה לוגיסטית:

   from sklearn.metrics import accuracy_score, classification_report
   from sklearn.linear_model import LogisticRegression
   model = LogisticRegression()
   model.fit(X_train, y_train)
   predictions = model.predict(X_test)
   
   print(classification_report(y_test, predictions))
   print('Predicted labels: ', predictions)
   print('Accuracy: ', accuracy_score(y_test, predictions))
   

הדיוק לא רע (כ-95%), ולא מפתיע, מכיוון ש-Country ו-Latitude/Longitude מתואמים.

המודל שיצרתם אינו מאוד מהפכני מכיוון שאתם אמורים להיות מסוגלים להסיק Country מ-Latitude ו-Longitude, אבל זהו תרגיל טוב לנסות לאמן מנתונים גולמיים שניקיתם, ייצאתם, ואז להשתמש במודל הזה באפליקציית אינטרנט.

תרגיל - 'שימור' המודל שלכם

עכשיו, הגיע הזמן לשמר את המודל שלכם! תוכלו לעשות זאת בכמה שורות קוד. לאחר שהוא משומר, טענו את המודל המשומר ובדקו אותו מול מערך נתונים לדוגמה שמכיל ערכים עבור שניות, קו רוחב וקו אורך.

import pickle
model_filename = 'ufo-model.pkl'
pickle.dump(model, open(model_filename,'wb'))

model = pickle.load(open('ufo-model.pkl','rb'))
print(model.predict([[50,44,-12]]))

המודל מחזיר '3', שזהו קוד המדינה עבור בריטניה. מדהים! 👽

תרגיל - בניית אפליקציית Flask

עכשיו תוכלו לבנות אפליקציית Flask שתוכל לקרוא את המודל שלכם ולהחזיר תוצאות דומות, אבל בצורה יותר נעימה לעין.

1. התחילו ביצירת תיקייה בשם web-app ליד קובץ notebook.ipynb שבו נמצא קובץ ufo-model.pkl שלכם.

2. בתיקייה הזו צרו עוד שלוש תיקיות: static, עם תיקייה css בתוכה, ו-templates. עכשיו אמורים להיות לכם הקבצים והתיקיות הבאים:

   web-app/
     static/
       css/
     templates/
   notebook.ipynb
   ufo-model.pkl
   

   ✅ עיינו בתיקיית הפתרון כדי לראות את האפליקציה המוגמרת

3. הקובץ הראשון שיש ליצור בתיקיית web-app הוא קובץ requirements.txt. כמו package.json באפליקציית JavaScript, קובץ זה מפרט את התלויות הנדרשות על ידי האפליקציה. ב-requirements.txt הוסיפו את השורות:

   scikit-learn
   pandas
   numpy
   flask
   

4. עכשיו, הריצו את הקובץ הזה על ידי ניווט ל-web-app:

   cd web-app
   

5. בטרמינל שלכם הקלידו pip install, כדי להתקין את הספריות המפורטות ב-requirements.txt:

   pip install -r requirements.txt
   

6. עכשיו, אתם מוכנים ליצור עוד שלושה קבצים כדי לסיים את האפליקציה:

   1. צרו app.py בשורש.
   2. צרו index.html בתיקיית templates.
   3. צרו styles.css בתיקיית static/css.

7. בנו את קובץ styles.css עם כמה סגנונות:

   body {
   	width: 100%;
   	height: 100%;
   	font-family: 'Helvetica';
   	background: black;
   	color: #fff;
   	text-align: center;
   	letter-spacing: 1.4px;
   	font-size: 30px;
   }
   
   input {
   	min-width: 150px;
   }
   
   .grid {
   	width: 300px;
   	border: 1px solid #2d2d2d;
   	display: grid;
   	justify-content: center;
   	margin: 20px auto;
   }
   
   .box {
   	color: #fff;
   	background: #2d2d2d;
   	padding: 12px;
   	display: inline-block;
   }
   

8. לאחר מכן, בנו את קובץ index.html:

   <!DOCTYPE html>
   <html>
     <head>
       <meta charset="UTF-8">
       <title>🛸 UFO Appearance Prediction! 👽</title>
       <link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
     </head>
   
     <body>
       <div class="grid">
   
         <div class="box">
   
           <p>According to the number of seconds, latitude and longitude, which country is likely to have reported seeing a UFO?</p>
   
           <form action="{{ url_for('predict')}}" method="post">
             <input type="number" name="seconds" placeholder="Seconds" required="required" min="0" max="60" />
             <input type="text" name="latitude" placeholder="Latitude" required="required" />
             <input type="text" name="longitude" placeholder="Longitude" required="required" />
             <button type="submit" class="btn">Predict country where the UFO is seen</button>
           </form>
   
           <p>{{ prediction_text }}</p>
   
         </div>
   
       </div>
   
     </body>
   </html>
   

   שימו לב לתבניות בקובץ הזה. שימו לב לסינטקס 'mustache' סביב משתנים שיסופקו על ידי האפליקציה, כמו טקסט התחזית: {{}}. יש גם טופס ששולח תחזית לנתיב /predict.

   לבסוף, אתם מוכנים לבנות את קובץ ה-Python שמניע את צריכת המודל והצגת התחזיות:

9. ב-app.py הוסיפו:

   import numpy as np
   from flask import Flask, request, render_template
   import pickle
   
   app = Flask(__name__)
   
   model = pickle.load(open("./ufo-model.pkl", "rb"))
   
   
   @app.route("/")
   def home():
       return render_template("index.html")
   
   
   @app.route("/predict", methods=["POST"])
   def predict():
   
       int_features = [int(x) for x in request.form.values()]
       final_features = [np.array(int_features)]
       prediction = model.predict(final_features)
   
       output = prediction[0]
   
       countries = ["Australia", "Canada", "Germany", "UK", "US"]
   
       return render_template(
           "index.html", prediction_text="Likely country: {}".format(countries[output])
       )
   
   
   if __name__ == "__main__":
       app.run(debug=True)
   

   💡 טיפ: כשאתם מוסיפים debug=True בזמן הרצת אפליקציית האינטרנט באמצעות Flask, כל שינוי שתעשו באפליקציה שלכם ישתקף מיד ללא צורך להפעיל מחדש את השרת. שימו לב! אל תפעילו מצב זה באפליקציה בסביבת ייצור.

אם תריצו python app.py או python3 app.py - שרת האינטרנט שלכם יתחיל לפעול, מקומית, ותוכלו למלא טופס קצר כדי לקבל תשובה לשאלה הבוערת שלכם על היכן נצפו עב"מים!

לפני שתעשו זאת, הסתכלו על החלקים של app.py:

1. קודם כל, התלויות נטענות והאפליקציה מתחילה.
2. לאחר מכן, המודל מיובא.
3. לאחר מכן, index.html מוצג בנתיב הבית.

בנתיב /predict, מספר דברים קורים כשהטופס נשלח:

1. משתני הטופס נאספים ומומרים למערך numpy. הם נשלחים למודל ותחזית מוחזרת.
2. המדינות שאנחנו רוצים להציג מוצגות מחדש כטקסט קריא מקוד המדינה החזוי שלהן, והערך הזה נשלח חזרה ל-index.html כדי להיות מוצג בתבנית.

שימוש במודל בדרך זו, עם Flask ומודל משומר, הוא יחסית פשוט. הדבר הקשה ביותר הוא להבין באיזו צורה הנתונים צריכים להיות כדי להישלח למודל ולקבל תחזית. זה תלוי לחלוטין באיך המודל אומן. למודל הזה יש שלוש נקודות נתונים שצריך להזין כדי לקבל תחזית.

בסביבה מקצועית, תוכלו לראות עד כמה תקשורת טובה היא הכרחית בין האנשים שמאמנים את המודל לבין אלה שצורכים אותו באפליקציית אינטרנט או נייד. במקרה שלנו, זה רק אדם אחד, אתם!

---

🚀 אתגר

במקום לעבוד במחברת ולייבא את המודל לאפליקציית Flask, תוכלו לאמן את המודל ממש בתוך אפליקציית Flask! נסו להמיר את קוד ה-Python במחברת, אולי לאחר ניקוי הנתונים שלכם, כדי לאמן את המודל מתוך האפליקציה בנתיב שנקרא train. מה היתרונות והחסרונות של שיטה זו?

שאלון אחרי השיעור

סקירה ולימוד עצמי

ישנן דרכים רבות לבנות אפליקציית אינטרנט לצריכת מודלים של למידת מכונה. הכינו רשימה של הדרכים שבהן תוכלו להשתמש ב-JavaScript או Python כדי לבנות אפליקציית אינטרנט שתנצל למידת מכונה. שקלו ארכיטקטורה: האם המודל צריך להישאר באפליקציה או לחיות בענן? אם האפשרות השנייה, איך הייתם ניגשים אליו? ציירו מודל ארכיטקטוני לפתרון אינטרנטי של למידת מכונה.

משימה

נסו מודל אחר

---

כתב ויתור:
מסמך זה תורגם באמצעות שירות תרגום מבוסס בינה מלאכותית Co-op Translator. למרות שאנו שואפים לדיוק, יש לקחת בחשבון שתרגומים אוטומטיים עשויים להכיל שגיאות או אי דיוקים. המסמך המקורי בשפתו המקורית צריך להיחשב כמקור סמכותי. עבור מידע קריטי, מומלץ להשתמש בתרגום מקצועי על ידי אדם. איננו נושאים באחריות לאי הבנות או לפרשנויות שגויות הנובעות משימוש בתרגום זה.