From 9ef8781b5471c70c54d51cd49f7b11daaddd2b5e Mon Sep 17 00:00:00 2001 From: "localizeflow[bot]" Date: Wed, 8 Jul 2026 16:18:50 +0000 Subject: [PATCH] chore(i18n): sync translations with latest source changes (chunk 1/1, 17 changes) --- translations/he/.co-op-translator.json | 44 +++++- translations/he/CONTRIBUTING.md | 29 ++++ translations/he/examples/README.md | 74 ++++----- .../TransferLearningTF.ipynb | 140 +++++++++--------- translations/he/lessons/5-NLP/README.md | 80 +++++----- translations/id/.co-op-translator.json | 37 ++++- translations/id/CONTRIBUTING.md | 29 ++++ translations/id/examples/README.md | 56 +++---- .../id/lessons/0-course-setup/how-to-run.md | 36 ++--- .../TransferLearningTF.ipynb | 129 ++++++++-------- translations/id/lessons/5-NLP/README.md | 58 ++++---- translations/vi/.co-op-translator.json | 37 ++++- translations/vi/CONTRIBUTING.md | 29 ++++ translations/vi/examples/README.md | 82 +++++----- .../vi/lessons/0-course-setup/how-to-run.md | 52 +++---- .../TransferLearningTF.ipynb | 136 ++++++++--------- translations/vi/lessons/5-NLP/README.md | 68 ++++----- 17 files changed, 652 insertions(+), 464 deletions(-) create mode 100644 translations/he/CONTRIBUTING.md create mode 100644 translations/id/CONTRIBUTING.md create mode 100644 translations/vi/CONTRIBUTING.md diff --git a/translations/he/.co-op-translator.json b/translations/he/.co-op-translator.json index 02b2e603..f66cd4d0 100644 --- a/translations/he/.co-op-translator.json +++ b/translations/he/.co-op-translator.json @@ -5,6 +5,12 @@ "source_file": "AGENTS.md", "language_code": "he" }, + "CONTRIBUTING.md": { + "original_hash": "c6fd7e781b67111a90abd166d0ce4aa0", + "translation_date": "2026-07-08T16:18:27+00:00", + "source_file": "CONTRIBUTING.md", + "language_code": "he" + }, "README.md": { "original_hash": "12c8eb6bf0867d2f1c32daf613ac5b8b", "translation_date": "2026-04-06T20:24:48+00:00", @@ -17,6 +23,30 @@ "source_file": "SECURITY.md", "language_code": "he" }, + "__translation_failures__": { + "lessons/0-course-setup/how-to-run.md": { + "original_hash": "7ad8c7d8604c53649b3d4d1e2f3a6fa1", + "source_file": "lessons/0-course-setup/how-to-run.md", + "language_code": "he", + "failure_date": "2026-07-08T16:02:02+00:00", + "status": "failed", + "error_type": "TranslationIncompleteError", + "error_message": "Markdown translation remained incomplete for chunk 1 of 'how-to-run.md', and the chunk could not be split further.", + "translator_version": "0.20.0", + "failure_policy_version": 1 + }, + "lessons/sketchnotes/LICENSE.md": { + "original_hash": "45ab63a2cd8f5faef6c9b150618837a4", + "source_file": "lessons/sketchnotes/LICENSE.md", + "language_code": "he", + "failure_date": "2026-07-08T16:07:36+00:00", + "status": "failed", + "error_type": "TranslationIncompleteError", + "error_message": "Markdown translation remained incomplete for chunk 1.1.1 of 'LICENSE.md', and the chunk could not be split further.", + "translator_version": "0.20.0", + "failure_policy_version": 1 + } + }, "etc/CODE_OF_CONDUCT.md": { "original_hash": "c06b12caf3c901eb3156e3dd5b0aea56", "translation_date": "2025-08-28T20:13:31+00:00", @@ -54,8 +84,8 @@ "language_code": "he" }, "examples/README.md": { - "original_hash": "0d1babfdcbeb46525f2db3fbaaa54cd7", - "translation_date": "2025-10-03T11:32:11+00:00", + "original_hash": "7883d52c2e2a221e0b07a7b112a149b9", + "translation_date": "2026-07-08T16:01:05+00:00", "source_file": "examples/README.md", "language_code": "he" }, @@ -191,6 +221,12 @@ "source_file": "lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md", "language_code": "he" }, + "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb": { + "original_hash": "99b816b6a4957ef4100cee4c4221dff9", + "translation_date": "2026-07-08T15:56:57+00:00", + "source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb", + "language_code": "he" + }, "lessons/4-ComputerVision/08-TransferLearning/lab/README.md": { "original_hash": "7765935c35fcee69b9fe2d0cfd6963e2", "translation_date": "2025-08-28T19:29:33+00:00", @@ -330,8 +366,8 @@ "language_code": "he" }, "lessons/5-NLP/README.md": { - "original_hash": "8ef02a9318257ea140ed3ed74442096d", - "translation_date": "2025-08-28T19:58:00+00:00", + "original_hash": "038df6f1a73e49f6430740da083bfd6d", + "translation_date": "2026-07-08T16:02:43+00:00", "source_file": "lessons/5-NLP/README.md", "language_code": "he" }, diff --git a/translations/he/CONTRIBUTING.md b/translations/he/CONTRIBUTING.md new file mode 100644 index 00000000..d58b1440 --- /dev/null +++ b/translations/he/CONTRIBUTING.md @@ -0,0 +1,29 @@ +# לתרום ל-AI-For-Beginners + +תודה על העניין שלך לתרום ל-AI-For-Beginners! אנו מקבלים בברכה תרגומים, תיקוני שיעורים ותיקוני עיצוב. + +## הסכם רישיון תורם של מיקרוסופט (CLA) + +פרויקט זה מקבל תרומות והצעות. רוב התרומות דורשות ממך להסכים להסכם רישיון תורם (CLA) שמצהיר שיש לך את הזכות, ובאמת מעניק לנו את הזכויות להשתמש בתרומתך. לפרטים, בקר ב-[https://cla.microsoft.com](https://cla.microsoft.com). + +כאשר תגיש בקשת משיכה, הרובוט CLA יחליט אוטומטית האם עליך לספק CLA ויקשט את הבקשה בהתאם (למשל, תג, הערה). פשוט פעל לפי ההוראות שמספק הרובוט. תצטרך לעשות זאת רק פעם אחת בכל המאגרי מידע שמשתמשים ב-CLA שלנו. + +## איך לתרום + +### 1. תיקון שגיאות הקלדה / קוד +אם מצאת טעות הקלדה או באג בכל פנקס Jupyter או בקובץ סימון של שיעור: +1. פצל את המאגר. +2. תקן את טעות ההקלדה או הקישור השבור. +3. הגש בקשת משיכה עם תיאור ברור של התיקון. + +### 2. הגשת תרגומים +אנו מברכים תרגומים של השיעורים לשפות אחרות! אנא הנח תרגומים בתיקיית `translations/` תוך שימוש בשמות התיקיות הקיימות שם (לדוגמה `translations/es/`, `translations/pt-BR/`, `translations/zh-CN/`). + +לפרטים נוספים, ראה [etc/CONTRIBUTING.md](etc/CONTRIBUTING.md). + +--- + + +**כתב ויתור**: +מסמך זה תורגם באמצעות שירות תרגום אוטומטי [Co-op Translator](https://github.com/Azure/co-op-translator). למרות שאנו שואפים לדיוק, יש לקחת בחשבון שתרגומים אוטומטיים עלולים להכיל שגיאות או אי-דיוקים. יש להחשיב את המסמך המקורי בשפתו הטבעית כמקור הסמכות. למידע קריטי מומלץ להשתמש בתרגום מקצועי על ידי מתרגם אדם. אנו לא אחראים לכל אי-הבנה או פירוש שגוי הנובע מהשימוש בתרגום זה. + \ No newline at end of file diff --git a/translations/he/examples/README.md b/translations/he/examples/README.md index 8d166431..cb2855a5 100644 --- a/translations/he/examples/README.md +++ b/translations/he/examples/README.md @@ -1,31 +1,31 @@ -# דוגמאות AI ידידותיות למתחילים +# דוגמאות ידידותיות למתחילים בבינה מלאכותית -ברוכים הבאים! ספרייה זו מכילה דוגמאות פשוטות ועצמאיות שיעזרו לכם להתחיל עם AI ולמידת מכונה. כל דוגמה תוכננה להיות ידידותית למתחילים עם הערות מפורטות והסברים שלב אחר שלב. +ברוכים הבאים! תיקייה זו מכילה דוגמאות פשוטות ועצמאיות שיעזרו לכם להתחיל עם בינה מלאכותית ולמידת מכונה. כל דוגמה מעוצבת להיות ידידותית למתחילים עם הערות מפורטות והסברים שלב-אחר-שלב. ## 📚 סקירת דוגמאות -| דוגמה | תיאור | רמת קושי | דרישות מקדימות | -|-------|-------|----------|-----------------| -| [Hello AI World](../../../examples/01-hello-ai-world.py) | תוכנית ה-AI הראשונה שלכם - זיהוי תבניות פשוט | ⭐ מתחילים | יסודות Python | -| [Simple Neural Network](../../../examples/02-simple-neural-network.py) | בניית רשת נוירונים מאפס | ⭐⭐ מתחילים+ | Python, מתמטיקה בסיסית | -| [Image Classifier](./03-image-classifier.ipynb) | סיווג תמונות עם מודל מאומן מראש | ⭐⭐ מתחילים+ | Python, numpy | -| [Text Sentiment](../../../examples/04-text-sentiment.py) | ניתוח רגשות בטקסט (חיובי/שלילי) | ⭐⭐ מתחילים+ | Python | +| דוגמה | תיאור | רמת קושי | דרישות מוקדמות | +|---------|-------------|------------|---------------| +| [Hello AI World](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/01-hello-ai-world.py) | התוכנית הראשונה שלך בבינה מלאכותית - זיהוי תבניות פשוט | ⭐ מתחיל | יסודות פייתון | +| [Simple Neural Network](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/02-simple-neural-network.py) | בניית רשת עצבית מהבסיס | ⭐⭐ מתחילים+ | פייתון, מתמטיקה בסיסית | +| [Image Classifier](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/03-image-classifier.ipynb) | סיווג תמונות עם מודל מאומן מראש | ⭐⭐ מתחילים+ | פייתון, numpy | +| [Text Sentiment](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/04-text-sentiment.py) | ניתוח סנטימנט של טקסט (חיובי/שלילי) | ⭐⭐ מתחילים+ | פייתון | -## 🚀 איך מתחילים +## 🚀 התחלה -### דרישות מקדימות +### דרישות מוקדמות -וודאו ש-Python מותקן אצלכם (מומלץ גרסה 3.8 או גבוהה יותר). התקינו את החבילות הנדרשות: +ודא שיש לך פייתון מותקן (מומלץ גרסה 3.8 ומעלה). התקן את החבילות הנדרשות: ```bash -# For Python scripts +# לסקריפטים של פייתון pip install numpy -# For Jupyter notebooks (image classifier) +# למחברות ג'ופיטר (מסווג תמונות) pip install jupyter numpy pillow tensorflow ``` -או השתמשו בסביבת conda מתוך תוכנית הלימודים הראשית: +או השתמש בסביבת conda מתוך תוכנית הלימודים הראשית: ```bash conda env create --name ai4beg --file ../environment.yml @@ -34,52 +34,54 @@ conda activate ai4beg ### הרצת הדוגמאות -**עבור קבצי Python (.py):** +**לקבצי Python (.py):** ```bash python 01-hello-ai-world.py ``` -**עבור מחברות Jupyter (.ipynb):** +**לקבצי Jupyter (.ipynb):** ```bash jupyter notebook 03-image-classifier.ipynb ``` ## 📖 מסלול לימוד -מומלץ לעקוב אחרי הדוגמאות לפי הסדר: +אנו ממליצים לעקוב אחר הדוגמאות לפי הסדר: -1. **התחילו עם "Hello AI World"** - למדו את יסודות זיהוי התבניות -2. **בנו רשת נוירונים פשוטה** - הבינו איך רשתות נוירונים פועלות -3. **נסו את מסווג התמונות** - ראו את ה-AI בפעולה עם תמונות אמיתיות -4. **נתחו רגשות בטקסט** - חקרו עיבוד שפה טבעית +1. **התחל עם "Hello AI World"** - למד את יסודות זיהוי התבניות +2. **בנה רשת עצבית פשוטה** - הבן כיצד רשתות עצביות פועלות +3. **נסה את המסווג תמונות** - ראה בינה מלאכותית בפעולה עם תמונות אמיתיות +4. **נתח סנטימנט טקסט** - חקור עיבוד שפה טבעית ## 💡 טיפים למתחילים -- **קראו את הערות הקוד בקפידה** - הן מסבירות מה כל שורה עושה -- **נסו להתנסות!** - שנו ערכים וראו מה קורה -- **אל תדאגו אם לא תבינו הכל** - הלמידה לוקחת זמן -- **שאלו שאלות** - השתמשו ב-[לוח הדיונים](https://github.com/microsoft/AI-For-Beginners/discussions) +- **קרא את ההערות בקוד בקפידה** - הן מסבירות מה כל שורה עושה +- **תנסה!** - נסה לשנות ערכים וראה מה קורה +- **אל תדאג אם לא תבין הכל מיד** - למידה לוקחת זמן +- **שאל שאלות** - השתמש בלוח הדיונים [Discussion board](https://github.com/microsoft/AI-For-Beginners/discussions) -## 🔗 צעדים הבאים +## 🔗 שלבים הבאים -לאחר שתסיימו את הדוגמאות, חקרו את תוכנית הלימודים המלאה: -- [מבוא ל-AI](../lessons/1-Intro/README.md) -- [רשתות נוירונים](../lessons/3-NeuralNetworks/README.md) +לאחר סיום דוגמאות אלו, חקור את תוכנית הלימודים המלאה: +- [מבוא לבינה מלאכותית](../lessons/1-Intro/README.md) +- [רשתות עצביות](../lessons/3-NeuralNetworks/README.md) - [ראייה ממוחשבת](../lessons/4-ComputerVision/README.md) - [עיבוד שפה טבעית](../lessons/5-NLP/README.md) ## 🤝 תרומה -מצאתם את הדוגמאות מועילות? עזרו לנו לשפר אותן: -- דווחו על בעיות או הציעו שיפורים -- הוסיפו עוד דוגמאות למתחילים -- שפרו את התיעוד וההערות +מצאת את הדוגמאות האלה מועילות? עזור לנו לשפר אותן: +- דווח על בעיות או הצע שיפורים +- הוסף דוגמאות נוספות למתחילים +- שפר את התיעוד וההערות --- -*זכרו: כל מומחה היה פעם מתחיל. למידה נעימה! 🎓* +*זכור: כל מומחה היה פעם מתחיל. לימודים מהנים! 🎓* --- -**כתב ויתור**: -מסמך זה תורגם באמצעות שירות תרגום מבוסס בינה מלאכותית [Co-op Translator](https://github.com/Azure/co-op-translator). למרות שאנו שואפים לדיוק, יש לקחת בחשבון שתרגומים אוטומטיים עשויים להכיל שגיאות או אי דיוקים. המסמך המקורי בשפתו המקורית צריך להיחשב כמקור הסמכותי. עבור מידע קריטי, מומלץ להשתמש בתרגום מקצועי על ידי אדם. איננו נושאים באחריות לאי הבנות או לפרשנויות שגויות הנובעות משימוש בתרגום זה. \ No newline at end of file + +**כתב ויתור**: +מסמך זה תורגם באמצעות שירות תרגום אוטומטי [Co-op Translator](https://github.com/Azure/co-op-translator). למרות שאנו שואפים לדיוק, יש לקחת בחשבון שתרגומים אוטומטיים עלולים להכיל שגיאות או אי-דיוקים. יש להחשיב את המסמך המקורי בשפתו הטבעית כמקור הסמכות. למידע קריטי מומלץ להשתמש בתרגום מקצועי על ידי מתרגם אדם. אנו לא אחראים לכל אי-הבנה או פירוש שגוי הנובע מהשימוש בתרגום זה. + \ No newline at end of file diff --git a/translations/he/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb b/translations/he/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb index ea1f1f16..6344ab27 100644 --- a/translations/he/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb +++ b/translations/he/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb @@ -6,9 +6,9 @@ "source": [ "# מודלים מאומנים מראש ולמידת העברה\n", "\n", - "אימון רשתות עצביות קונבולוציוניות (CNNs) יכול לקחת זמן רב, ונדרש לכך גם כמות גדולה של נתונים. עם זאת, חלק גדול מהזמן מושקע בלמידת המסננים הבסיסיים שהרשת משתמשת בהם כדי לזהות תבניות מתוך תמונות. עולה שאלה טבעית - האם ניתן להשתמש ברשת עצבית שאומנה על מערך נתונים אחד ולהתאים אותה לסיווג תמונות שונות מבלי לעבור את כל תהליך האימון מחדש?\n", + "אימון רשתות CNN עלול לקחת הרבה זמן, ונדרשת כמות גדולה של נתונים למשימה זו. עם זאת, במהלך הזמן הרב נלמדים בעיקר המסננים הנמוכים הטובים ביותר שהרשת משתמשת בהם כדי לחלץ תבניות מתוך תמונות. עולה שאלה טבעית - האם אפשר להשתמש ברשת עצבית שאומנה על מערך נתונים אחד ולהתאים אותה לסיווג תמונות שונות בלי תהליך אימון מלא?\n", "\n", - "גישה זו נקראת **למידת העברה**, מכיוון שאנחנו מעבירים ידע מסוים ממודל רשת עצבית אחד לאחר. בלמידת העברה, בדרך כלל מתחילים עם מודל מאומן מראש, שאומן על מערך נתונים גדול כלשהו, כמו **ImageNet**. מודלים אלו כבר יודעים לבצע עבודה טובה בזיהוי מאפיינים שונים מתוך תמונות כלליות, וברוב המקרים, בניית מסווג על בסיס המאפיינים שהופקו יכולה להניב תוצאות טובות.\n" + "גישה זו נקראת **למידת העברה**, כי היא מעבירה קצת ידע ממודל רשת עצבית אחד לאחר. בלמידת העברה, בדרך כלל מתחילים עם מודל מאומן מראש, שאומן על מערך נתוני תמונות גדול כלשהו, כמו **ImageNet**. המודלים האלה כבר יכולים לבצע עבודה טובה בחילוץ תכונות שונות מתמונות גנריות, ובמקרים רבים בניית מסווג על בסיס התכונות שחלצו בלבד יכולה להניב תוצאה טובה.\n" ] }, { @@ -29,11 +29,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## מאגר הנתונים של חתולים מול כלבים\n", + "## מערך הנתונים חתולים מול כלבים\n", "\n", - "ביחידה זו, נפתור בעיה אמיתית של סיווג תמונות של חתולים וכלבים. לשם כך, נשתמש ב-[מאגר הנתונים של חתולים מול כלבים מ-Kaggle](https://www.kaggle.com/c/dogs-vs-cats), שניתן גם להוריד [מ-Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n", + "ביחידה הזאת נפתור בעיה מהחיים האמיתיים של סיווג תמונות של חתולים וכלבים. לשם כך, נשתמש ב[מערך הנתונים של חתולים מול כלבים ב-Kaggle](https://www.kaggle.com/c/dogs-vs-cats), שניתן גם להוריד [מאת מיקרוסופט](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n", "\n", - "בואו נוריד את מאגר הנתונים הזה ונחלץ אותו לתיקיית `data` (תהליך זה עשוי לקחת זמן!):\n" + "הורידו את מערך הנתונים הזה וחלצו אותו לתיקייה `data` (התהליך עלול לקחת קצת זמן!):\n" ] }, { @@ -64,7 +64,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "למרבה הצער, יש כמה קבצי תמונה פגומים במאגר הנתונים. אנו צריכים לבצע ניקוי מהיר כדי לבדוק קבצים פגומים. כדי לא לפגוע במדריך זה, העברנו את הקוד לאימות מאגר הנתונים למודול.\n" + "לצערנו, יש כמה קבצי תמונה פגומים בקבוצת הנתונים. עלינו לבצע ניקוי מהיר כדי לבדוק קבצים פגומים. כדי לא לפגום במדריך זה, הזזנו את הקוד לאימות קבוצת הנתונים למודול.\n" ] }, { @@ -333,13 +333,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## טעינת מערך הנתונים\n", + "## טעינת אוסף הנתונים\n", "\n", - "בדוגמאות קודמות, טענו מערכי נתונים שמובנים בתוך Keras. עכשיו אנחנו עומדים להתמודד עם מערך נתונים משלנו, שאותו נצטרך לטעון מתיקייה של תמונות.\n", + "בדוגמאות הקודמות, טעינו אוספי נתונים שכלולים בתוך Keras. עכשיו אנחנו עומדים להתמודד עם אוסף הנתונים שלנו, שצריך לטעון מתיקיית תמונות.\n", "\n", - "בחיים האמיתיים, גודל מערכי נתונים של תמונות יכול להיות די גדול, ולא ניתן להסתמך על כך שכל הנתונים יוכלו להיכנס לזיכרון. לכן, מערכי נתונים מיוצגים לעיתים קרובות כ-**גנרטורים** שיכולים להחזיר נתונים במנות קטנות שמתאימות לאימון.\n", + "בחיים האמיתיים, גודל אוספי הנתונים לתמונות יכול להיות גדול מאוד, ולא ניתן להסתמך על כך שכל הנתונים יוכלו להיכנס לזיכרון. לכן, אוספי נתונים מיוצגים לעיתים קרובות כמחוללים (**generators**) שיכולים להחזיר נתונים במיני-אצוות המתאימות לאימון.\n", "\n", - "כדי להתמודד עם סיווג תמונות, Keras כוללת פונקציה מיוחדת בשם `image_dataset_from_directory`, שיכולה לטעון תמונות מתיקיות משנה שמייצגות מחלקות שונות. פונקציה זו גם מטפלת בסקיילינג של התמונות, ויכולה גם לחלק את מערך הנתונים לתת-קבוצות של אימון ובדיקה:\n" + "כדי להתמודד עם סיווג תמונות, Keras כוללת פונקציה מיוחדת `image_dataset_from_directory`, שיכולה לטעון תמונות מתיקיות משנה המתאימות למחלקות שונות. פונקציה זו מטפלת גם בקנה מידה של התמונות, ויכולה גם לחלק את אוסף הנתונים לחלקי אימון ובדיקה:\n" ] }, { @@ -383,9 +383,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "חשוב להגדיר את אותו ערך `seed` בשתי הקריאות, מכיוון שהוא משפיע על חלוקת התמונות בין קבוצת האימון וקבוצת הבדיקה.\n", + "חשוב להגדיר את אותה ערך `seed` לשתי הקריאות, כי זה משפיע על חלוקת התמונות בין מערך האימון למערך הבדיקה.\n", "\n", - "המערך מזהה באופן אוטומטי את שמות הקטגוריות מתוך התיקיות, וניתן לגשת אליהם במידת הצורך על ידי קריאה:\n" + "מערך הנתונים אוסף באופן אוטומטי את שמות המחלקות מהתקיות, ואתה יכול לגשת אליהם אם נדרש על ידי קריאה ל:\n" ] }, { @@ -412,7 +412,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "מערכי הנתונים שהשגנו יכולים להיות מועברים ישירות לפונקציית `fit` כדי לאמן את המודל. הם מכילים הן תמונות תואמות והן תוויות, שניתן לעבור עליהן באמצעות המבנה הבא:\n" + "מערכי הנתונים שקיבלנו יכולים להיות מועברים ישירות לפונקציית `fit` לאימון המודל. הם מכילים הן תמונות תואמות והן תוויות, שניתן לעבור עליהם בלולאה באמצעות המבנה הבא:\n" ] }, { @@ -453,7 +453,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "> **הערה**: כל התמונות במאגר הנתונים מיוצגות כטנסורים מסוג נקודה צפה בטווח 0-255. לפני העברתן לרשת העצבית, עלינו להקטין את הערכים לטווח 0-1. כאשר אנו מציגים תמונות, עלינו לעשות את אותו הדבר או להמיר את הערכים לסוג `int` (כפי שעשינו בקוד למעלה), כדי להראות ל-`matplotlib` שאנו רוצים להציג את התמונה המקורית ללא שינוי.\n" + "> **הערה**: כל התמונות במאגר הנתונים מיוצגות כמטריצות נקודות צף בטווח 0-255. לפני העברתם לרשת העצבית, עלינו לשנות את הערכים האלה לטווח 0-1. כאשר מציגים תמונות, עלינו לעשות את אותו הדבר, או להמיר את הערכים לסוג `int` (כפי שאנו עושים בקוד שבמעלה), כדי להראות ל-`matplotlib` שאנו רוצים להציג את התמונה המקורית ללא שינוי.\n" ] }, { @@ -462,7 +462,7 @@ "source": [ "## מודלים מאומנים מראש\n", "\n", - "למשימות רבות של סיווג תמונות ניתן למצוא מודלים של רשתות עצביות מאומנים מראש. רבים מהמודלים הללו זמינים בתוך המרחב `keras.applications`, ועוד מודלים רבים ניתן למצוא באינטרנט. בואו נראה איך ניתן לטעון ולהשתמש במודל הפשוט ביותר VGG-16:\n" + "עבור משימות סיווג תמונות רבות ניתן למצוא מודלים של רשתות עצביות מאומנות מראש. רבים מהמודלים הללו זמינים בתוך מרחב השמות `keras.applications`, ועוד מודלים רבים ניתן למצוא באינטרנט. בואו נראה כיצד ניתן לטעון ולהשתמש במודל הפשוט ביותר VGG-16:\n" ] }, { @@ -497,7 +497,17 @@ } ], "source": [ - "vgg = keras.applications.VGG16()\n", + "# SHA-256 of VGG16 weights (with top)\n", + "VGG16_WEIGHTS_SHA256 = '64373286793e3c8b2b4e3219cbf3544bce2f55ab4682710a29f5e7af8f5e4f61'\n", + "\n", + "_weights_path = keras.utils.get_file(\n", + " 'vgg16_weights_tf_dim_ordering_tf_kernels.h5',\n", + " 'https://storage.googleapis.com/tensorflow/keras-applications/vgg16/vgg16_weights_tf_dim_ordering_tf_kernels.h5',\n", + " file_hash=VGG16_WEIGHTS_SHA256,\n", + " hash_algorithm='sha256',\n", + ")\n", + "\n", + "vgg = keras.applications.VGG16(weights=_weights_path)\n", "inp = keras.applications.vgg16.preprocess_input(x_sample[:1])\n", "\n", "res = vgg(inp)\n", @@ -511,19 +521,16 @@ "metadata": {}, "source": [ "יש כאן כמה דברים חשובים:\n", - "\n", - "* לפני שמעבירים קלט לכל רשת נוירונים מאומנת מראש, יש לעבד אותו בצורה מסוימת. זה נעשה על ידי קריאה לפונקציה המתאימה `preprocess_input`, שמקבלת אצווה של תמונות ומחזירה את הצורה המעובדת שלהן. במקרה של VGG-16, התמונות מנורמלות, ונגרע מהן ערך ממוצע מוגדר מראש לכל ערוץ. זאת מכיוון ש-VGG-16 אומנה במקור עם עיבוד מקדים זה.\n", - "\n", - "* רשת הנוירונים מופעלת על אצוות הקלט, והתוצאה היא אצווה של טנסורים עם 1000 אלמנטים שמראים את ההסתברות של כל מחלקה. ניתן למצוא את מספר המחלקה הסביר ביותר על ידי קריאה ל-`argmax` על הטנסור הזה.\n", - "\n", - "* התוצאה שהתקבלה היא [מספר של מחלקה מתוך `ImageNet`](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). כדי להבין את התוצאה הזו, ניתן גם להשתמש בפונקציה `decode_predictions`, שמחזירה את n המחלקות המובילות יחד עם שמותיהן.\n" + "* לפני העברת קלט לכל רשת מאומנת מראש יש לעבד אותו בדרך מסוימת. זה נעשה על ידי קריאה לפונקציית `preprocess_input` המתאימה, שמקבלת אצווה של תמונות ומחזירה את צורתן המעובדת. במקרה של VGG-16, התמונות מנורמלות ונחסר ערך ממוצע שהוגדר מראש עבור כל ערוץ. זה כי VGG-16 אומנה במקור עם עיבוד מוקדם זה.\n", + "* רשת עצבית מוחלת על אצוות הקלט, ואנו מקבלים כתוצאה אצווה של טנסורים בני 1000 אלמנטים שמראים את ההסתברות לכל מחלקה. ניתן למצוא את המספר של המחלקה הסבירה ביותר על ידי קריאה ל-`argmax` על הטנסור הזה.\n", + "* התוצאה שהתקבלה היא [מספר של מחלקת `ImageNet`](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). כדי להבין את התוצאה הזו, ניתן גם להשתמש בפונקציית `decode_predictions`, שמחזירה את n המחלקות העליונות יחד עם שמותיהן.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "בואו נראה גם את הארכיטקטורה של רשת VGG-16:\n" + "בואו נבחן גם את הארכיטקטורה של רשת VGG-16:\n" ] }, { @@ -600,9 +607,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## חישובים על GPU\n", + "## חישובים ב-GPU\n", "\n", - "רשתות עצביות עמוקות, כמו VGG-16 וארכיטקטורות מודרניות אחרות, דורשות כוח חישוב רב כדי לפעול. הגיוני להשתמש בהאצת GPU אם היא זמינה. למרבה המזל, Keras מאיצה באופן אוטומטי את החישובים על ה-GPU אם הוא זמין. ניתן לבדוק אם Tensorflow מסוגל להשתמש ב-GPU באמצעות הקוד הבא:\n" + "רשתות נוירונים עמוקות, כמו VGG-16 ואדריכלות מודרניות אחרות, דורשות כוח חישובי משמעותי להפעלה. יש הגיון להשתמש בהאצת GPU, אם היא זמינה. למרבה המזל, Keras מאיצה אוטומטית את החישובים על ה-GPU אם הוא זמין. אנחנו יכולים לבדוק אם Tensorflow מסוגל להשתמש ב-GPU באמצעות הקוד הבא:\n" ] }, { @@ -629,9 +636,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## חילוץ מאפיינים מ-VGG\n", "\n", - "אם אנחנו רוצים להשתמש ב-VGG-16 כדי לחלץ מאפיינים מהתמונות שלנו, אנחנו צריכים את המודל ללא שכבות הסיווג הסופיות. ניתן ליצור את מודל VGG-16 ללא השכבות העליונות באמצעות הקוד הבא:\n" + "## חילוץ תכונות VGG\n", + "\n", + "אם אנחנו רוצים להשתמש ב-VGG-16 כדי לחלץ תכונות מהתמונות שלנו, אנחנו צריכים את המודל ללא שכבות הסיווג הסופיות. אנחנו יכולים לאתחל את מודל VGG-16 ללא השכבות העליונות באמצעות הקוד הבא:\n" ] }, { @@ -683,9 +691,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "המימד של טנסור התכונות הוא 7x7x512, אך כדי להציג אותו בצורה חזותית היינו צריכים לשנות את צורתו למבנה דו-ממדי.\n", + "המימד של טנזור התכונות הוא 7x7x512, אבל על מנת להציג אותו נאלצנו לעצב מחדש לצורה דו-ממדית.\n", "\n", - "עכשיו בואו ננסה לבדוק אם ניתן להשתמש בתכונות הללו כדי לסווג תמונות. ניקח באופן ידני חלק מהתמונות (50 מיני-אצוות, במקרה שלנו), ונחשב מראש את וקטורי התכונות שלהן. ניתן להשתמש ב-API של **dataset** של Tensorflow כדי לעשות זאת. פונקציית `map` לוקחת מערך נתונים ומיישמת פונקציית למבדה נתונה כדי לשנות אותו. אנו משתמשים במנגנון הזה כדי לבנות מערכי נתונים חדשים, `ds_features_train` ו-`ds_features_test`, שמכילים תכונות שהופקו על ידי VGG במקום התמונות המקוריות.\n" + "עכשיו בואו ננסה לראות אם ניתן להשתמש בתכונות אלו כדי לסווג תמונות. ניקח באופן ידני חלק מהתמונות (50 מיני-בצ'ים, במקרה שלנו), ונחשב מראש את וקטורי התכונות שלהן. אנו יכולים להשתמש ב-API של Tensorflow **dataset** כדי לעשות זאת. פונקציית `map` מקבלת סט נתונים ומיישמת פונקציית למבדה נתונה כדי לבצע המרה. אנו משתמשים במנגנון זה כדי לבנות סטי נתונים חדשים, `ds_features_train` ו-`ds_features_test`, המכילים תכונות שהופקו מ-VGG במקום התמונות המקוריות.\n" ] }, { @@ -715,9 +723,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "השתמשנו בבנייה `.take(50)` כדי להגביל את גודל מערך הנתונים, על מנת להאיץ את ההדגמה שלנו. כמובן, ניתן לבצע את הניסוי הזה על מערך הנתונים המלא.\n", + "השתמשנו בבנייה `.take(50)` כדי להגביל את גודל מערך הנתונים, כדי להאיץ את ההדגמה שלנו. כמובן שניתן לבצע ניסוי זה על מערך הנתונים המלא.\n", "\n", - "עכשיו, כשיש לנו מערך נתונים עם תכונות שהופקו, נוכל לאמן מסווג צפוף פשוט כדי להבחין בין חתולים לכלבים. הרשת הזו תקבל וקטור תכונות בצורת (7,7,512), ותפיק פלט אחד שמייצג או כלב או חתול. מכיוון שמדובר בסיווג בינארי, אנו משתמשים בפונקציית הפעלה `sigmoid` ובאובדן `binary_crossentropy`.\n" + "כעת שיש לנו מערך נתונים עם תכונות שהופקו, נוכל לאמן מסווג צפוף פשוט כדי להבדיל בין חתולים לכלבים. רשת זו תקבל וקטור של תכונות בצורת (7,7,512), ותפיק פלט אחד המתאים לכלב או לחתול. מאחר שמדובר במיוני בינארי, נשתמש בפונקציית ההפעלה `sigmoid` ואובדן `binary_crossentropy`.\n" ] }, { @@ -746,13 +754,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "התוצאה נהדרת, אנחנו יכולים להבחין בין חתול לכלב עם סבירות של כמעט 95%! עם זאת, בדקנו את הגישה הזו רק על תת-קבוצה של כל התמונות, מכיוון שמיצוי תכונות ידני לוקח הרבה זמן.\n", + "התוצאה נהדרת, אנחנו יכולים להבחין בין חתול לכלב עם כמעט 95% הסתברות! עם זאת, בדקנו את הגישה הזו רק על תת-קבוצה של כל התמונות, כי חילוץ התכונות הידני נראה שלוקח הרבה זמן.\n", "\n", - "## למידת העברה באמצעות רשת VGG אחת\n", + "## למידה בהעברה באמצעות רשת VGG אחת\n", "\n", - "אנחנו יכולים גם להימנע ממיצוי תכונות ידני מראש על ידי שימוש ברשת VGG-16 המקורית בשלמותה במהלך האימון, על ידי הוספת ממצה תכונות כרובד הראשון ברשת שלנו.\n", + "אנחנו גם יכולים להימנע מחישוב תכונות מראש ידנית על ידי שימוש ברשת VGG-16 המקורית כמכלול במהלך האימון, על ידי הוספת מנחה תכונות לרשת שלנו כשכבה ראשונה.\n", "\n", - "היופי בארכיטקטורה של Keras הוא שמודל VGG-16 שהגדרנו קודם יכול לשמש גם כרובד בתוך רשת עצבית אחרת! כל מה שצריך לעשות הוא לבנות רשת עם מסווג צפוף מעליה, ואז לאמן את כל הרשת באמצעות back propagation.\n" + "היופי בארכיטקטורת Keras הוא שמודל VGG-16 שהגדרנו למעלה יכול לשמש גם כשכבה ברשת עצבית אחרת! אנחנו רק צריכים לבנות רשת עם מסווג צפוף מעליה, ואז לאמן את כל הרשת באמצעות הפצה לאחור.\n" ] }, { @@ -796,13 +804,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "מודל זה נראה כמו רשת סיווג מקצה לקצה, אשר מקבלת תמונה ומחזירה את הקטגוריה. עם זאת, החלק המאתגר הוא שאנחנו רוצים ש-VGG16 ישמש כמחלץ מאפיינים, ולא יבוצע עליו אימון מחדש. לכן, עלינו **להקפיא את המשקלים של מחלץ המאפיינים הקונבולוציוני**. ניתן לגשת לשכבה הראשונה של הרשת על ידי קריאה ל-`model.layers[0]`, וכל מה שצריך לעשות הוא להגדיר את המאפיין `trainable` כ-`False`.\n", + "מודל זה נראה כמו רשת סיווג מקצה-לקצה, שלוקחת תמונה ומחזירה את הסוג. עם זאת, הטריק הוא שאנחנו רוצים ש-VGG16 תפעל כמחלץ תכונות, ולא שתאומן מחדש. לכן, עלינו **להקפיא את המשקלים של מחלץ התכונות המודגש בקונבולוציה**. נוכל לגשת לשכבה הראשונה של הרשת על ידי קריאה ל-`model.layers[0]`, וכל מה שצריך לעשות הוא לקבוע את התכונה `trainable` ל־`False`.\n", "\n", - "> **Note**: הקפאת המשקלים של מחלץ המאפיינים נחוצה, מכיוון שאם לא, שכבת הסיווג הלא מאומנת יכולה להרוס את המשקלים המקוריים של מחלץ המאפיינים הקונבולוציוני.\n", + "> **הערה**: הקפאת המשקלים של מחלץ התכונות נדרשת, כי אחרת שכבת הממוין הלא מאומנת עלולה להרוס את המשקלים המקוריים שאומנו מראש של מחלץ הקונבולוציה.\n", "\n", - "ניתן להבחין שבעוד שמספר הפרמטרים הכולל ברשת שלנו הוא כ-15 מיליון, אנחנו מאמנים רק 25 אלף פרמטרים. כל שאר הפרמטרים של המסננים הקונבולוציוניים ברמה העליונה הם מאומנים מראש. זה טוב, מכיוון שאנחנו יכולים לכוונן מספר קטן יותר של פרמטרים עם מספר קטן יותר של דוגמאות.\n", + "תוכלו לשים לב שבזמן שמספר הפרמטרים הכולל ברשת שלנו הוא בסביבות 15 מיליון, אנחנו מאמנים רק 25 אלף פרמטרים. כל שאר הפרמטרים של מסנני הקונבולוציה שבשכבה העליונה אומנו מראש. זה טוב, כי אנחנו יכולים לכוונן עדין כמות קטנה יותר של פרמטרים עם כמות קטנה יותר של דוגמאות.\n", "\n", - "כעת נאמן את הרשת שלנו ונראה עד כמה נוכל להגיע. צפו לזמן ריצה די ארוך, ואל תדאגו אם נראה שהביצוע קפוא לזמן מה.\n" + "כעת נתחיל לאמן את הרשת שלנו ונראה כמה טוב נוכל להגיע. צפו לזמן ריצה יחסית ארוך, ואל תדאגו אם הביצוע ייראה קפוא לזמן מה.\n" ] }, { @@ -827,11 +835,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "נראה שהצלחנו להשיג מסווג חתולים מול כלבים מדויק למדי!\n", + "נראה כי השגנו מסווג חתולים מול כלבים מדויק למדי! \n", "\n", - "## שמירת המודל וטעינתו\n", + "## שמירה וטעינת המודל\n", "\n", - "לאחר שאימנו את המודל, נוכל לשמור את מבנה המודל והמשקלים המאומנים לקובץ לשימוש עתידי:\n" + "ברגע שאימנו את המודל, אנו יכולים לשמור את ארכיטקטורת המודל ואת המשקלים המאומנים לקובץ לשימוש עתידי:\n" ] }, { @@ -855,7 +863,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "אנחנו יכולים לטעון את המודל מהקובץ בכל זמן. ייתכן שתמצא את זה שימושי במקרה שהניסוי הבא יהרוס את המודל - לא תצטרך להתחיל מחדש מאפס.\n" + "אז נוכל להטעין את המודל מקובץ בכל זמן שתרצו. זה יכול להיות שימושי במקרה שהניסוי הבא יהרוס את המודל - לא תצטרכו להתחיל מהתחלה מחדש.\n" ] }, { @@ -871,15 +879,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## כוונון עדין בלמידה מעבירה\n", + "## העברת למידה עם כוונון מדויק\n", "\n", - "בקטע הקודם, אימנו את שכבת הסיווג הסופית כדי לסווג תמונות במאגר הנתונים שלנו. עם זאת, לא אימנו מחדש את מפיק התכונות, והמודל שלנו הסתמך על התכונות שהמודל למד מנתוני ImageNet. אם האובייקטים שלך נראים שונה באופן חזותי מתמונות רגילות של ImageNet, ייתכן ששילוב התכונות הזה לא יעבוד בצורה הטובה ביותר. לכן, יש היגיון להתחיל לאמן גם את שכבות הקונבולוציה.\n", + "בסעיף הקודם, אימנו את שכבת המיון הסופית לסיווג תמונות במאגר הנתונים שלנו. עם זאת, לא אימנו מחדש את מאתר התכונות, והמודל שלנו הסתמך על התכונות שהמודל למד מנתוני ImageNet. אם האובייקטים שלך נראים שונה מתמונות רגילות של ImageNet, ייתכן ששילוב התכונות הזה לא יעבוד בצורה הטובה ביותר. לכן הגיוני להתחיל לאמן גם שכבות קונבולוציה.\n", "\n", - "כדי לעשות זאת, ניתן לבטל את הקפאת הפרמטרים של מסנני הקונבולוציה שהקפאנו קודם לכן.\n", + "לשם כך, נוכל לשחרר את פרמטרי המסנן בקונבולוציה שהקפאנו קודם.\n", "\n", - "> **Note:** חשוב להקפיא תחילה את הפרמטרים ולבצע כמה אפוקים של אימון כדי לייצב את המשקלים בשכבת הסיווג. אם תתחיל מיד לאמן רשת מקצה לקצה עם פרמטרים לא מוקפאים, סביר להניח ששגיאות גדולות יהרסו את המשקלים שהוכנו מראש בשכבות הקונבולוציה.\n", + "> **הערה:** חשוב להקפיא את הפרמטרים תחילה ולבצע כמה אפוקים של אימון כדי לייצב את המשקולות בשכבת המיון. אם תתחיל מיד לאמן את הרשת מקצה לקצה עם פרמטרים לא מוקפאים, שגיאות גדולות עשויות להשמיד את המשקולות שהוכנו מראש בשכבות הקונבולוציה.\n", "\n", - "המודל הקונבולוציוני שלנו מסוג VGG-16 ממוקם בתוך השכבה הראשונה, והוא מורכב ממספר שכבות בפני עצמו. ניתן להסתכל על המבנה שלו:\n" + "מודל ה-VGG-16 הקונבולוציוני שלנו ממוקם בתוך השכבה הראשונה, והוא מורכב מהרבה שכבות בעצמו. נוכל להסתכל על המבנה שלו:\n" ] }, { @@ -948,7 +956,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "אנחנו יכולים להפשיר את כל השכבות של בסיס הקונבולוציה:\n" + "אנו יכולים לשחרר את כל השכבות של הבסיס הקונבולוציוני:\n" ] }, { @@ -964,7 +972,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "עם זאת, הפשרה של כולם בבת אחת אינה הרעיון הטוב ביותר. אנו יכולים תחילה להפשיר רק כמה שכבות סופיות של קונבולוציות, מכיוון שהן מכילות דפוסים ברמה גבוהה שרלוונטיים לתמונות שלנו. לדוגמה, כדי להתחיל, אנו יכולים להקפיא את כל השכבות מלבד 4 האחרונות:\n" + "עם זאת, לשחרר את כולם בבת אחת אינו הרעיון הטוב ביותר. ניתן תחילה לשחרר רק כמה שכבות סופיות של העיבודים הקונבולוציוניים, מכיוון שהן מכילות דפוסים ברמה גבוהה יותר שרלוונטיים לתמונות שלנו. לדוגמה, כדי להתחיל, נוכל להקפיא את כל השכבות מלבד ארבע האחרונות:\n" ] }, { @@ -1003,11 +1011,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "שימו לב שמספר הפרמטרים הניתנים לאימון גדל באופן משמעותי, אך הוא עדיין עומד על כ-50% מכלל הפרמטרים.\n", + "שימו לב שכמות הפרמטרים שניתנים לאימון עלתה משמעותית, אך היא עדיין בסביבות 50% מכלל הפרמטרים.\n", "\n", - "לאחר ביטול הקפאת השכבות, ניתן לבצע עוד כמה אפוקים של אימון (בדוגמה שלנו, נבצע רק אחד). ניתן גם לבחור קצב למידה נמוך יותר, כדי למזער את ההשפעה על המשקלים שהוכנו מראש. עם זאת, גם עם קצב למידה נמוך, ניתן לצפות לירידה בדיוק בתחילת האימון, עד שלבסוף תגיעו לרמה מעט גבוהה יותר בהשוואה למקרה של משקלים קבועים.\n", + "לאחר שתבטלו את ההקפאה, ניתן לבצע עוד כמה אפוקים של אימון (בדוגמה שלנו, נעשה רק אחד). ניתן גם לבחור בקצב למידה נמוך יותר, כדי למזער את ההשפעה על המשקלים שאומנו מראש. עם זאת, גם עם קצב למידה נמוך, ניתן לצפות לירידה בדיוק בתחילת האימון, עד שבסופו של דבר מגיעים לרמה קצת גבוהה יותר מאשר במקרה של משקלים קבועים.\n", "\n", - "> **Note:** האימון הזה מתבצע הרבה יותר לאט, מכיוון שעלינו להעביר את הגרדיאנטים חזרה דרך שכבות רבות ברשת!\n" + "> **הערה:** האימון הזה מתבצע הרבה יותר לאט, כי אנחנו צריכים להפיץ גרדיאנטים לאחור דרך שכבות רבות ברשת!\n" ] }, { @@ -1031,18 +1039,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "אנו צפויים להגיע לדיוק גבוה יותר באימון, מכיוון שאנו משתמשים ברשת חזקה יותר עם יותר פרמטרים, אך הדיוק באימות לא יעלה באותה מידה.\n", + "סביר שנשיג דיוק אימון גבוה יותר, כי אנחנו משתמשים ברשת חזקה יותר עם פרמטרים רבים יותר, אבל דיוק האימות לא יעלה באותה מידה.\n", "\n", - "אל תהססו לשחרר עוד כמה שכבות של הרשת ולהמשיך באימון, כדי לראות אם תוכלו להשיג דיוק גבוה יותר!\n" + "אל תהסס לשחרר עוד שכבות מהרשת ולאמן יותר, כדי לבדוק אם תוכל להשיג דיוק גבוה יותר!\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## מודלים נוספים לראייה ממוחשבת\n", + "## מודלים אחרים של חזון ממוחשב\n", "\n", - "VGG-16 היא אחת הארכיטקטורות הפשוטות ביותר לראייה ממוחשבת. Keras מספקת עוד רשתות רבות שכוונו מראש. בין הרשתות הנפוצות ביותר נמצאות ארכיטקטורות **ResNet**, שפותחו על ידי Microsoft, ו-**Inception** של Google. לדוגמה, בואו נחקור את הארכיטקטורה של המודל הפשוט ביותר במשפחת ResNet-50 (ResNet היא משפחה של מודלים בעומקים שונים, אתם יכולים לנסות להתנסות עם ResNet-152 אם תרצו לראות איך נראה מודל עמוק באמת):\n" + "VGG-16 הוא אחת מהארכיטקטורות הפשוטות ביותר של חזון ממוחשב. Keras מספקת רשתות מאומנות נוספות רבות. הנפוצות שבהן הן ארכיטקטורות **ResNet**, שפותחו על ידי מיקרוסופט, ו-**Inception** של גוגל. לדוגמה, נחקור את הארכיטקטורה של הדגם הפשוט ביותר ResNet-50 (ResNet היא משפחה של מודלים בעומקים שונים, ואתה יכול לנסות להתנסות עם ResNet-152 אם אתה רוצה לראות איך נראית מודל עמוק באמת):\n" ] }, { @@ -1444,29 +1452,29 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "כפי שניתן לראות, המודל מכיל את אותם אבני בניין מוכרות: שכבות קונבולוציה, שכבות איגום ושכבת סיווג צפופה בסוף. ניתן להשתמש במודל הזה בדיוק באותו אופן שבו השתמשנו ב-VGG-16 ללמידה מעוברת. אתם יכולים לנסות להתנסות בקוד שמעל, להשתמש במודלים שונים של ResNet כמודל בסיס, ולראות כיצד דיוק התוצאות משתנה.\n", + "כפי שניתן לראות, המודל מכיל את אותם בלוקים מוכרים: שכבות קונבולוציה, שכבות ריכוז ומסווג צפוף סופי. אנו יכולים להשתמש במודל זה באותו אופן בדיוק שבו השתמשנו ב-VGG-16 ללמידת העברה. אתם יכולים לנסות להתנסות עם הקוד למעלה, להשתמש במודלים שונים של ResNet בתור המודל הבסיסי, ולראות כיצד הדיוק משתנה.\n", "\n", "## נירמול אצווה\n", "\n", - "הרשת הזו מכילה סוג נוסף של שכבה: **נירמול אצווה**. הרעיון של נירמול אצווה הוא להביא את הערכים שעוברים דרך הרשת העצבית לטווח הנכון. בדרך כלל, רשתות עצביות פועלות בצורה הטובה ביותר כאשר כל הערכים נמצאים בטווח של [-1,1] או [0,1], ולכן אנו מתאימים/מנרמלים את נתוני הקלט שלנו בהתאם. עם זאת, במהלך האימון של רשת עמוקה, יכול לקרות שהערכים יוצאים משמעותית מהטווח הזה, מה שגורם לבעיות באימון. שכבת נירמול אצווה מחשבת ממוצע וסטיית תקן לכל הערכים של האצווה הנוכחית, ומשתמשת בהם כדי לנרמל את האות לפני שהוא עובר דרך שכבת רשת עצבית. זה משפר באופן משמעותי את היציבות של רשתות עמוקות.\n" + "רשת זו מכילה סוג נוסף של שכבה: **נירמול אצווה**. הרעיון בנירמול אצווה הוא להביא ערכים הזורמים דרך רשת הנוירונים לתחום הנכון. בדרך כלל רשתות נוירונים עובדות בצורה הטובה ביותר כאשר כל הערכים בטווח של [-1,1] או [0,1], ולכן אנו משלימים/מנרמלים את נתוני הכניסה בהתאם. עם זאת, במהלך אימון של רשת עמוקה, ייתכן שערכים יצאו משמעותית מהטווח הזה, מה שהופך את האימון לבעייתי. שכבת נירמול האצווה מחשבת ממוצע וסטיית תקן לכל הערכים של האצווה הנוכחית, ומשתמשת בהם לנירמול האות לפני שהוא עובר דרך שכבת רשת הנוירונים. זה משפר משמעותית את היציבות של רשתות עמוקות.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## מסקנות\n", + "## מסקנה\n", "\n", - "באמצעות למידת העברה, הצלחנו להרכיב במהירות מסווג למשימת סיווג האובייקטים המותאמת שלנו ולהשיג דיוק גבוה. עם זאת, הדוגמה הזו לא הייתה לגמרי הוגנת, מכיוון שרשת VGG-16 המקורית אומנה מראש לזהות חתולים וכלבים, ולכן פשוט השתמשנו מחדש ברוב הדפוסים שכבר היו קיימים ברשת. ניתן לצפות לדיוק נמוך יותר באובייקטים ייחודיים מתחומים ספציפיים, כמו פרטים בקו ייצור במפעל או עלים שונים של עצים.\n", + "באמצעות למידה בהעברה, הצלחנו להרכיב במהירות מסווג למשימה המותאמת שלנו של סיווג אובייקטים, ולהשיג דיוק גבוה. עם זאת, דוגמה זו לא הייתה הוגנת לחלוטין, מכיוון שרשת VGG-16 המקורית אומנה מראש לזהות חתולים וכלבים, ולכן השתמשנו בעיקר בדפוסים שכבר היו קיימים ברשת. ניתן לצפות לדיוק נמוך יותר באובייקטים ייחודיים יותר לתחום מסוים, כמו פרטים בקו ייצור במפעל, או עלים שונים של עצים.\n", "\n", - "ניתן לראות שמשימות מורכבות יותר שאנחנו פותרים כיום דורשות כוח חישוב גבוה יותר, ולא ניתן לפתור אותן בקלות על גבי מעבד (CPU). ביחידה הבאה, ננסה להשתמש ביישום קל יותר כדי לאמן את אותו מודל תוך שימוש במשאבי חישוב נמוכים יותר, מה שמוביל לירידה קלה בלבד בדיוק.\n" + "ניתן לראות שמשימות מורכבות יותר שאנו פותרים עכשיו דורשות כוח חישובי גבוה יותר, ולא ניתן לפתור אותן בקלות על ה-CPU. ביחידה הבאה, ננסה להשתמש ביישום קל יותר כדי לאמן את אותו הדגם עם משאבי חישוב נמוכים יותר, מה שיביא רק לדיוק מעט נמוך יותר.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "\n---\n\n**כתב ויתור**: \nמסמך זה תורגם באמצעות שירות תרגום מבוסס בינה מלאכותית [Co-op Translator](https://github.com/Azure/co-op-translator). למרות שאנו שואפים לדיוק, יש לקחת בחשבון שתרגומים אוטומטיים עשויים להכיל שגיאות או אי דיוקים. המסמך המקורי בשפתו המקורית צריך להיחשב כמקור סמכותי. עבור מידע קריטי, מומלץ להשתמש בתרגום מקצועי על ידי אדם. איננו נושאים באחריות לאי הבנות או לפרשנויות שגויות הנובעות משימוש בתרגום זה.\n" + "---\n\n\n**כתב ויתור**:\nמסמך זה תורגם באמצעות שירות תרגום אוטומטי [Co-op Translator](https://github.com/Azure/co-op-translator). למרות שאנו שואפים לדיוק, יש לקחת בחשבון שתרגומים אוטומטיים עלולים להכיל שגיאות או אי-דיוקים. יש להחשיב את המסמך המקורי בשפתו הטבעית כמקור הסמכות. למידע קריטי מומלץ להשתמש בתרגום מקצועי על ידי מתרגם אדם. אנו לא אחראים לכל אי-הבנה או פירוש שגוי הנובע מהשימוש בתרגום זה.\n\n" ] } ], @@ -1487,12 +1495,6 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.10" - }, - "coopTranslator": { - "original_hash": "c189abc107848f96051085cc30945129", - "translation_date": "2025-08-28T20:37:37+00:00", - "source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb", - "language_code": "he" } }, "nbformat": 4, diff --git a/translations/he/lessons/5-NLP/README.md b/translations/he/lessons/5-NLP/README.md index 53d366ac..789f48c6 100644 --- a/translations/he/lessons/5-NLP/README.md +++ b/translations/he/lessons/5-NLP/README.md @@ -1,44 +1,36 @@ # עיבוד שפה טבעית -![סיכום משימות NLP בציור](../../../../translated_images/he/ai-nlp.b22dcb8ca4707cea.webp) +![סיכום משימות NLP ברישום](../../../../translated_images/he/ai-nlp.b22dcb8ca4707cea.webp) -בפרק זה נתמקד בשימוש ברשתות נוירונים לטיפול במשימות הקשורות ל**עיבוד שפה טבעית (NLP)**. ישנם הרבה בעיות NLP שאנו רוצים שמחשבים יוכלו לפתור: +בחלק זה, נתרכז בשימוש ברשתות עצביות כדי לטפל במשימות הקשורות ל**עיבוד שפה טבעית (NLP)**. ישנן בעיות רבות ב-NLP שרוצים שהמחשב יוכל לפתור: -* **סיווג טקסט** הוא בעיית סיווג טיפוסית המתייחסת לרצפי טקסט. דוגמאות כוללות סיווג הודעות דוא"ל כספאם או לא-ספאם, או קטלוג מאמרים כתחום ספורט, עסקים, פוליטיקה וכו'. בנוסף, בעת פיתוח צ'אטבוטים, לעיתים קרובות יש צורך להבין מה המשתמש רצה לומר — במקרה זה אנו מתמודדים עם **סיווג כוונה**. לעיתים קרובות, בסיווג כוונה יש להתמודד עם קטגוריות רבות. +* **מיון טקסט** היא בעיית מיון טיפוסית הקשורה ברצפי טקסט. דוגמאות כוללות מיון הודעות דואר אלקטרוני כספאם לעומת לא ספאם, או סיווג מאמרים כספורט, עסקים, פוליטיקה וכו'. בנוסף, בפיתוח בוטים לשיחה, לעיתים קרובות יש צורך להבין מה המשתמש רצה לומר – במקרה זה אנו עוסקים ב**מיון כוונה**. לעיתים קרובות, במיון כוונה יש צורך להתמודד עם קטגוריות רבות. +* **ניתוח סנטימנטים** היא בעיית רגרסיה טיפוסית, שבה יש לייחס מספר (סנטימנט) המייצג עד כמה המשמעות של המשפט היא חיובית או שלילית. גרסה מתקדמת יותר של ניתוח סנטימנטים היא **ניתוח סנטימנטים מבוסס היבטים** (ABSA), שבו מייחסים סנטימנט לא לכל המשפט, אלא לחלקים שונים בו (היבטים), למשל *במסעדה הזו אהבתי את המטבח, אבל האווירה הייתה נוראית*. +* **זיהוי ישויות שמיות** (NER) מתייחס לבעיה של חילוץ ישויות מסוימות מתוך הטקסט. לדוגמה, ייתכן שנצטרך להבין שבביטוי *אני צריך לטוס לפריז מחר* המילה *מחר* מתייחסת לתאריך, ו-*פריז* היא מיקום. +* **חילוץ מילות מפתח** דומה ל-NER, אך יש לחלץ מילים החשובות למשמעות המשפט באופן אוטומטי, ללא אימון מוקדם לסוגי ישויות ספציפיים. +* **קיבוץ טקסט** יכול להיות שימושי כאשר רוצים לקבץ יחד משפטים דומים, למשל בקשות דומות בשיחות תמיכה טכנית. +* **מענה לשאלות** מתייחס ליכולת של מודל לענות על שאלה ספציפית. המודל מקבל קטע טקסט ושאלה כקלט, והוא צריך לספק מקום בטקסט שבו קיימת התשובה לשאלה (או, לפעמים, לייצר את טקסט התשובה). +* **יצירת טקסט** היא היכולת של מודל לייצר טקסט חדש. ניתן לראות זאת כמשימת מיון החוזה על האות/מילה הבאה בהתבסס על *פרומפט טקסט*. מודלים מתקדמים ליצירת טקסט, כמו GPT-3, מסוגלים לפתור משימות NLP נוספות כמו מיון באמצעות טכניקה שנקראת [תכנות פרומפט](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) או [הנדסת פרומפטים](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29) +* **סיכום טקסט** היא טכניקה שבה רוצים שהמחשב "יקרא" טקסט ארוך ויסכם אותו בכמה משפטים. +* **תרגום מכונה** ניתן לראות כשילוב של הבנת טקסט בשפה אחת, ויצירת טקסט בשפה אחרת. -* **ניתוח רגשות** הוא בעיית רגרסיה טיפוסית, שבה יש לייחס מספר (רגש) המתאר עד כמה המשמעות של משפט היא חיובית או שלילית. גרסה מתקדמת יותר של ניתוח רגשות היא **ניתוח רגשות מבוסס היבטים** (ABSA), שבו אנו מייחסים רגש לא למשפט כולו, אלא לחלקים שונים בו (היבטים), לדוגמה: *במסעדה הזו אהבתי את האוכל, אבל האווירה הייתה נוראית*. +בתחילה, רוב משימות ה-NLP נפתרו באמצעות שיטות מסורתיות כמו דקדוק. לדוגמה, בתרגום מכונה השתמשו ב-parserים כדי להפוך משפט ראשוני לעץ תחבירי, ואז חילצו מבנים סמנטיים ברמה גבוהה כדי לייצג את משמעות המשפט, ועל בסיס משמעות זו ודקדוק שפת היעד נוצר התוצאה. כיום, משימות NLP רבות נפתרות בצורה יעילה יותר באמצעות רשתות עצביות. -* **זיהוי ישויות בשם** (NER) מתייחס לבעיה של חילוץ ישויות מסוימות מטקסט. לדוגמה, ייתכן שנצטרך להבין שבביטוי *אני צריך לטוס לפריז מחר* המילה *מחר* מתייחסת לתאריך, ו*פריז* היא מיקום. +> שיטות NLP קלאסיות רבות יושמו בספריית הפייתון [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org). קיימת גם [ספריית NLTK](https://www.nltk.org/book/) מעולה זמינה באינטרנט שמסבירה כיצד לפתור משימות NLP שונות בעזרת NLTK. -* **חילוץ מילות מפתח** דומה ל-NER, אך כאן יש לחלץ מילים החשובות למשמעות המשפט באופן אוטומטי, ללא אימון מוקדם על סוגי ישויות מסוימים. +בקורס שלנו נתמקד בעיקר בשימוש ברשתות עצביות ל-NLP, ונעשה שימוש ב-NLTK במקומות הנדרשים. -* **אשכולות טקסט** יכולים להיות שימושיים כאשר אנו רוצים לקבץ יחד משפטים דומים, לדוגמה, בקשות דומות בשיחות תמיכה טכנית. - -* **מענה על שאלות** מתייחס ליכולת של מודל לענות על שאלה מסוימת. המודל מקבל קטע טקסט ושאלה כקלט, והוא צריך לספק מקום בטקסט שבו נמצאת התשובה לשאלה (או, לעיתים, לייצר את טקסט התשובה). - -* **יצירת טקסט** היא היכולת של מודל לייצר טקסט חדש. ניתן לראות זאת כמשימת סיווג שמנבאת את האות/המילה הבאה בהתבסס על *טקסט פתיחה*. מודלים מתקדמים ליצירת טקסט, כמו GPT-3, מסוגלים לפתור משימות NLP אחרות כמו סיווג באמצעות טכניקה הנקראת [תכנות באמצעות הנחיות](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) או [הנדסת הנחיות](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29). - -* **סיכום טקסט** הוא טכניקה שבה אנו רוצים שמחשב "יקרא" טקסט ארוך ויסכם אותו בכמה משפטים. - -* **תרגום מכונה** ניתן לראות כשילוב של הבנת טקסט בשפה אחת ויצירת טקסט בשפה אחרת. - -בהתחלה, רוב משימות ה-NLP נפתרו באמצעות שיטות מסורתיות כמו דקדוקים. לדוגמה, בתרגום מכונה נעשה שימוש במנתחים כדי להפוך משפט ראשוני לעץ תחבירי, ואז הופקו מבנים סמנטיים ברמה גבוהה כדי לייצג את משמעות המשפט, ועל בסיס משמעות זו ודקדוק השפה היעד נוצר התוצאה. כיום, משימות NLP רבות נפתרות בצורה יעילה יותר באמצעות רשתות נוירונים. - -> שיטות NLP קלאסיות רבות מיושמות בספריית Python בשם [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org). ישנו [ספר NLTK](https://www.nltk.org/book/) מצוין הזמין אונליין שמסביר כיצד ניתן לפתור משימות NLP שונות באמצעות NLTK. - -בקורס שלנו, נתמקד בעיקר בשימוש ברשתות נוירונים ל-NLP, ונשתמש ב-NLTK במידת הצורך. - -כבר למדנו על שימוש ברשתות נוירונים לטיפול בנתונים טבלאיים ובתמונות. ההבדל העיקרי בין סוגי הנתונים הללו לטקסט הוא שטקסט הוא רצף באורך משתנה, בעוד שגודל הקלט במקרה של תמונות ידוע מראש. בעוד שרשתות קונבולוציה יכולות לחלץ תבניות מנתוני קלט, התבניות בטקסט מורכבות יותר. לדוגמה, ייתכן שישנה שלילה המופרדת מהנושא על ידי מילים רבות (לדוגמה: *אני לא אוהב תפוזים* לעומת *אני לא אוהב את התפוזים הגדולים הצבעוניים והטעימים האלה*), ועדיין יש לפרש זאת כתבנית אחת. לכן, כדי להתמודד עם שפה, יש להציג סוגי רשתות נוירונים חדשים, כמו *רשתות חוזרות* ו*טרנספורמרים*. +כבר למדתם על שימוש ברשתות עצביות לטיפול בנתונים טבלאיים ותמונות. ההבדל העיקרי בין סוגי הנתונים הללו לטקסט הוא שטקסט הוא רצף באורך משתנה, בעוד שגודל הקלט במקרה של תמונות ידוע מראש. בעוד שרשתות קונבולוציה יכולות לחלץ תבניות מנתוני הקלט, התבניות בטקסט מורכבות יותר. לדוגמה, ניגודיות בין מילים יכולה להיות מופרדת מנושא על ידי מילים רבות (למשל *אני לא אוהב תפוזים* לעומת *אני לא אוהב את התפוזים הגדולים, הצבעוניים והטעימים האלה*), וזה עדיין צריך להתפרש כתבנית אחת. לכן, כדי להתמודד עם שפה יש להציג סוגים חדשים של רשתות עצביות, כמו *רשתות חוזרות* ו*טרנספורמרים*. ## התקנת ספריות -אם אתם משתמשים בהתקנת Python מקומית להפעלת הקורס, ייתכן שתצטרכו להתקין את כל הספריות הנדרשות ל-NLP באמצעות הפקודות הבאות: +אם אתם משתמשים בהתקנת פייתון מקומית על מנת להריץ את הקורס, ייתכן שתצטרכו להתקין את כל הספריות הדרושות ל-NLP בעזרת הפקודות הבאות: -**עבור PyTorch** +**ל-PyTorch** ```bash -pip install -r requirements-torch.txt +pip install -r requirements-pytorch.txt ``` -**עבור TensorFlow** +**ל-TensorFlow** ```bash pip install -r requirements-tf.txt ``` @@ -47,13 +39,13 @@ pip install -r requirements-tf.txt ## אזהרת GPU -בפרק זה, בחלק מהדוגמאות נבצע אימון של מודלים גדולים למדי. -* **שימוש במחשב עם GPU**: מומלץ להפעיל את המחברות שלכם על מחשב עם GPU כדי לקצר את זמני ההמתנה בעת עבודה עם מודלים גדולים. -* **מגבלות זיכרון GPU**: עבודה עם GPU עשויה להוביל למצבים שבהם נגמר זיכרון ה-GPU, במיוחד בעת אימון מודלים גדולים. -* **צריכת זיכרון GPU**: כמות זיכרון ה-GPU הנצרכת במהלך האימון תלויה בגורמים שונים, כולל גודל המיניבאץ'. -* **הקטנת גודל מיניבאץ'**: אם אתם נתקלים בבעיות זיכרון GPU, שקלו להקטין את גודל המיניבאץ' בקוד שלכם כפתרון אפשרי. -* **שחרור זיכרון GPU ב-TensorFlow**: גרסאות ישנות של TensorFlow עשויות לא לשחרר זיכרון GPU כראוי בעת אימון מודלים מרובים בתוך קרנל Python אחד. כדי לנהל את השימוש בזיכרון GPU בצורה יעילה, ניתן להגדיר את TensorFlow להקצות זיכרון GPU רק לפי הצורך. -* **הוספת קוד**: כדי להגדיר את TensorFlow כך שיגדיל את הקצאת זיכרון ה-GPU רק בעת הצורך, הוסיפו את הקוד הבא למחברות שלכם: +בחלק זה, בכמה מהדוגמאות נלמד להדריך מודלים גדולים למדי. +* **השתמשו במחשב עם GPU**: מומלץ להריץ את המחברות שלכם על מחשב עם GPU להפחתת זמני ההמתנה בעת עבודה עם מודלים גדולים. +* **מגבלות זיכרון GPU**: עבודה עם GPU עלולה לגרום לכך שייגמר זיכרון ה-GPU, במיוחד בעת הדרכת מודלים גדולים. +* **צריכת זיכרון GPU**: כמות זיכרון ה-GPU הנצרכת במהלך ההדרכה תלויה בגורמים רבים, כולל גודל המיני-אצווה. +* **הקטנת גודל מיני-אצווה**: אם אתם נתקלים בבעיות זיכרון GPU, שקלו להקטין את גודל המיני-אצווה בקוד שלכם כפתרון אפשרי. +* **שחרור זיכרון GPU ב-TensorFlow**: גרסאות ישנות של TensorFlow עשויות שלא לשחרר את זיכרון ה-GPU כראוי בעת הדרכת מספר מודלים באותה ליבת פייתון. כדי לנהל שימוש בזיכרון GPU בצורה יעילה, ניתן לקבוע ב-TensorFlow להקצות זיכרון GPU רק לפי הצורך. +* **הכללת קוד**: על מנת לגדיר את TensorFlow להגדיל את הקצאת זיכרון ה-GPU רק בעת הצורך, יש לכלול את הקוד הבא במחברות שלכם: ```python physical_devices = tf.config.list_physical_devices('GPU') @@ -61,19 +53,21 @@ if len(physical_devices)>0: tf.config.experimental.set_memory_growth(physical_devices[0], True) ``` -אם אתם מעוניינים ללמוד על NLP מנקודת מבט של למידת מכונה קלאסית, בקרו ב-[סדרת השיעורים הזו](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP). +אם אתם מעוניינים ללמוד על NLP מפרספקטיבה קלאסית של למידת מכונה, בקרו ב[סדרת השיעורים הזו](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP) -## בפרק זה -בפרק זה נלמד על: +## בחלק זה +בחלק זה נלמד על: -* [ייצוג טקסט כטנסורים](13-TextRep/README.md) -* [הטמעות מילים](14-Emdeddings/README.md) -* [מודלים לשוניים](15-LanguageModeling/README.md) -* [רשתות נוירונים חוזרות](16-RNN/README.md) +* [ייצוג טקסט כמטריצות](13-TextRep/README.md) +* [הנחת מילים](14-Emdeddings/README.md) +* [מודלינג שפה](15-LanguageModeling/README.md) +* [רשתות עצביות חוזרות](16-RNN/README.md) * [רשתות גנרטיביות](17-GenerativeNetworks/README.md) * [טרנספורמרים](18-Transformers/README.md) --- -**כתב ויתור**: -מסמך זה תורגם באמצעות שירות תרגום מבוסס בינה מלאכותית [Co-op Translator](https://github.com/Azure/co-op-translator). בעוד שאנו שואפים לדיוק, יש להיות מודעים לכך שתרגומים אוטומטיים עשויים להכיל שגיאות או אי דיוקים. המסמך המקורי בשפתו המקורית צריך להיחשב כמקור סמכותי. עבור מידע קריטי, מומלץ להשתמש בתרגום מקצועי על ידי אדם. איננו נושאים באחריות לאי הבנות או לפרשנויות שגויות הנובעות משימוש בתרגום זה. \ No newline at end of file + +**כתב ויתור**: +מסמך זה תורגם באמצעות שירות תרגום אוטומטי [Co-op Translator](https://github.com/Azure/co-op-translator). למרות שאנו שואפים לדיוק, יש לקחת בחשבון שתרגומים אוטומטיים עלולים להכיל שגיאות או אי-דיוקים. יש להחשיב את המסמך המקורי בשפתו הטבעית כמקור הסמכות. למידע קריטי מומלץ להשתמש בתרגום מקצועי על ידי מתרגם אדם. אנו לא אחראים לכל אי-הבנה או פירוש שגוי הנובע מהשימוש בתרגום זה. + \ No newline at end of file diff --git a/translations/id/.co-op-translator.json b/translations/id/.co-op-translator.json index 2301d21a..ffffd4d0 100644 --- a/translations/id/.co-op-translator.json +++ b/translations/id/.co-op-translator.json @@ -5,6 +5,12 @@ "source_file": "AGENTS.md", "language_code": "id" }, + "CONTRIBUTING.md": { + "original_hash": "c6fd7e781b67111a90abd166d0ce4aa0", + "translation_date": "2026-07-08T16:18:45+00:00", + "source_file": "CONTRIBUTING.md", + "language_code": "id" + }, "README.md": { "original_hash": "12c8eb6bf0867d2f1c32daf613ac5b8b", "translation_date": "2026-04-06T20:28:05+00:00", @@ -17,6 +23,19 @@ "source_file": "SECURITY.md", "language_code": "id" }, + "__translation_failures__": { + "lessons/sketchnotes/LICENSE.md": { + "original_hash": "45ab63a2cd8f5faef6c9b150618837a4", + "source_file": "lessons/sketchnotes/LICENSE.md", + "language_code": "id", + "failure_date": "2026-07-08T16:18:13+00:00", + "status": "failed", + "error_type": "TranslationIncompleteError", + "error_message": "Markdown translation remained incomplete for chunk 1.1.1 of 'LICENSE.md', and the chunk could not be split further.", + "translator_version": "0.20.0", + "failure_policy_version": 1 + } + }, "etc/CODE_OF_CONDUCT.md": { "original_hash": "c06b12caf3c901eb3156e3dd5b0aea56", "translation_date": "2025-08-29T12:52:28+00:00", @@ -54,8 +73,8 @@ "language_code": "id" }, "examples/README.md": { - "original_hash": "0d1babfdcbeb46525f2db3fbaaa54cd7", - "translation_date": "2025-10-03T11:32:36+00:00", + "original_hash": "7883d52c2e2a221e0b07a7b112a149b9", + "translation_date": "2026-07-08T16:13:49+00:00", "source_file": "examples/README.md", "language_code": "id" }, @@ -66,8 +85,8 @@ "language_code": "id" }, "lessons/0-course-setup/how-to-run.md": { - "original_hash": "a4717bd9103b9f6cd84d534b83534689", - "translation_date": "2026-01-16T03:44:39+00:00", + "original_hash": "7ad8c7d8604c53649b3d4d1e2f3a6fa1", + "translation_date": "2026-07-08T16:14:09+00:00", "source_file": "lessons/0-course-setup/how-to-run.md", "language_code": "id" }, @@ -191,6 +210,12 @@ "source_file": "lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md", "language_code": "id" }, + "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb": { + "original_hash": "99b816b6a4957ef4100cee4c4221dff9", + "translation_date": "2026-07-08T16:00:35+00:00", + "source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb", + "language_code": "id" + }, "lessons/4-ComputerVision/08-TransferLearning/lab/README.md": { "original_hash": "7765935c35fcee69b9fe2d0cfd6963e2", "translation_date": "2025-08-29T12:22:38+00:00", @@ -330,8 +355,8 @@ "language_code": "id" }, "lessons/5-NLP/README.md": { - "original_hash": "8ef02a9318257ea140ed3ed74442096d", - "translation_date": "2025-08-29T12:41:43+00:00", + "original_hash": "038df6f1a73e49f6430740da083bfd6d", + "translation_date": "2026-07-08T16:14:31+00:00", "source_file": "lessons/5-NLP/README.md", "language_code": "id" }, diff --git a/translations/id/CONTRIBUTING.md b/translations/id/CONTRIBUTING.md new file mode 100644 index 00000000..b75ebb2e --- /dev/null +++ b/translations/id/CONTRIBUTING.md @@ -0,0 +1,29 @@ +# Berkontribusi pada AI-For-Beginners + +Terima kasih atas minat Anda untuk berkontribusi pada AI-For-Beginners! Kami menyambut terjemahan, perbaikan pelajaran, dan koreksi format. + +## Perjanjian Lisensi Kontributor (CLA) Microsoft + +Proyek ini menyambut kontribusi dan saran. Sebagian besar kontribusi mengharuskan Anda menyetujui Perjanjian Lisensi Kontributor (CLA) yang menyatakan bahwa Anda memiliki hak, dan memang memberikan kami hak untuk menggunakan kontribusi Anda. Untuk detail, kunjungi [https://cla.microsoft.com](https://cla.microsoft.com). + +Saat Anda mengajukan pull request, bot CLA secara otomatis akan menentukan apakah Anda perlu memberikan CLA dan menghias PR dengan tepat (misalnya, label, komentar). Cukup ikuti instruksi yang diberikan oleh bot. Anda hanya perlu melakukan ini sekali di seluruh repositori yang menggunakan CLA kami. + +## Cara Berkontribusi + +### 1. Memperbaiki Typo / Kesalahan Kode +Jika Anda menemukan typo atau bug di notebook Jupyter atau file markdown pelajaran manapun: +1. Fork repositori tersebut. +2. Perbaiki typo atau tautan yang rusak. +3. Ajukan Pull Request dengan deskripsi perbaikan yang jelas. + +### 2. Mengajukan Terjemahan +Kami menyambut terjemahan pelajaran ke dalam bahasa lain! Silakan letakkan terjemahan di bawah direktori `translations/` dengan menggunakan nama folder yang sudah ada di sana (misalnya `translations/es/`, `translations/pt-BR/`, `translations/zh-CN/`). + +Untuk detail lebih lanjut, lihat [etc/CONTRIBUTING.md](etc/CONTRIBUTING.md). + +--- + + +**Penafian**: +Dokumen ini telah diterjemahkan menggunakan layanan terjemahan AI [Co-op Translator](https://github.com/Azure/co-op-translator). Meskipun kami berupaya untuk mencapai akurasi, harap diketahui bahwa terjemahan otomatis mungkin mengandung kesalahan atau ketidakakuratan. Dokumen asli dalam bahasa aslinya harus dianggap sebagai sumber yang sah. Untuk informasi penting, disarankan menggunakan terjemahan profesional oleh manusia. Kami tidak bertanggung jawab atas kesalahpahaman atau penafsiran yang keliru yang timbul dari penggunaan terjemahan ini. + \ No newline at end of file diff --git a/translations/id/examples/README.md b/translations/id/examples/README.md index 1b7017b0..71923b15 100644 --- a/translations/id/examples/README.md +++ b/translations/id/examples/README.md @@ -1,27 +1,27 @@ -# Contoh AI Ramah Pemula +# Contoh AI untuk Pemula -Selamat datang! Direktori ini berisi contoh sederhana dan mandiri untuk membantu Anda memulai dengan AI dan pembelajaran mesin. Setiap contoh dirancang agar mudah dipahami dengan komentar yang rinci dan penjelasan langkah demi langkah. +Selamat datang! Direktori ini berisi contoh sederhana dan mandiri untuk membantu Anda memulai dengan AI dan pembelajaran mesin. Setiap contoh dirancang ramah pemula dengan komentar terperinci dan penjelasan langkah demi langkah. -## 📚 Gambaran Contoh +## 📚 Ikhtisar Contoh | Contoh | Deskripsi | Tingkat Kesulitan | Prasyarat | -|--------|-----------|-------------------|-----------| -| [Hello AI World](../../../examples/01-hello-ai-world.py) | Program AI pertama Anda - pengenalan pola sederhana | ⭐ Pemula | Dasar-dasar Python | -| [Simple Neural Network](../../../examples/02-simple-neural-network.py) | Membangun jaringan neural dari awal | ⭐⭐ Pemula+ | Python, matematika dasar | -| [Image Classifier](./03-image-classifier.ipynb) | Mengklasifikasi gambar dengan model yang sudah dilatih | ⭐⭐ Pemula+ | Python, numpy | -| [Text Sentiment](../../../examples/04-text-sentiment.py) | Menganalisis sentimen teks (positif/negatif) | ⭐⭐ Pemula+ | Python | +|---------|-------------|------------|---------------| +| [Hello AI World](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/01-hello-ai-world.py) | Program AI pertamamu - pengenalan pola sederhana | ⭐ Pemula | Dasar Python | +| [Simple Neural Network](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/02-simple-neural-network.py) | Membuat jaringan saraf dari awal | ⭐⭐ Pemula+ | Python, matematika dasar | +| [Image Classifier](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/03-image-classifier.ipynb) | Mengklasifikasikan gambar dengan model yang sudah dilatih | ⭐⭐ Pemula+ | Python, numpy | +| [Text Sentiment](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/04-text-sentiment.py) | Menganalisis sentimen teks (positif/negatif) | ⭐⭐ Pemula+ | Python | ## 🚀 Memulai ### Prasyarat -Pastikan Anda sudah menginstal Python (disarankan versi 3.8 atau lebih tinggi). Instal paket yang diperlukan: +Pastikan Anda telah menginstal Python (3.8 atau lebih tinggi disarankan). Instal paket yang diperlukan: ```bash -# For Python scripts +# Untuk skrip Python pip install numpy -# For Jupyter notebooks (image classifier) +# Untuk notebook Jupyter (pengklasifikasi gambar) pip install jupyter numpy pillow tensorflow ``` @@ -34,43 +34,43 @@ conda activate ai4beg ### Menjalankan Contoh -**Untuk skrip Python (.py files):** +**Untuk skrip Python (.py):** ```bash python 01-hello-ai-world.py ``` -**Untuk Jupyter notebooks (.ipynb files):** +**Untuk notebook Jupyter (.ipynb):** ```bash jupyter notebook 03-image-classifier.ipynb ``` ## 📖 Jalur Pembelajaran -Kami merekomendasikan mengikuti contoh secara berurutan: +Kami menyarankan mengikuti contoh secara urut: -1. **Mulai dengan "Hello AI World"** - Pelajari dasar-dasar pengenalan pola -2. **Bangun Jaringan Neural Sederhana** - Pahami cara kerja jaringan neural +1. **Mulai dengan "Hello AI World"** - Pelajari dasar pengenalan pola +2. **Bangun Jaringan Saraf Sederhana** - Pahami cara kerja jaringan saraf 3. **Coba Pengklasifikasi Gambar** - Lihat AI beraksi dengan gambar nyata 4. **Analisis Sentimen Teks** - Jelajahi pemrosesan bahasa alami ## 💡 Tips untuk Pemula -- **Baca komentar kode dengan cermat** - Mereka menjelaskan apa yang dilakukan setiap baris -- **Bereksperimen!** - Coba ubah nilai dan lihat apa yang terjadi -- **Jangan khawatir jika tidak memahami semuanya** - Belajar membutuhkan waktu -- **Ajukan pertanyaan** - Gunakan [Papan Diskusi](https://github.com/microsoft/AI-For-Beginners/discussions) +- **Baca komentar kode dengan saksama** - Mereka menjelaskan apa yang dilakukan setiap baris +- **Bereksperimenlah!** - Cobalah mengubah nilai dan lihat hasilnya +- **Jangan khawatir memahami semuanya** - Belajar itu proses yang butuh waktu +- **Ajukan pertanyaan** - Gunakan [papan Diskusi](https://github.com/microsoft/AI-For-Beginners/discussions) ## 🔗 Langkah Selanjutnya -Setelah menyelesaikan contoh-contoh ini, jelajahi kurikulum lengkap: +Setelah menyelesaikan contoh ini, jelajahi kurikulum lengkap: - [Pengantar AI](../lessons/1-Intro/README.md) -- [Jaringan Neural](../lessons/3-NeuralNetworks/README.md) -- [Visi Komputer](../lessons/4-ComputerVision/README.md) +- [Jaringan Saraf](../lessons/3-NeuralNetworks/README.md) +- [Penglihatan Komputer](../lessons/4-ComputerVision/README.md) - [Pemrosesan Bahasa Alami](../lessons/5-NLP/README.md) -## 🤝 Kontribusi +## 🤝 Berkontribusi -Apakah contoh-contoh ini membantu Anda? Bantu kami untuk meningkatkannya: +Menemukan contoh ini bermanfaat? Bantu kami memperbaikinya: - Laporkan masalah atau usulkan perbaikan - Tambahkan lebih banyak contoh untuk pemula - Tingkatkan dokumentasi dan komentar @@ -81,5 +81,7 @@ Apakah contoh-contoh ini membantu Anda? Bantu kami untuk meningkatkannya: --- -**Penafian**: -Dokumen ini telah diterjemahkan menggunakan layanan penerjemahan AI [Co-op Translator](https://github.com/Azure/co-op-translator). Meskipun kami berusaha untuk memberikan hasil yang akurat, harap diperhatikan bahwa terjemahan otomatis mungkin mengandung kesalahan atau ketidakakuratan. Dokumen asli dalam bahasa aslinya harus dianggap sebagai sumber yang otoritatif. Untuk informasi yang bersifat kritis, disarankan menggunakan jasa penerjemahan manusia profesional. Kami tidak bertanggung jawab atas kesalahpahaman atau penafsiran yang keliru yang timbul dari penggunaan terjemahan ini. \ No newline at end of file + +**Penafian**: +Dokumen ini telah diterjemahkan menggunakan layanan terjemahan AI [Co-op Translator](https://github.com/Azure/co-op-translator). Meskipun kami berupaya untuk mencapai akurasi, harap diketahui bahwa terjemahan otomatis mungkin mengandung kesalahan atau ketidakakuratan. Dokumen asli dalam bahasa aslinya harus dianggap sebagai sumber yang sah. Untuk informasi penting, disarankan menggunakan terjemahan profesional oleh manusia. Kami tidak bertanggung jawab atas kesalahpahaman atau penafsiran yang keliru yang timbul dari penggunaan terjemahan ini. + \ No newline at end of file diff --git a/translations/id/lessons/0-course-setup/how-to-run.md b/translations/id/lessons/0-course-setup/how-to-run.md index 79901a5b..9a6cbe98 100644 --- a/translations/id/lessons/0-course-setup/how-to-run.md +++ b/translations/id/lessons/0-course-setup/how-to-run.md @@ -1,10 +1,10 @@ # Cara Menjalankan Kode -Kurikulum ini berisi banyak contoh dan lab yang dapat dieksekusi yang ingin Anda jalankan. Untuk melakukan ini, Anda memerlukan kemampuan untuk menjalankan kode Python di Jupyter Notebooks yang disediakan sebagai bagian dari kurikulum ini. Anda memiliki beberapa opsi untuk menjalankan kodenya: +Kurikulum ini berisi banyak contoh dan lab yang dapat dijalankan yang mungkin ingin Anda jalankan. Untuk melakukan ini, Anda memerlukan kemampuan menjalankan kode Python di Jupyter Notebooks yang disediakan sebagai bagian dari kurikulum ini. Anda memiliki beberapa opsi untuk menjalankan kode: ## Menjalankan secara lokal di komputer Anda -Untuk menjalankan kode secara lokal di komputer Anda, diperlukan instalasi Python. Salah satu rekomendasinya adalah menginstal **[miniconda](https://conda.io/en/latest/miniconda.html)** - ini adalah instalasi yang relatif ringan yang mendukung pengelola paket `conda` untuk berbagai **lingkungan virtual** Python. +Untuk menjalankan kode secara lokal di komputer Anda, diperlukan instalasi Python. Salah satu rekomendasinya adalah menginstal **[miniconda](https://conda.io/en/latest/miniconda.html)** - ini adalah instalasi yang cukup ringan yang mendukung pengelola paket `conda` untuk berbagai **lingkungan virtual** Python. Setelah Anda menginstal miniconda, kloning repositori dan buat lingkungan virtual yang akan digunakan untuk kursus ini: @@ -21,13 +21,13 @@ Kurikulum ini paling baik digunakan saat membukanya di [Visual Studio Code](http > **Catatan**: Setelah Anda mengkloning dan membuka direktori di VS Code, secara otomatis akan menyarankan Anda untuk menginstal ekstensi Python. Anda juga perlu menginstal miniconda seperti yang dijelaskan di atas. -> **Catatan**: Jika VS Code menyarankan Anda untuk membuka kembali repositori dalam sebuah kontainer, Anda harus menolak ini untuk menggunakan instalasi Python lokal. +> **Catatan**: Jika VS Code menyarankan untuk membuka kembali repositori dalam sebuah kontainer, Anda harus menolak ini untuk menggunakan instalasi Python lokal. -### Menggunakan Jupyter di Peramban +### Menggunakan Jupyter di Browser -Anda juga dapat menggunakan lingkungan Jupyter dari peramban di komputer Anda sendiri. Baik Jupyter klasik maupun JupyterHub menyediakan lingkungan pengembangan yang nyaman dengan fitur pelengkapan otomatis, penyorotan kode, dll. +Anda juga dapat menggunakan lingkungan Jupyter dari browser di komputer Anda sendiri. Baik Jupyter klasik maupun JupyterHub menyediakan lingkungan pengembangan yang nyaman dengan auto-completion, penyorotan kode, dll. -Untuk memulai Jupyter secara lokal, buka direktori kursus, dan jalankan: +Untuk memulai Jupyter secara lokal, pergi ke direktori kursus, dan jalankan: ```bash jupyter notebook @@ -38,34 +38,34 @@ jupyterhub ``` Kemudian Anda dapat menavigasi ke salah satu file `.ipynb`, membukanya, dan mulai bekerja. -### Menjalankan dalam kontainer +### Menjalankan di dalam kontainer -Alternatif lain untuk instalasi Python adalah menjalankan kode dalam sebuah kontainer. Karena repositori kami menyediakan folder khusus `.devcontainer` yang menunjukkan cara membangun kontainer untuk repositori ini, VS Code menawarkan kesempatan untuk membuka kembali kode di dalam kontainer. Ini memerlukan instalasi Docker, dan juga akan lebih kompleks, sehingga kami merekomendasikan ini untuk pengguna yang lebih berpengalaman. +Alternatif lain untuk instalasi Python adalah menjalankan kode dalam kontainer. Karena repositori kami menyediakan folder khusus `.devcontainer` yang mengarahkan bagaimana membangun kontainer untuk repo ini, VS Code menawarkan kesempatan untuk membuka ulang kode di dalam kontainer. Ini memerlukan instalasi Docker, dan juga akan lebih kompleks, jadi kami merekomendasikan hal ini untuk pengguna yang lebih berpengalaman. ## Menjalankan di Cloud -Jika Anda tidak ingin menginstal Python secara lokal, dan memiliki akses ke beberapa sumber daya cloud - alternatif yang baik adalah menjalankan kode di cloud. Ada beberapa cara yang bisa Anda lakukan: +Jika Anda tidak ingin menginstal Python secara lokal, dan memiliki akses ke beberapa sumber daya cloud - alternatif yang baik adalah menjalankan kode di cloud. Ada beberapa cara yang dapat Anda lakukan ini: -* Menggunakan **[GitHub Codespaces](https://github.com/features/codespaces)**, yang merupakan lingkungan virtual yang dibuat untuk Anda di GitHub, dapat diakses melalui antarmuka peramban VS Code. Jika Anda memiliki akses ke Codespaces, Anda cukup mengklik tombol **Code** di repo, memulai codespace, dan langsung dapat menjalankan kodenya. -* Menggunakan **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) menyediakan sumber daya komputasi gratis di cloud bagi orang-orang seperti Anda untuk mencoba beberapa kode di GitHub. Ada tombol di halaman depan untuk membuka repositori di Binder - ini akan membawa Anda dengan cepat ke situs binder, yang akan membangun kontainer dasar dan memulai antarmuka web Jupyter untuk Anda dengan mulus. +* Menggunakan **[GitHub Codespaces](https://github.com/features/codespaces)**, yang merupakan lingkungan virtual yang dibuat untuk Anda di GitHub, dapat diakses melalui antarmuka browser VS Code. Jika Anda memiliki akses ke Codespaces, Anda hanya perlu klik tombol **Code** di repo, mulai codespace, dan segera berjalan. +* Menggunakan **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) menyediakan sumber daya komputasi gratis di cloud untuk orang-orang seperti Anda agar dapat mencoba beberapa kode di GitHub. Ada tombol di halaman depan untuk membuka repositori di Binder - ini akan membawa Anda cepat ke situs binder, yang akan membangun kontainer dasar dan memulai antarmuka web Jupyter untuk Anda secara mulus. -> **Catatan**: Untuk mencegah penyalahgunaan, Binder memblokir akses ke beberapa sumber daya web. Ini mungkin menyebabkan beberapa kode tidak dapat bekerja, yang mengambil model dan/atau dataset dari Internet publik. Anda mungkin perlu mencari solusi alternatif. Selain itu, sumber daya komputasi yang disediakan oleh Binder cukup dasar, sehingga pelatihan akan lambat, terutama pada pelajaran selanjutnya yang lebih kompleks. +> **Catatan**: Untuk mencegah penyalahgunaan, Binder memblokir akses ke beberapa sumber daya web. Ini mungkin akan menghalangi sebagian kode untuk berjalan, terutama yang mengambil model dan/atau dataset dari Internet publik. Anda mungkin perlu mencari solusi alternatif. Selain itu, sumber daya komputasi yang disediakan oleh Binder cukup dasar, jadi pelatihan akan lambat, terutama pada pelajaran yang lebih kompleks di kemudian hari. ## Menjalankan di Cloud dengan GPU -Beberapa pelajaran akhir dalam kurikulum ini akan sangat diuntungkan dengan dukungan GPU. Pelatihan model, misalnya, bisa sangat lambat jika tidak menggunakan GPU. Ada beberapa opsi yang dapat Anda ikuti, terutama jika Anda memiliki akses ke cloud baik melalui [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste), atau melalui institusi Anda: +Beberapa pelajaran terakhir dalam kurikulum ini akan sangat diuntungkan dengan dukungan GPU. Pelatihan model, misalnya, bisa sangat lambat jika tanpa GPU. Ada beberapa opsi yang dapat Anda ikuti, terutama jika Anda memiliki akses ke cloud baik melalui [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste), atau melalui institusi Anda: -* Buat [Data Science Virtual Machine](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) dan sambungkan ke sana melalui Jupyter. Anda kemudian dapat mengkloning repo langsung ke mesin tersebut, dan mulai belajar. NC-series VM menyediakan dukungan GPU. +* Buat [Data Science Virtual Machine](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) dan sambungkan ke mesin tersebut melalui Jupyter. Anda kemudian dapat mengkloning repo langsung ke mesin ini, dan mulai belajar. VM seri NC memiliki dukungan GPU. -> **Catatan**: Beberapa langganan, termasuk Azure for Students, tidak menyediakan dukungan GPU secara default. Anda mungkin perlu mengajukan permintaan dukungan teknis untuk mendapatkan core GPU tambahan. +> **Catatan**: Beberapa langganan, termasuk Azure for Students, tidak menyediakan dukungan GPU secara langsung. Anda mungkin perlu meminta tambahan inti GPU dengan permintaan dukungan teknis. -* Buat [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) dan gunakan fitur Notebook di sana. [Video ini](https://azure-for-academics.github.io/quickstart/azureml-papers/) menunjukkan cara mengkloning repositori ke notebook Azure ML dan mulai menggunakannya. +* Buat [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) dan kemudian gunakan fitur Notebook di sana. [Video ini](https://azure-for-academics.github.io/quickstart/azureml-papers/) menunjukkan cara mengkloning repositori ke dalam notebook Azure ML dan mulai menggunakannya. -Anda juga dapat menggunakan Google Colab, yang menyediakan dukungan GPU gratis terbatas, dan mengunggah Jupyter Notebooks ke sana untuk dijalankan satu per satu. +Anda juga dapat menggunakan Google Colab, yang menyertakan beberapa dukungan GPU gratis, dan mengunggah Jupyter Notebooks di sana untuk menjalankannya satu per satu. --- **Penafian**: -Dokumen ini telah diterjemahkan menggunakan layanan terjemahan AI [Co-op Translator](https://github.com/Azure/co-op-translator). Meskipun kami berusaha untuk akurasi, harap diketahui bahwa terjemahan otomatis mungkin mengandung kesalahan atau ketidaktepatan. Dokumen asli dalam bahasa aslinya harus dianggap sebagai sumber yang berwenang. Untuk informasi yang penting, disarankan menggunakan terjemahan profesional oleh manusia. Kami tidak bertanggung jawab atas kesalahpahaman atau salah tafsir yang timbul dari penggunaan terjemahan ini. +Dokumen ini telah diterjemahkan menggunakan layanan terjemahan AI [Co-op Translator](https://github.com/Azure/co-op-translator). Meskipun kami berupaya untuk mencapai akurasi, harap diketahui bahwa terjemahan otomatis mungkin mengandung kesalahan atau ketidakakuratan. Dokumen asli dalam bahasa aslinya harus dianggap sebagai sumber yang sah. Untuk informasi penting, disarankan menggunakan terjemahan profesional oleh manusia. Kami tidak bertanggung jawab atas kesalahpahaman atau penafsiran yang keliru yang timbul dari penggunaan terjemahan ini. \ No newline at end of file diff --git a/translations/id/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb b/translations/id/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb index 63d66275..209a010c 100644 --- a/translations/id/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb +++ b/translations/id/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb @@ -4,11 +4,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Model Pra-latih dan Transfer Learning\n", + "# Model yang sudah dilatih sebelumnya dan pembelajaran transfer\n", "\n", - "Melatih CNN bisa memakan banyak waktu, dan membutuhkan banyak data untuk tugas tersebut. Namun, sebagian besar waktu dihabiskan untuk mempelajari filter tingkat rendah terbaik yang digunakan jaringan untuk mengekstrak pola dari gambar. Sebuah pertanyaan alami muncul - bisakah kita menggunakan jaringan neural yang telah dilatih pada satu dataset dan mengadaptasinya untuk mengklasifikasikan gambar yang berbeda tanpa proses pelatihan penuh?\n", + "Melatih CNN bisa memakan banyak waktu, dan dibutuhkan banyak data untuk tugas tersebut. Namun, banyak waktu dihabiskan untuk mempelajari filter tingkat rendah terbaik yang digunakan jaringan untuk mengekstrak pola dari gambar. Sebuah pertanyaan alami muncul - bisakah kita menggunakan jaringan saraf yang sudah dilatih pada satu dataset dan mengadaptasinya untuk mengklasifikasikan gambar yang berbeda tanpa proses pelatihan penuh?\n", "\n", - "Pendekatan ini disebut **transfer learning**, karena kita mentransfer sebagian pengetahuan dari satu model jaringan neural ke model lainnya. Dalam transfer learning, kita biasanya memulai dengan model pra-latih, yang telah dilatih pada dataset gambar besar, seperti **ImageNet**. Model-model tersebut sudah cukup baik dalam mengekstrak berbagai fitur dari gambar umum, dan dalam banyak kasus, hanya dengan membangun sebuah classifier di atas fitur-fitur yang diekstrak tersebut dapat menghasilkan hasil yang baik.\n" + "Pendekatan ini disebut **pembelajaran transfer**, karena kita mentransfer sebagian pengetahuan dari satu model jaringan saraf ke model lain. Dalam pembelajaran transfer, biasanya kita mulai dengan model yang sudah dilatih sebelumnya, yang telah dilatih pada beberapa dataset gambar besar, seperti **ImageNet**. Model-model tersebut sudah bisa melakukan pekerjaan yang baik dalam mengekstrak berbagai fitur dari gambar generik, dan dalam banyak kasus hanya membangun klasifikator di atas fitur yang diekstrak tersebut dapat menghasilkan hasil yang baik.\n" ] }, { @@ -31,7 +31,7 @@ "source": [ "## Dataset Kucing vs. Anjing\n", "\n", - "Dalam unit ini, kita akan menyelesaikan masalah nyata dalam mengklasifikasikan gambar kucing dan anjing. Untuk alasan ini, kita akan menggunakan [Dataset Kucing vs. Anjing dari Kaggle](https://www.kaggle.com/c/dogs-vs-cats), yang juga dapat diunduh [dari Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n", + "Dalam unit ini, kita akan menyelesaikan masalah nyata dalam mengklasifikasikan gambar kucing dan anjing. Untuk alasan ini, kita akan menggunakan [Dataset Kucing vs. Anjing dari Kaggle](https://www.kaggle.com/c/dogs-vs-cats), yang juga bisa diunduh [dari Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n", "\n", "Mari kita unduh dataset ini dan ekstrak ke dalam direktori `data` (proses ini mungkin memakan waktu!):\n" ] @@ -64,7 +64,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Sayangnya, ada beberapa file gambar yang rusak dalam dataset. Kita perlu melakukan pembersihan cepat untuk memeriksa file yang rusak. Agar tidak mengganggu tutorial ini, kami memindahkan kode untuk memverifikasi dataset ke dalam sebuah modul.\n" + "Sayangnya, ada beberapa file gambar yang korup dalam dataset. Kita perlu melakukan pembersihan cepat untuk memeriksa file yang rusak. Agar tidak merusak tutorial ini, kami memindahkan kode untuk memverifikasi dataset ke dalam sebuah modul.\n" ] }, { @@ -335,11 +335,11 @@ "source": [ "## Memuat Dataset\n", "\n", - "Dalam contoh sebelumnya, kita memuat dataset yang sudah tersedia di Keras. Sekarang kita akan bekerja dengan dataset kita sendiri, yang perlu kita muat dari direktori gambar.\n", + "Pada contoh sebelumnya, kita memuat dataset yang sudah bawaan dari Keras. Sekarang kita akan menangani dataset kita sendiri, yang perlu kita muat dari direktori gambar.\n", "\n", - "Dalam kehidupan nyata, ukuran dataset gambar bisa sangat besar, dan kita tidak bisa mengandalkan semua data dapat dimuat ke dalam memori. Oleh karena itu, dataset sering kali direpresentasikan sebagai **generator** yang dapat mengembalikan data dalam minibatch yang sesuai untuk pelatihan.\n", + "Dalam kehidupan nyata, ukuran dataset gambar bisa sangat besar, dan tidak mungkin semua data muat di memori. Oleh karena itu, dataset sering diwakili sebagai **generator** yang dapat mengembalikan data dalam minibatch yang sesuai untuk pelatihan.\n", "\n", - "Untuk menangani klasifikasi gambar, Keras menyertakan fungsi khusus `image_dataset_from_directory`, yang dapat memuat gambar dari subdirektori yang sesuai dengan kelas yang berbeda. Fungsi ini juga mengurus penskalaan gambar, dan dapat membagi dataset menjadi subset pelatihan dan pengujian:\n" + "Untuk menangani klasifikasi gambar, Keras menyertakan fungsi khusus `image_dataset_from_directory`, yang dapat memuat gambar dari subdirektori yang sesuai dengan kelas yang berbeda. Fungsi ini juga mengurus penskalaan gambar, dan juga dapat membagi dataset menjadi subset train dan test:\n" ] }, { @@ -383,7 +383,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Penting untuk menetapkan nilai `seed` yang sama untuk kedua pemanggilan, karena ini memengaruhi pembagian gambar antara dataset pelatihan dan pengujian.\n", + "Penting untuk mengatur nilai `seed` yang sama untuk kedua panggilan, karena ini memengaruhi pembagian gambar antara dataset pelatihan dan pengujian.\n", "\n", "Dataset secara otomatis mengambil nama kelas dari direktori, dan Anda dapat mengaksesnya jika diperlukan dengan memanggil:\n" ] @@ -412,7 +412,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Dataset yang telah kami peroleh dapat langsung diteruskan ke fungsi `fit` untuk melatih model. Dataset tersebut berisi gambar dan label yang sesuai, yang dapat diulang menggunakan konstruksi berikut:\n" + "Dataset yang telah kami dapatkan dapat langsung diteruskan ke fungsi `fit` untuk melatih model. Dataset tersebut berisi baik gambar maupun label yang sesuai, yang dapat diulang menggunakan konstruksi berikut:\n" ] }, { @@ -453,16 +453,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "> **Catatan**: Semua gambar dalam dataset direpresentasikan sebagai tensor titik float dengan rentang 0-255. Sebelum meneruskannya ke jaringan saraf, kita perlu menskalakan nilai-nilai tersebut ke dalam rentang 0-1. Saat memplot gambar, kita juga perlu melakukan hal yang sama, atau mengonversi nilai ke tipe `int` (seperti yang kita lakukan dalam kode di atas), agar menunjukkan kepada `matplotlib` bahwa kita ingin memplot gambar asli yang belum diskalakan.\n" + "> **Catatan**: Semua gambar dalam dataset direpresentasikan sebagai tensor titik mengambang dengan rentang 0-255. Sebelum mengirimkannya ke jaringan syaraf, kita perlu mengubah skala nilai tersebut ke rentang 0-1. Saat memplot gambar, kita juga perlu melakukan hal yang sama, atau mengonversi nilai menjadi tipe `int` (yang kami lakukan dalam kode di atas), agar `matplotlib` menunjukkan bahwa kita ingin memplot gambar asli yang belum diskalakan.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Model yang telah dilatih sebelumnya\n", + "## Model Pra-latih\n", "\n", - "Untuk banyak tugas klasifikasi gambar, kita dapat menemukan model jaringan saraf yang telah dilatih sebelumnya. Banyak dari model tersebut tersedia di dalam namespace `keras.applications`, dan lebih banyak lagi model dapat ditemukan di Internet. Mari kita lihat bagaimana model VGG-16 yang paling sederhana dapat dimuat dan digunakan:\n" + "Untuk banyak tugas klasifikasi gambar, kita dapat menemukan model jaringan saraf yang sudah dilatih sebelumnya. Banyak dari model tersebut tersedia di dalam namespace `keras.applications`, dan lebih banyak lagi model dapat ditemukan di Internet. Mari kita lihat bagaimana model VGG-16 paling sederhana dapat dimuat dan digunakan:\n" ] }, { @@ -497,7 +497,17 @@ } ], "source": [ - "vgg = keras.applications.VGG16()\n", + "# SHA-256 of VGG16 weights (with top)\n", + "VGG16_WEIGHTS_SHA256 = '64373286793e3c8b2b4e3219cbf3544bce2f55ab4682710a29f5e7af8f5e4f61'\n", + "\n", + "_weights_path = keras.utils.get_file(\n", + " 'vgg16_weights_tf_dim_ordering_tf_kernels.h5',\n", + " 'https://storage.googleapis.com/tensorflow/keras-applications/vgg16/vgg16_weights_tf_dim_ordering_tf_kernels.h5',\n", + " file_hash=VGG16_WEIGHTS_SHA256,\n", + " hash_algorithm='sha256',\n", + ")\n", + "\n", + "vgg = keras.applications.VGG16(weights=_weights_path)\n", "inp = keras.applications.vgg16.preprocess_input(x_sample[:1])\n", "\n", "res = vgg(inp)\n", @@ -511,16 +521,16 @@ "metadata": {}, "source": [ "Ada beberapa hal penting di sini:\n", - "* Sebelum memberikan input ke jaringan yang sudah dilatih sebelumnya, input tersebut harus diproses terlebih dahulu dengan cara tertentu. Hal ini dilakukan dengan memanggil fungsi `preprocess_input` yang sesuai, yang menerima batch gambar dan mengembalikan bentuk yang telah diproses. Dalam kasus VGG-16, gambar-gambar tersebut dinormalisasi, dan nilai rata-rata yang telah ditentukan untuk setiap saluran dikurangi. Hal ini karena VGG-16 awalnya dilatih dengan pra-pemrosesan seperti ini.\n", - "* Jaringan neural diterapkan pada batch input, dan hasilnya adalah batch tensor berisi 1000 elemen yang menunjukkan probabilitas setiap kelas. Kita dapat menemukan nomor kelas yang paling mungkin dengan memanggil `argmax` pada tensor ini.\n", - "* Hasil yang diperoleh adalah [nomor kelas `ImageNet`](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). Untuk memahami hasil ini, kita juga dapat menggunakan fungsi `decode_predictions`, yang mengembalikan n kelas teratas beserta nama-namanya.\n" + "* Sebelum memasukkan input ke jaringan yang sudah dilatih sebelumnya, input harus diproses terlebih dahulu dengan cara tertentu. Ini dilakukan dengan memanggil fungsi `preprocess_input` yang sesuai, yang menerima batch gambar, dan mengembalikan bentuk yang sudah diproses. Dalam kasus VGG-16, gambar dinormalisasi, dan nilai rata-rata yang telah ditentukan untuk setiap saluran dikurangi. Ini karena VGG-16 awalnya dilatih dengan pra-pemrosesan ini.\n", + "* Jaringan saraf diterapkan pada batch input, dan kita menerima sebagai hasil tensor 1000-elemen untuk setiap batch yang menunjukkan probabilitas setiap kelas. Kita dapat menemukan nomor kelas yang paling mungkin dengan memanggil `argmax` pada tensor ini.\n", + "* Hasil yang diperoleh adalah [nomor kelas `ImageNet`](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). Untuk memahami hasil ini, kita juga dapat menggunakan fungsi `decode_predictions`, yang mengembalikan n kelas teratas bersama dengan nama mereka.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Mari kita lihat arsitektur jaringan VGG-16:\n" + "Mari kita lihat juga arsitektur jaringan VGG-16:\n" ] }, { @@ -597,9 +607,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Komputasi GPU\n", + "## Perhitungan GPU\n", "\n", - "Jaringan neural dalam, seperti VGG-16 dan arsitektur modern lainnya, membutuhkan daya komputasi yang cukup besar untuk dijalankan. Oleh karena itu, masuk akal untuk menggunakan akselerasi GPU jika tersedia. Untungnya, Keras secara otomatis mempercepat komputasi di GPU jika tersedia. Kita dapat memeriksa apakah Tensorflow dapat menggunakan GPU dengan kode berikut:\n" + "Jaringan neural dalam yang dalam, seperti VGG-16 dan arsitektur modern lainnya memerlukan kekuatan komputasi yang cukup besar untuk dijalankan. Sangat masuk akal untuk menggunakan akselerasi GPU, jika tersedia. Untungnya, Keras secara otomatis mempercepat perhitungan di GPU jika tersedia. Kita dapat memeriksa apakah Tensorflow dapat menggunakan GPU menggunakan kode berikut:\n" ] }, { @@ -626,9 +636,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Mengekstrak Fitur VGG\n", "\n", - "Jika kita ingin menggunakan VGG-16 untuk mengekstrak fitur dari gambar kita, kita memerlukan model tanpa lapisan klasifikasi akhir. Kita dapat menginstansiasi model VGG-16 tanpa lapisan atas menggunakan kode berikut:\n" + "## Mengekstrak fitur VGG\n", + "\n", + "Jika kita ingin menggunakan VGG-16 untuk mengekstrak fitur dari gambar kita, kita membutuhkan model tanpa lapisan klasifikasi akhir. Kita dapat membuat model VGG-16 tanpa lapisan atas menggunakan kode ini:\n" ] }, { @@ -680,9 +691,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Dimensi tensor fitur adalah 7x7x512, tetapi untuk memvisualisasikannya kita harus mengubahnya menjadi bentuk 2D.\n", + "Dimensi tensor fitur adalah 7x7x512, tetapi untuk memvisualisasikannya kami harus mengubahnya menjadi bentuk 2D.\n", "\n", - "Sekarang mari kita coba melihat apakah fitur-fitur tersebut dapat digunakan untuk mengklasifikasikan gambar. Mari kita ambil secara manual sebagian gambar (50 minibatch, dalam kasus ini), dan hitung terlebih dahulu vektor fitur mereka. Kita dapat menggunakan API **dataset** Tensorflow untuk melakukan itu. Fungsi `map` mengambil dataset dan menerapkan lambda-function tertentu untuk mengubahnya. Kita menggunakan mekanisme ini untuk membangun dataset baru, `ds_features_train` dan `ds_features_test`, yang berisi fitur yang diekstraksi oleh VGG sebagai pengganti gambar asli.\n" + "Sekarang mari kita coba lihat apakah fitur-fitur tersebut dapat digunakan untuk mengklasifikasikan gambar. Mari secara manual mengambil beberapa bagian dari gambar (50 minibatch, dalam kasus kami), dan menghitung vektor fiturnya terlebih dahulu. Kita dapat menggunakan API **dataset** Tensorflow untuk melakukan itu. Fungsi `map` mengambil sebuah dataset dan menerapkan fungsi lambda tertentu untuk mengubahnya. Kami menggunakan mekanisme ini untuk membuat dataset baru, `ds_features_train` dan `ds_features_test`, yang berisi fitur yang diekstrak oleh VGG, bukan gambar aslinya.\n" ] }, { @@ -712,9 +723,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Kami menggunakan konstruksi `.take(50)` untuk membatasi ukuran dataset, agar mempercepat demonstrasi kami. Tentu saja, Anda dapat melakukan eksperimen ini pada dataset penuh.\n", + "Kami menggunakan konstruk `.take(50)` untuk membatasi ukuran dataset, agar mempercepat demonstrasi kami. Tentu saja Anda dapat melakukan eksperimen ini pada dataset penuh.\n", "\n", - "Sekarang kita memiliki dataset dengan fitur yang telah diekstraksi, kita dapat melatih sebuah classifier sederhana berbasis dense untuk membedakan antara kucing dan anjing. Jaringan ini akan menerima vektor fitur dengan bentuk (7,7,512), dan menghasilkan satu output yang mewakili apakah itu anjing atau kucing. Karena ini adalah klasifikasi biner, kita menggunakan fungsi aktivasi `sigmoid` dan loss `binary_crossentropy`.\n" + "Sekarang kita memiliki dataset dengan fitur yang telah diekstrak, kita dapat melatih klasifikator dense sederhana untuk membedakan antara kucing dan anjing. Jaringan ini akan menerima vektor fitur berbentuk (7,7,512), dan menghasilkan satu output yang menunjukkan apakah itu anjing atau kucing. Karena ini adalah klasifikasi biner, kami menggunakan fungsi aktivasi `sigmoid` dan loss `binary_crossentropy`.\n" ] }, { @@ -743,13 +754,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Hasilnya luar biasa, kita dapat membedakan antara kucing dan anjing dengan probabilitas hampir 95%! Namun, kami hanya menguji pendekatan ini pada sebagian kecil dari semua gambar, karena ekstraksi fitur manual tampaknya memakan banyak waktu.\n", + "Hasilnya sangat baik, kita dapat membedakan antara kucing dan anjing dengan probabilitas hampir 95%! Namun, kita baru menguji pendekatan ini pada sebagian gambar saja, karena ekstraksi fitur secara manual tampaknya memerlukan banyak waktu.\n", "\n", "## Transfer learning menggunakan satu jaringan VGG\n", "\n", - "Kita juga dapat menghindari proses ekstraksi fitur secara manual dengan menggunakan jaringan VGG-16 asli secara keseluruhan selama pelatihan, dengan menambahkan ekstraktor fitur ke jaringan kita sebagai lapisan pertama.\n", + "Kita juga dapat menghindari perhitungan fitur secara manual dengan menggunakan jaringan VGG-16 asli secara keseluruhan selama pelatihan, dengan menambahkan ekstraktor fitur ke jaringan kita sebagai lapisan pertama.\n", "\n", - "Keindahan arsitektur Keras adalah bahwa model VGG-16 yang telah kita definisikan di atas juga dapat digunakan sebagai lapisan dalam jaringan neural lainnya! Kita hanya perlu membangun jaringan dengan classifier dense di atasnya, lalu melatih seluruh jaringan menggunakan back propagation.\n" + "Keindahan arsitektur Keras adalah model VGG-16 yang telah kita definisikan di atas juga dapat digunakan sebagai lapisan di jaringan neural lain! Kita hanya perlu membangun jaringan dengan pengklasifikasi dense di atasnya, lalu melatih seluruh jaringan menggunakan back propagation.\n" ] }, { @@ -793,13 +804,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Model ini terlihat seperti jaringan klasifikasi end-to-end, yang menerima sebuah gambar dan mengembalikan kelasnya. Namun, hal yang rumit adalah kita ingin VGG16 berfungsi sebagai ekstraktor fitur, bukan untuk dilatih ulang. Oleh karena itu, kita perlu **membekukan bobot ekstraktor fitur konvolusi**. Kita dapat mengakses lapisan pertama jaringan dengan memanggil `model.layers[0]`, dan kita hanya perlu mengatur properti `trainable` ke `False`.\n", + "Model ini terlihat seperti jaringan klasifikasi ujung-ke-ujung, yang menerima sebuah gambar dan mengembalikan kelasnya. Namun, hal yang tricky adalah kita ingin VGG16 berperan sebagai ekstraktor fitur, dan tidak dilatih ulang. Oleh karena itu, kita perlu **membekukan bobot ekstraktor fitur konvolusional**. Kita dapat mengakses lapisan pertama dari jaringan dengan memanggil `model.layers[0]`, dan kita hanya perlu mengatur properti `trainable` menjadi `False`.\n", "\n", - "> **Note**: Pembekuan bobot ekstraktor fitur diperlukan, karena jika tidak, lapisan klasifikasi yang belum terlatih dapat merusak bobot pra-latih asli dari ekstraktor konvolusi.\n", + "> **Catatan**: Pembekuan bobot ekstraktor fitur diperlukan, karena jika tidak, lapisan klasifikasi yang belum dilatih dapat merusak bobot pre-trained asli dari ekstraktor konvolusional.\n", "\n", - "Anda dapat melihat bahwa meskipun jumlah total parameter dalam jaringan kita sekitar 15 juta, kita hanya melatih 25 ribu parameter. Semua parameter lainnya dari filter konvolusi tingkat atas sudah pra-latih. Hal ini baik, karena kita dapat menyempurnakan jumlah parameter yang lebih kecil dengan jumlah contoh yang lebih sedikit.\n", + "Anda dapat melihat bahwa meskipun total jumlah parameter dalam jaringan kita sekitar 15 juta, kita hanya melatih 25 ribu parameter. Semua parameter lain dari filter konvolusional tingkat atas sudah dilatih sebelumnya. Itu bagus, karena kita dapat melakukan fine-tune pada jumlah parameter yang lebih kecil dengan jumlah contoh yang lebih sedikit.\n", "\n", - "Sekarang kita akan melatih jaringan kita dan melihat seberapa baik hasilnya. Harapkan waktu eksekusi yang cukup lama, dan jangan khawatir jika eksekusi tampak seperti berhenti untuk beberapa waktu.\n" + "Sekarang kita akan melatih jaringan kita dan melihat seberapa baik hasil yang bisa didapat. Harapkan waktu berjalan yang agak lama, dan jangan khawatir jika eksekusi tampak beku untuk beberapa waktu.\n" ] }, { @@ -824,11 +835,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Sepertinya kita telah mendapatkan classifier kucing vs. anjing yang cukup akurat!\n", + "Sepertinya kita telah memperoleh classifier kucing vs. anjing yang cukup akurat! \n", "\n", "## Menyimpan dan Memuat Model\n", "\n", - "Setelah kita melatih model, kita dapat menyimpan arsitektur model dan bobot yang telah dilatih ke dalam file untuk digunakan di masa depan:\n" + "Setelah kita melatih model, kita dapat menyimpan arsitektur model dan bobot terlatih ke dalam file untuk digunakan di masa depan:\n" ] }, { @@ -852,7 +863,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Kita kemudian dapat memuat model dari file kapan saja. Anda mungkin merasa ini berguna jika percobaan berikutnya merusak model - Anda tidak perlu memulai dari awal lagi.\n" + "Kita kemudian dapat memuat model dari file kapan saja. Anda mungkin menganggap ini berguna jika eksperimen berikutnya merusak model - Anda tidak perlu memulai dari awal lagi.\n" ] }, { @@ -868,15 +879,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Fine-tuning transfer learning\n", + "## Penyempurnaan transfer learning\n", "\n", - "Pada bagian sebelumnya, kita telah melatih lapisan klasifikasi terakhir untuk mengklasifikasikan gambar dalam dataset kita sendiri. Namun, kita belum melatih ulang feature extractor, dan model kita mengandalkan fitur yang telah dipelajari dari data ImageNet. Jika objek Anda secara visual berbeda dari gambar-gambar biasa di ImageNet, kombinasi fitur ini mungkin tidak bekerja dengan optimal. Oleh karena itu, masuk akal untuk mulai melatih lapisan-lapisan konvolusi juga.\n", + "Pada bagian sebelumnya, kita telah melatih lapisan pengklasifikasi terakhir untuk mengklasifikasikan gambar dalam dataset kita sendiri. Namun, kita tidak melatih ulang ekstraktor fitur, dan model kita mengandalkan fitur yang telah dipelajari model dari data ImageNet. Jika objek Anda secara visual berbeda dari gambar ImageNet biasa, kombinasi fitur ini mungkin tidak bekerja dengan baik. Oleh karena itu, masuk akal untuk mulai melatih juga lapisan konvolusi.\n", "\n", - "Untuk melakukannya, kita dapat membuka kembali parameter filter konvolusi yang sebelumnya telah kita bekukan.\n", + "Untuk melakukannya, kita dapat membuka kunci parameter filter konvolusional yang sebelumnya telah kita bekukan.\n", "\n", - "> **Note:** Penting untuk membekukan parameter terlebih dahulu dan melakukan beberapa epoch pelatihan untuk menstabilkan bobot pada lapisan klasifikasi. Jika Anda langsung memulai pelatihan jaringan end-to-end dengan parameter yang tidak dibekukan, kesalahan besar kemungkinan akan merusak bobot yang telah dilatih sebelumnya pada lapisan konvolusi.\n", + "> **Catatan:** Penting untuk membekukan parameter terlebih dahulu dan melakukan beberapa epoch pelatihan untuk menstabilkan bobot pada lapisan klasifikasi. Jika Anda langsung memulai pelatihan jaringan secara menyeluruh dengan parameter yang tidak dibekukan, kesalahan besar kemungkinan akan merusak bobot yang telah dilatih sebelumnya di lapisan konvolusi.\n", "\n", - "Model konvolusi VGG-16 kita berada di dalam lapisan pertama, dan terdiri dari banyak lapisan itu sendiri. Kita dapat melihat strukturnya:\n" + "Model VGG-16 konvolusional kita terletak di dalam lapisan pertama, dan terdiri dari banyak lapisan itu sendiri. Kita dapat melihat strukturnya:\n" ] }, { @@ -945,7 +956,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Kita dapat mencairkan semua lapisan dari basis konvolusional:\n" + "Kita dapat membuka kunci semua lapisan dari dasar konvolusi:\n" ] }, { @@ -961,7 +972,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Namun, membuka pembekuan semuanya sekaligus bukanlah ide terbaik. Kita dapat terlebih dahulu membuka pembekuan hanya beberapa lapisan akhir dari konvolusi, karena mereka mengandung pola tingkat tinggi yang relevan untuk gambar kita. Sebagai contoh, untuk memulai, kita dapat membekukan semua lapisan kecuali 4 lapisan terakhir:\n" + "Namun, mencairkan semuanya sekaligus bukanlah ide terbaik. Kita dapat terlebih dahulu mencairkan hanya beberapa lapisan akhir konvolusi, karena lapisan tersebut mengandung pola tingkat tinggi yang relevan untuk gambar kita. Misalnya, untuk memulai, kita dapat membekukan semua lapisan kecuali 4 lapisan terakhir: \n" ] }, { @@ -1000,11 +1011,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Perhatikan bahwa jumlah parameter yang dapat dilatih meningkat secara signifikan, tetapi masih sekitar 50% dari total parameter.\n", + "Perhatikan bahwa jumlah parameter yang dapat dilatih meningkat secara signifikan, tetapi masih sekitar 50% dari semua parameter.\n", "\n", - "Setelah membuka pembekuan, kita dapat melakukan beberapa epoch pelatihan tambahan (dalam contoh kita, kita hanya akan melakukan satu). Anda juga dapat memilih tingkat pembelajaran yang lebih rendah untuk meminimalkan dampak pada bobot yang telah dilatih sebelumnya. Namun, bahkan dengan tingkat pembelajaran yang rendah, Anda dapat mengharapkan akurasi menurun di awal pelatihan, hingga akhirnya mencapai tingkat yang sedikit lebih tinggi dibandingkan dengan kasus bobot yang tetap.\n", + "Setelah membebaskan (unfreezing), kita bisa melakukan beberapa epoch pelatihan lagi (dalam contoh kami, kami hanya akan melakukan satu). Anda juga bisa memilih tingkat pembelajaran yang lebih rendah, untuk meminimalkan dampak pada bobot yang telah dilatih sebelumnya. Namun, bahkan dengan tingkat pembelajaran yang rendah, Anda dapat mengharapkan akurasi menurun di awal pelatihan, hingga akhirnya mencapai tingkat sedikit lebih tinggi daripada pada kasus bobot tetap.\n", "\n", - "> **Note:** Pelatihan ini berlangsung jauh lebih lambat, karena kita perlu menyebarkan gradien kembali melalui banyak lapisan jaringan!\n" + "> **Catatan:** Pelatihan ini terjadi jauh lebih lambat, karena kita perlu mengpropagasi gradien kembali melalui banyak lapisan jaringan!\n" ] }, { @@ -1028,18 +1039,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Kami kemungkinan akan mencapai akurasi pelatihan yang lebih tinggi, karena kami menggunakan jaringan yang lebih kuat dengan lebih banyak parameter, tetapi akurasi validasi mungkin tidak meningkat sebanyak itu.\n", + "Kita kemungkinan akan mencapai akurasi pelatihan yang lebih tinggi, karena kita menggunakan jaringan yang lebih kuat dengan lebih banyak parameter, tetapi akurasi validasi tidak akan meningkat sebanyak itu.\n", "\n", - "Jangan ragu untuk membuka beberapa lapisan jaringan tambahan dan melatih lebih lanjut, untuk melihat apakah Anda dapat mencapai akurasi yang lebih tinggi!\n" + "Silakan buka beberapa lapisan jaringan lagi dan latih lebih lama, untuk melihat apakah Anda dapat mencapai akurasi yang lebih tinggi!\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Model penglihatan komputer lainnya\n", + "## Model visi komputer lainnya\n", "\n", - "VGG-16 adalah salah satu arsitektur penglihatan komputer yang paling sederhana. Keras menyediakan banyak jaringan yang telah dilatih sebelumnya. Di antara jaringan tersebut, yang paling sering digunakan adalah arsitektur **ResNet**, yang dikembangkan oleh Microsoft, dan **Inception** oleh Google. Sebagai contoh, mari kita eksplorasi arsitektur model ResNet-50 yang paling sederhana (ResNet adalah keluarga model dengan kedalaman berbeda, Anda dapat mencoba bereksperimen dengan ResNet-152 jika ingin melihat seperti apa model yang sangat dalam):\n" + "VGG-16 adalah salah satu arsitektur visi komputer yang paling sederhana. Keras menyediakan banyak jaringan yang sudah dilatih sebelumnya. Yang paling sering digunakan di antara itu adalah arsitektur **ResNet**, yang dikembangkan oleh Microsoft, dan **Inception** oleh Google. Sebagai contoh, mari kita jelajahi arsitektur model ResNet-50 yang paling sederhana (ResNet adalah keluarga model dengan kedalaman berbeda, Anda bisa mencoba bereksperimen dengan ResNet-152 jika ingin melihat seperti apa model yang benar-benar dalam): \n" ] }, { @@ -1441,29 +1452,29 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Seperti yang dapat Anda lihat, model ini mengandung blok bangunan yang sudah familiar: lapisan konvolusi, lapisan pooling, dan lapisan klasifikasi padat di akhir. Kita dapat menggunakan model ini dengan cara yang sama persis seperti kita menggunakan VGG-16 untuk transfer learning. Anda dapat mencoba bereksperimen dengan kode di atas, menggunakan berbagai model ResNet sebagai model dasar, dan melihat bagaimana akurasi berubah.\n", + "Seperti yang Anda lihat, model ini mengandung blok bangunan yang sama yang sudah dikenal: lapisan konvolusional, lapisan pooling, dan klasifier dense akhir. Kita dapat menggunakan model ini dengan cara yang persis sama seperti yang telah kita lakukan dengan VGG-16 untuk transfer learning. Anda dapat mencoba bereksperimen dengan kode di atas, menggunakan model ResNet yang berbeda sebagai model dasar, dan melihat bagaimana akurasi berubah.\n", "\n", "## Normalisasi Batch\n", "\n", - "Jaringan ini juga mengandung jenis lapisan lain: **Normalisasi Batch**. Ide dari normalisasi batch adalah untuk membawa nilai-nilai yang mengalir melalui jaringan neural ke interval yang tepat. Biasanya, jaringan neural bekerja paling baik ketika semua nilai berada dalam rentang [-1,1] atau [0,1], dan itulah alasan mengapa kita menskalakan/menormalkan data input kita sesuai. Namun, selama pelatihan jaringan yang dalam, bisa saja terjadi bahwa nilai-nilai menjadi sangat keluar dari rentang ini, yang membuat pelatihan menjadi bermasalah. Lapisan normalisasi batch menghitung rata-rata dan deviasi standar untuk semua nilai dari minibatch saat ini, dan menggunakannya untuk menormalkan sinyal sebelum meneruskannya melalui lapisan jaringan neural. Ini secara signifikan meningkatkan stabilitas jaringan yang dalam.\n" + "Jaringan ini mengandung jenis lapisan lain: **Normalisasi Batch**. Ide dari normalisasi batch adalah untuk membawa nilai-nilai yang mengalir melalui jaringan neural ke interval yang tepat. Biasanya jaringan neural bekerja paling baik ketika semua nilai berada dalam rentang [-1,1] atau [0,1], dan itulah alasan kita menskalakan/mem-normalisasi data input kita sesuai dengan itu. Namun, selama pelatihan jaringan yang dalam, dapat terjadi nilai-nilai keluar jauh dari rentang ini, yang menjadikan pelatihan bermasalah. Lapisan normalisasi batch menghitung rata-rata dan deviasi standar untuk semua nilai dari minibatch saat ini, dan menggunakannya untuk menormalisasi sinyal sebelum melewatinya melalui lapisan jaringan neural. Ini secara signifikan meningkatkan kestabilan jaringan yang dalam.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Intisari\n", + "## Kesimpulan\n", "\n", - "Dengan menggunakan transfer learning, kami dapat dengan cepat membuat sebuah classifier untuk tugas klasifikasi objek khusus kami, dan mencapai akurasi yang tinggi. Namun, contoh ini tidak sepenuhnya adil, karena jaringan VGG-16 asli telah dilatih sebelumnya untuk mengenali kucing dan anjing, sehingga kami hanya menggunakan kembali sebagian besar pola yang sudah ada di jaringan tersebut. Anda dapat mengharapkan akurasi yang lebih rendah pada objek yang lebih spesifik dan tidak umum, seperti detail pada jalur produksi di pabrik, atau berbagai jenis daun pohon.\n", + "Dengan menggunakan transfer learning, kami dapat dengan cepat menyusun pengklasifikasi untuk tugas klasifikasi objek khusus kami, dan mencapai akurasi yang tinggi. Namun, contoh ini tidak sepenuhnya adil, karena jaringan VGG-16 asli telah dilatih sebelumnya untuk mengenali kucing dan anjing, sehingga kami hanya menggunakan kembali sebagian besar pola yang sudah ada dalam jaringan tersebut. Anda dapat mengharapkan akurasi yang lebih rendah pada objek domain khusus yang lebih eksotik, seperti detail di jalur produksi di pabrik, atau daun pohon yang berbeda.\n", "\n", - "Anda dapat melihat bahwa tugas yang lebih kompleks yang sedang kami selesaikan sekarang membutuhkan daya komputasi yang lebih tinggi, dan tidak dapat dengan mudah diselesaikan menggunakan CPU. Pada unit berikutnya, kami akan mencoba menggunakan implementasi yang lebih ringan untuk melatih model yang sama dengan sumber daya komputasi yang lebih rendah, yang menghasilkan akurasi yang hanya sedikit lebih rendah.\n" + "Anda dapat melihat bahwa tugas yang lebih kompleks yang kami selesaikan sekarang membutuhkan daya komputasi yang lebih tinggi, dan tidak dapat dengan mudah diselesaikan pada CPU. Pada unit berikutnya, kami akan mencoba menggunakan implementasi yang lebih ringan untuk melatih model yang sama menggunakan sumber daya komputasi yang lebih rendah, yang menghasilkan akurasi yang hanya sedikit lebih rendah.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "\n---\n\n**Penafian**: \nDokumen ini telah diterjemahkan menggunakan layanan penerjemahan AI [Co-op Translator](https://github.com/Azure/co-op-translator). Meskipun kami berupaya untuk memberikan hasil yang akurat, harap diperhatikan bahwa terjemahan otomatis mungkin mengandung kesalahan atau ketidakakuratan. Dokumen asli dalam bahasa aslinya harus dianggap sebagai sumber yang berwenang. Untuk informasi yang bersifat kritis, disarankan menggunakan jasa penerjemahan manusia profesional. Kami tidak bertanggung jawab atas kesalahpahaman atau penafsiran yang keliru yang timbul dari penggunaan terjemahan ini.\n" + "---\n\n\n**Penafian**:\nDokumen ini telah diterjemahkan menggunakan layanan terjemahan AI [Co-op Translator](https://github.com/Azure/co-op-translator). Meskipun kami berupaya untuk mencapai akurasi, harap diketahui bahwa terjemahan otomatis mungkin mengandung kesalahan atau ketidakakuratan. Dokumen asli dalam bahasa aslinya harus dianggap sebagai sumber yang sah. Untuk informasi penting, disarankan menggunakan terjemahan profesional oleh manusia. Kami tidak bertanggung jawab atas kesalahpahaman atau penafsiran yang keliru yang timbul dari penggunaan terjemahan ini.\n\n" ] } ], @@ -1484,12 +1495,6 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.10" - }, - "coopTranslator": { - "original_hash": "c189abc107848f96051085cc30945129", - "translation_date": "2025-08-29T13:36:29+00:00", - "source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb", - "language_code": "id" } }, "nbformat": 4, diff --git a/translations/id/lessons/5-NLP/README.md b/translations/id/lessons/5-NLP/README.md index da537e75..198b2f0e 100644 --- a/translations/id/lessons/5-NLP/README.md +++ b/translations/id/lessons/5-NLP/README.md @@ -1,34 +1,34 @@ # Pemrosesan Bahasa Alami -![Ringkasan tugas NLP dalam bentuk doodle](../../../../translated_images/id/ai-nlp.b22dcb8ca4707cea.webp) +![Ringkasan tugas NLP dalam sebuah doodle](../../../../translated_images/id/ai-nlp.b22dcb8ca4707cea.webp) -Di bagian ini, kita akan fokus pada penggunaan Jaringan Saraf untuk menangani tugas-tugas yang berkaitan dengan **Pemrosesan Bahasa Alami (Natural Language Processing/NLP)**. Ada banyak masalah NLP yang ingin kita selesaikan dengan bantuan komputer: +Dalam bagian ini, kita akan fokus menggunakan Jaringan Saraf untuk menangani tugas-tugas terkait **Pemrosesan Bahasa Alami (NLP)**. Ada banyak masalah NLP yang ingin kita bisa selesaikan dengan komputer: -* **Klasifikasi teks** adalah masalah klasifikasi yang berkaitan dengan urutan teks. Contohnya termasuk mengklasifikasikan pesan e-mail sebagai spam atau bukan spam, atau mengategorikan artikel ke dalam kategori seperti olahraga, bisnis, politik, dll. Selain itu, saat mengembangkan chatbot, kita sering perlu memahami apa yang ingin disampaikan oleh pengguna -- dalam hal ini kita berurusan dengan **klasifikasi maksud**. Dalam klasifikasi maksud, sering kali kita harus menangani banyak kategori. -* **Analisis sentimen** adalah masalah regresi, di mana kita perlu memberikan nilai (sentimen) yang mencerminkan seberapa positif/negatif makna sebuah kalimat. Versi yang lebih canggih dari analisis sentimen adalah **analisis sentimen berbasis aspek** (Aspect-Based Sentiment Analysis/ABSA), di mana kita memberikan sentimen tidak untuk seluruh kalimat, tetapi untuk bagian-bagian tertentu (aspek), misalnya *Di restoran ini, saya suka masakannya, tetapi suasananya sangat buruk*. -* **Pengenalan Entitas Bernama** (Named Entity Recognition/NER) mengacu pada masalah mengekstraksi entitas tertentu dari teks. Sebagai contoh, kita mungkin perlu memahami bahwa dalam frasa *Saya perlu terbang ke Paris besok* kata *besok* merujuk pada TANGGAL, dan *Paris* adalah LOKASI. -* **Ekstraksi kata kunci** mirip dengan NER, tetapi kita perlu mengekstrak kata-kata yang penting untuk makna kalimat secara otomatis, tanpa pelatihan sebelumnya untuk jenis entitas tertentu. -* **Pengelompokan teks** dapat berguna ketika kita ingin mengelompokkan kalimat yang serupa, misalnya, permintaan serupa dalam percakapan dukungan teknis. -* **Menjawab pertanyaan** mengacu pada kemampuan model untuk menjawab pertanyaan tertentu. Model menerima teks dan pertanyaan sebagai input, dan perlu memberikan tempat dalam teks di mana jawaban atas pertanyaan tersebut terkandung (atau, terkadang, menghasilkan teks jawaban). -* **Pembuatan teks** adalah kemampuan model untuk menghasilkan teks baru. Ini dapat dianggap sebagai tugas klasifikasi yang memprediksi huruf/kata berikutnya berdasarkan *teks awal*. Model pembuatan teks yang canggih, seperti GPT-3, mampu menyelesaikan tugas NLP lainnya seperti klasifikasi menggunakan teknik yang disebut [prompt programming](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) atau [prompt engineering](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29). -* **Rangkuman teks** adalah teknik di mana kita ingin komputer "membaca" teks panjang dan meringkasnya dalam beberapa kalimat. -* **Penerjemahan mesin** dapat dilihat sebagai kombinasi pemahaman teks dalam satu bahasa, dan pembuatan teks dalam bahasa lain. +* **Klasifikasi teks** adalah masalah klasifikasi khas yang terkait dengan urutan teks. Contohnya termasuk mengklasifikasikan pesan email sebagai spam vs. tidak spam, atau mengkategorikan artikel sebagai olahraga, bisnis, politik, dll. Juga, saat mengembangkan bot obrolan, kita sering perlu memahami apa yang ingin dikatakan pengguna -- dalam kasus ini kita berurusan dengan **klasifikasi intent**. Seringkali, dalam klasifikasi intent kita perlu menangani banyak kategori. +* **Analisis sentimen** adalah masalah regresi khas, di mana kita perlu memberikan angka (sentimen) yang sesuai dengan seberapa positif/negatif makna suatu kalimat. Versi yang lebih maju dari analisis sentimen adalah **analisis sentimen berbasis aspek** (ABSA), di mana kita memberikan sentimen bukan untuk seluruh kalimat, tapi untuk bagian-bagian berbeda dari kalimat tersebut (aspek), misalnya *Di restoran ini, saya suka masakannya, tapi suasananya buruk*. +* **Pengenalan Entitas Bernama** (NER) merujuk pada masalah mengekstrak entitas tertentu dari teks. Misalnya, kita perlu memahami bahwa dalam frasa *Saya perlu terbang ke Paris besok* kata *besok* merujuk ke TANGGAL, dan *Paris* adalah LOKASI. +* **Ekstraksi kata kunci** mirip dengan NER, tapi kita perlu mengekstrak kata-kata penting untuk makna kalimat secara otomatis, tanpa pelatihan awal untuk jenis entitas tertentu. +* **Pengelompokan teks** dapat berguna ketika kita ingin mengelompokkan kalimat yang mirip, contohnya, permintaan serupa dalam percakapan dukungan teknis. +* **Menjawab pertanyaan** merujuk pada kemampuan model untuk menjawab pertanyaan spesifik. Model menerima teks dan pertanyaan sebagai masukan, dan perlu menyediakan bagian dalam teks di mana jawaban pertanyaan terdapat (atau, kadang-kadang, menghasilkan teks jawaban). +* **Generasi teks** adalah kemampuan model untuk menghasilkan teks baru. Ini dapat dianggap sebagai tugas klasifikasi yang memprediksi huruf/kata berikutnya berdasarkan *prompt teks*. Model generasi teks canggih, seperti GPT-3, mampu menyelesaikan tugas NLP lain seperti klasifikasi dengan teknik yang disebut [prompt programming](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) atau [prompt engineering](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29) +* **Ringkasan teks** adalah teknik dimana kita ingin komputer "membaca" teks panjang dan merangkumnya dalam beberapa kalimat. +* **Penerjemahan mesin** dapat dipandang sebagai kombinasi pemahaman teks dalam satu bahasa, dan menghasilkan teks dalam bahasa lain. -Awalnya, sebagian besar tugas NLP diselesaikan menggunakan metode tradisional seperti tata bahasa. Sebagai contoh, dalam penerjemahan mesin, parser digunakan untuk mengubah kalimat awal menjadi pohon sintaksis, kemudian struktur semantik tingkat tinggi diekstraksi untuk mewakili makna kalimat, dan berdasarkan makna ini serta tata bahasa dari bahasa target, hasilnya dihasilkan. Saat ini, banyak tugas NLP lebih efektif diselesaikan menggunakan jaringan saraf. +Awalnya, sebagian besar tugas NLP diselesaikan menggunakan metode tradisional seperti tata bahasa. Misalnya, dalam penerjemahan mesin, parser digunakan untuk mengubah kalimat awal menjadi pohon sintaksis, kemudian struktur semantik tingkat tinggi diekstrak untuk merepresentasikan makna kalimat, dan berdasarkan makna ini serta tata bahasa bahasa target hasilnya dihasilkan. Saat ini, banyak tugas NLP lebih efektif diselesaikan menggunakan jaringan saraf. -> Banyak metode NLP klasik diimplementasikan dalam pustaka Python [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org). Ada [Buku NLTK](https://www.nltk.org/book/) yang sangat bagus tersedia secara online yang membahas bagaimana berbagai tugas NLP dapat diselesaikan menggunakan NLTK. +> Banyak metode NLP klasik diimplementasikan dalam pustaka Python [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org). Ada buku [NLTK Book](https://www.nltk.org/book/) yang tersedia online yang membahas bagaimana berbagai tugas NLP dapat diselesaikan menggunakan NLTK. -Dalam kursus ini, kita akan lebih banyak fokus pada penggunaan Jaringan Saraf untuk NLP, dan kita akan menggunakan NLTK jika diperlukan. +Dalam kursus kami, kami akan lebih banyak fokus menggunakan Jaringan Saraf untuk NLP, dan kami akan menggunakan NLTK bila diperlukan. -Kita telah mempelajari penggunaan jaringan saraf untuk menangani data tabular dan gambar. Perbedaan utama antara jenis data tersebut dan teks adalah bahwa teks adalah urutan dengan panjang variabel, sementara ukuran input pada gambar sudah diketahui sebelumnya. Meskipun jaringan konvolusi dapat mengekstrak pola dari data input, pola dalam teks lebih kompleks. Misalnya, kita dapat memiliki negasi yang dipisahkan dari subjek oleh banyak kata (misalnya, *Saya tidak suka jeruk*, vs. *Saya tidak suka jeruk besar yang berwarna-warni dan lezat*), dan itu tetap harus diinterpretasikan sebagai satu pola. Oleh karena itu, untuk menangani bahasa, kita perlu memperkenalkan jenis jaringan saraf baru, seperti *jaringan berulang* (recurrent networks) dan *transformer*. +Kita telah belajar menggunakan jaringan saraf untuk menangani data tabular dan gambar. Perbedaan utama antara jenis data tersebut dan teks adalah bahwa teks adalah urutan dengan panjang variabel, sementara ukuran input untuk gambar diketahui sebelumnya. Meskipun jaringan konvolusional bisa mengekstrak pola dari data input, pola dalam teks lebih kompleks. Misalnya, kita dapat memiliki negasi yang terpisah dari subjek dengan jarak kata yang bervariasi (misalnya *Saya tidak suka jeruk*, vs. *Saya tidak suka jeruk besar berwarna cerah yang enak itu*), dan itu tetap harus diinterpretasikan sebagai satu pola. Oleh karena itu, untuk menangani bahasa kita perlu memperkenalkan jenis jaringan saraf baru, seperti *jaringan berulang* dan *transformer*. -## Instalasi Pustaka +## Instalasi Perpustakaan -Jika Anda menggunakan instalasi Python lokal untuk menjalankan kursus ini, Anda mungkin perlu menginstal semua pustaka yang diperlukan untuk NLP menggunakan perintah berikut: +Jika Anda menggunakan instalasi Python lokal untuk menjalankan kursus ini, Anda mungkin perlu menginstal semua perpustakaan yang dibutuhkan untuk NLP dengan perintah berikut: **Untuk PyTorch** ```bash -pip install -r requirements-torch.txt +pip install -r requirements-pytorch.txt ``` **Untuk TensorFlow** ```bash @@ -39,13 +39,13 @@ pip install -r requirements-tf.txt ## Peringatan GPU -Di bagian ini, dalam beberapa contoh kita akan melatih model yang cukup besar. -* **Gunakan Komputer dengan GPU**: Disarankan untuk menjalankan notebook Anda di komputer yang mendukung GPU untuk mengurangi waktu tunggu saat bekerja dengan model besar. -* **Keterbatasan Memori GPU**: Menjalankan di GPU dapat menyebabkan situasi di mana memori GPU habis, terutama saat melatih model besar. +Dalam bagian ini, di beberapa contoh kita akan melatih model yang cukup besar. +* **Gunakan Komputer dengan GPU**: Disarankan menjalankan notebook Anda pada komputer dengan GPU untuk mengurangi waktu tunggu saat bekerja dengan model besar. +* **Keterbatasan Memori GPU**: Menjalankan di GPU bisa menyebabkan kehabisan memori GPU, terutama saat melatih model besar. * **Konsumsi Memori GPU**: Jumlah memori GPU yang digunakan selama pelatihan tergantung pada berbagai faktor, termasuk ukuran minibatch. -* **Minimalkan Ukuran Minibatch**: Jika Anda mengalami masalah memori GPU, pertimbangkan untuk mengurangi ukuran minibatch dalam kode Anda sebagai solusi potensial. -* **Pelepasan Memori GPU TensorFlow**: Versi lama TensorFlow mungkin tidak melepaskan memori GPU dengan benar saat melatih beberapa model dalam satu kernel Python. Untuk mengelola penggunaan memori GPU secara efektif, Anda dapat mengonfigurasi TensorFlow untuk mengalokasikan memori GPU hanya saat diperlukan. -* **Penyertaan Kode**: Untuk mengatur TensorFlow agar hanya menambah alokasi memori GPU saat diperlukan, sertakan kode berikut dalam notebook Anda: +* **Perkecil Ukuran Minibatch**: Jika Anda mengalami masalah memori GPU, pertimbangkan mengurangi ukuran minibatch dalam kode Anda sebagai solusi potensial. +* **Pelepasan Memori GPU di TensorFlow**: Versi TensorFlow lama mungkin tidak melepaskan memori GPU dengan benar saat melatih banyak model dalam satu kernel Python. Untuk mengelola penggunaan memori GPU secara efektif, Anda dapat mengonfigurasi TensorFlow agar hanya mengalokasikan memori GPU sesuai kebutuhan. +* **Inklusi Kode**: Untuk mengatur TensorFlow agar hanya meningkatkan alokasi memori GPU saat diperlukan, sertakan kode berikut dalam notebook Anda: ```python physical_devices = tf.config.list_physical_devices('GPU') @@ -53,10 +53,10 @@ if len(physical_devices)>0: tf.config.experimental.set_memory_growth(physical_devices[0], True) ``` -Jika Anda tertarik mempelajari NLP dari perspektif pembelajaran mesin klasik, kunjungi [rangkaian pelajaran ini](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP) +Jika Anda tertarik belajar NLP dari perspektif ML klasik, kunjungi [rangkaian pelajaran ini](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP) ## Dalam Bagian Ini -Di bagian ini kita akan mempelajari: +Dalam bagian ini kita akan mempelajari tentang: * [Merepresentasikan teks sebagai tensor](13-TextRep/README.md) * [Word Embeddings](14-Emdeddings/README.md) @@ -67,5 +67,7 @@ Di bagian ini kita akan mempelajari: --- -**Penafian**: -Dokumen ini telah diterjemahkan menggunakan layanan penerjemahan AI [Co-op Translator](https://github.com/Azure/co-op-translator). Meskipun kami berusaha untuk memberikan hasil yang akurat, harap diingat bahwa terjemahan otomatis mungkin mengandung kesalahan atau ketidakakuratan. Dokumen asli dalam bahasa aslinya harus dianggap sebagai sumber yang otoritatif. Untuk informasi yang bersifat kritis, disarankan menggunakan jasa penerjemahan profesional oleh manusia. Kami tidak bertanggung jawab atas kesalahpahaman atau penafsiran yang keliru yang timbul dari penggunaan terjemahan ini. \ No newline at end of file + +**Penafian**: +Dokumen ini telah diterjemahkan menggunakan layanan terjemahan AI [Co-op Translator](https://github.com/Azure/co-op-translator). Meskipun kami berupaya untuk mencapai akurasi, harap diketahui bahwa terjemahan otomatis mungkin mengandung kesalahan atau ketidakakuratan. Dokumen asli dalam bahasa aslinya harus dianggap sebagai sumber yang sah. Untuk informasi penting, disarankan menggunakan terjemahan profesional oleh manusia. Kami tidak bertanggung jawab atas kesalahpahaman atau penafsiran yang keliru yang timbul dari penggunaan terjemahan ini. + \ No newline at end of file diff --git a/translations/vi/.co-op-translator.json b/translations/vi/.co-op-translator.json index edae8838..1ba7155b 100644 --- a/translations/vi/.co-op-translator.json +++ b/translations/vi/.co-op-translator.json @@ -5,6 +5,12 @@ "source_file": "AGENTS.md", "language_code": "vi" }, + "CONTRIBUTING.md": { + "original_hash": "c6fd7e781b67111a90abd166d0ce4aa0", + "translation_date": "2026-07-08T16:18:37+00:00", + "source_file": "CONTRIBUTING.md", + "language_code": "vi" + }, "README.md": { "original_hash": "12c8eb6bf0867d2f1c32daf613ac5b8b", "translation_date": "2026-04-06T20:26:37+00:00", @@ -17,6 +23,19 @@ "source_file": "SECURITY.md", "language_code": "vi" }, + "__translation_failures__": { + "lessons/sketchnotes/LICENSE.md": { + "original_hash": "45ab63a2cd8f5faef6c9b150618837a4", + "source_file": "lessons/sketchnotes/LICENSE.md", + "language_code": "vi", + "failure_date": "2026-07-08T16:13:31+00:00", + "status": "failed", + "error_type": "TranslationIncompleteError", + "error_message": "Markdown translation remained incomplete for chunk 1.1.1 of 'LICENSE.md', and the chunk could not be split further.", + "translator_version": "0.20.0", + "failure_policy_version": 1 + } + }, "etc/CODE_OF_CONDUCT.md": { "original_hash": "c06b12caf3c901eb3156e3dd5b0aea56", "translation_date": "2025-08-29T12:52:22+00:00", @@ -54,8 +73,8 @@ "language_code": "vi" }, "examples/README.md": { - "original_hash": "0d1babfdcbeb46525f2db3fbaaa54cd7", - "translation_date": "2025-10-03T11:32:24+00:00", + "original_hash": "7883d52c2e2a221e0b07a7b112a149b9", + "translation_date": "2026-07-08T16:07:59+00:00", "source_file": "examples/README.md", "language_code": "vi" }, @@ -66,8 +85,8 @@ "language_code": "vi" }, "lessons/0-course-setup/how-to-run.md": { - "original_hash": "a4717bd9103b9f6cd84d534b83534689", - "translation_date": "2026-01-16T03:40:24+00:00", + "original_hash": "7ad8c7d8604c53649b3d4d1e2f3a6fa1", + "translation_date": "2026-07-08T16:08:24+00:00", "source_file": "lessons/0-course-setup/how-to-run.md", "language_code": "vi" }, @@ -191,6 +210,12 @@ "source_file": "lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md", "language_code": "vi" }, + "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb": { + "original_hash": "99b816b6a4957ef4100cee4c4221dff9", + "translation_date": "2026-07-08T15:59:02+00:00", + "source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb", + "language_code": "vi" + }, "lessons/4-ComputerVision/08-TransferLearning/lab/README.md": { "original_hash": "7765935c35fcee69b9fe2d0cfd6963e2", "translation_date": "2025-08-29T12:22:30+00:00", @@ -330,8 +355,8 @@ "language_code": "vi" }, "lessons/5-NLP/README.md": { - "original_hash": "8ef02a9318257ea140ed3ed74442096d", - "translation_date": "2025-08-29T12:41:19+00:00", + "original_hash": "038df6f1a73e49f6430740da083bfd6d", + "translation_date": "2026-07-08T16:08:57+00:00", "source_file": "lessons/5-NLP/README.md", "language_code": "vi" }, diff --git a/translations/vi/CONTRIBUTING.md b/translations/vi/CONTRIBUTING.md new file mode 100644 index 00000000..a2c76c6c --- /dev/null +++ b/translations/vi/CONTRIBUTING.md @@ -0,0 +1,29 @@ +# Đóng góp cho AI-For-Beginners + +Cảm ơn bạn đã quan tâm đến việc đóng góp cho AI-For-Beginners! Chúng tôi hoan nghênh các bản dịch, sửa bài học, và chỉnh sửa định dạng. + +## Thỏa thuận Giấy phép Đóng góp viên của Microsoft (CLA) + +Dự án này hoan nghênh các đóng góp và đề xuất. Hầu hết các đóng góp đòi hỏi bạn phải đồng ý với Thỏa thuận Giấy phép Đóng góp viên (CLA) tuyên bố rằng bạn có quyền và thực sự cấp cho chúng tôi quyền sử dụng đóng góp của bạn. Chi tiết vui lòng xem tại [https://cla.microsoft.com](https://cla.microsoft.com). + +Khi bạn gửi yêu cầu kéo, một bot CLA sẽ tự động xác định xem bạn có cần cung cấp CLA hay không và trang trí PR phù hợp (ví dụ: nhãn, bình luận). Chỉ cần làm theo hướng dẫn do bot cung cấp. Bạn chỉ cần làm việc này một lần cho tất cả các kho lưu trữ sử dụng CLA của chúng tôi. + +## Cách Đóng góp + +### 1. Sửa lỗi chính tả / lỗi mã +Nếu bạn tìm thấy lỗi chính tả hoặc lỗi trong bất kỳ sổ tay Jupyter hoặc tập tin markdown bài học nào: +1. Fork kho lưu trữ. +2. Sửa lỗi chính tả hoặc liên kết hỏng. +3. Gửi Yêu cầu Kéo với mô tả rõ ràng về sửa chữa. + +### 2. Gửi Bản dịch +Chúng tôi hoan nghênh các bản dịch bài học sang các ngôn ngữ khác! Vui lòng đặt các bản dịch dưới thư mục `translations/` sử dụng các tên thư mục hiện có ở đó (ví dụ `translations/es/`, `translations/pt-BR/`, `translations/zh-CN/`). + +Để biết thêm chi tiết, xem [etc/CONTRIBUTING.md](etc/CONTRIBUTING.md). + +--- + + +**Tuyên bố miễn trừ trách nhiệm**: +Tài liệu này đã được dịch bằng dịch vụ dịch thuật AI [Co-op Translator](https://github.com/Azure/co-op-translator). Mặc dù chúng tôi cố gắng đảm bảo độ chính xác, xin lưu ý rằng bản dịch tự động có thể chứa lỗi hoặc sai sót. Tài liệu gốc bằng ngôn ngữ gốc nên được coi là nguồn tin chính thức. Đối với thông tin quan trọng, nên sử dụng dịch vụ dịch thuật chuyên nghiệp bởi con người. Chúng tôi không chịu trách nhiệm về bất kỳ hiểu lầm hoặc giải thích sai nào phát sinh từ việc sử dụng bản dịch này. + \ No newline at end of file diff --git a/translations/vi/examples/README.md b/translations/vi/examples/README.md index 61e5f2cd..4976dd1e 100644 --- a/translations/vi/examples/README.md +++ b/translations/vi/examples/README.md @@ -1,85 +1,87 @@ -# Các Ví dụ AI Dễ Hiểu +# Ví dụ AI thân thiện cho người mới bắt đầu -Chào mừng bạn! Thư mục này chứa các ví dụ đơn giản, độc lập để giúp bạn bắt đầu với AI và học máy. Mỗi ví dụ được thiết kế thân thiện với người mới bắt đầu, kèm theo các bình luận chi tiết và hướng dẫn từng bước. +Chào mừng! Thư mục này chứa các ví dụ đơn giản, độc lập để giúp bạn bắt đầu với AI và học máy. Mỗi ví dụ được thiết kế thân thiện với người mới bắt đầu với các chú thích chi tiết và giải thích từng bước. -## 📚 Tổng Quan Các Ví Dụ +## 📚 Tổng quan về các ví dụ -| Ví dụ | Mô tả | Mức độ khó | Yêu cầu trước | -|-------|-------|------------|---------------| -| [Hello AI World](../../../examples/01-hello-ai-world.py) | Chương trình AI đầu tiên của bạn - nhận diện mẫu đơn giản | ⭐ Dễ | Kiến thức cơ bản về Python | -| [Simple Neural Network](../../../examples/02-simple-neural-network.py) | Tạo một mạng nơ-ron từ đầu | ⭐⭐ Dễ+ | Python, toán học cơ bản | -| [Image Classifier](./03-image-classifier.ipynb) | Phân loại hình ảnh với mô hình đã được huấn luyện trước | ⭐⭐ Dễ+ | Python, numpy | -| [Text Sentiment](../../../examples/04-text-sentiment.py) | Phân tích cảm xúc văn bản (tích cực/tiêu cực) | ⭐⭐ Dễ+ | Python | +| Ví dụ | Mô tả | Độ khó | Yêu cầu trước | +|---------|-------------|------------|---------------| +| [Hello AI World](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/01-hello-ai-world.py) | Chương trình AI đầu tiên của bạn - nhận dạng mẫu đơn giản | ⭐ Người mới bắt đầu | Kiến thức cơ bản Python | +| [Simple Neural Network](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/02-simple-neural-network.py) | Xây dựng mạng nơ-ron từ đầu | ⭐⭐ Người mới bắt đầu+ | Python, toán cơ bản | +| [Image Classifier](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/03-image-classifier.ipynb) | Phân loại hình ảnh với mô hình đã được huấn luyện sẵn | ⭐⭐ Người mới bắt đầu+ | Python, numpy | +| [Text Sentiment](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/04-text-sentiment.py) | Phân tích cảm xúc văn bản (tích cực/tiêu cực) | ⭐⭐ Người mới bắt đầu+ | Python | -## 🚀 Bắt Đầu +## 🚀 Bắt đầu -### Yêu Cầu Trước +### Yêu cầu trước -Hãy đảm bảo bạn đã cài đặt Python (khuyến nghị phiên bản 3.8 hoặc cao hơn). Cài đặt các gói cần thiết: +Đảm bảo bạn đã cài đặt Python (khuyến nghị phiên bản 3.8 trở lên). Cài đặt các gói cần thiết: ```bash -# For Python scripts +# Cho các script Python pip install numpy -# For Jupyter notebooks (image classifier) +# Cho các notebook Jupyter (bộ phân loại hình ảnh) pip install jupyter numpy pillow tensorflow ``` -Hoặc sử dụng môi trường conda từ chương trình học chính: +Hoặc sử dụng môi trường conda từ chương trình chính: ```bash conda env create --name ai4beg --file ../environment.yml conda activate ai4beg ``` -### Chạy Các Ví Dụ +### Chạy các ví dụ -**Đối với các tập tin Python (.py):** +**Đối với các tập lệnh Python (.py):** ```bash python 01-hello-ai-world.py ``` -**Đối với các notebook Jupyter (.ipynb):** +**Đối với sổ tay Jupyter (.ipynb):** ```bash jupyter notebook 03-image-classifier.ipynb ``` -## 📖 Lộ Trình Học Tập +## 📖 Lộ trình học tập -Chúng tôi khuyến nghị bạn làm theo thứ tự các ví dụ: +Chúng tôi khuyên bạn nên làm theo thứ tự các ví dụ: -1. **Bắt đầu với "Hello AI World"** - Tìm hiểu cơ bản về nhận diện mẫu -2. **Xây dựng Mạng Nơ-ron Đơn Giản** - Hiểu cách hoạt động của mạng nơ-ron -3. **Thử Phân Loại Hình Ảnh** - Xem AI hoạt động với hình ảnh thực tế -4. **Phân Tích Cảm Xúc Văn Bản** - Khám phá xử lý ngôn ngữ tự nhiên +1. **Bắt đầu với "Hello AI World"** - Học cơ bản về nhận dạng mẫu +2. **Xây dựng Mạng Nơ-ron Đơn giản** - Hiểu cách mạng nơ-ron hoạt động +3. **Thử nghiệm Bộ phân loại hình ảnh** - Xem AI hoạt động với hình ảnh thực +4. **Phân tích cảm xúc văn bản** - Khám phá xử lý ngôn ngữ tự nhiên -## 💡 Mẹo Cho Người Mới Bắt Đầu +## 💡 Mẹo cho người mới bắt đầu -- **Đọc kỹ các bình luận trong mã** - Chúng giải thích từng dòng mã -- **Thử nghiệm!** - Thay đổi các giá trị và xem điều gì xảy ra -- **Đừng lo lắng nếu chưa hiểu hết** - Học tập cần thời gian -- **Đặt câu hỏi** - Sử dụng [Diễn đàn thảo luận](https://github.com/microsoft/AI-For-Beginners/discussions) +- **Đọc kỹ các chú thích trong mã** - Chúng giải thích mỗi dòng làm gì +- **Thử nghiệm!** - Thử thay đổi các giá trị và xem kết quả +- **Đừng lo lắng nếu không hiểu hết mọi thứ** - Học là cả một quá trình +- **Hỏi khi có thắc mắc** - Sử dụng [Bảng thảo luận](https://github.com/microsoft/AI-For-Beginners/discussions) -## 🔗 Bước Tiếp Theo +## 🔗 Bước tiếp theo -Sau khi hoàn thành các ví dụ này, hãy khám phá chương trình học đầy đủ: +Sau khi hoàn thành các ví dụ này, hãy khám phá toàn bộ chương trình: - [Giới thiệu về AI](../lessons/1-Intro/README.md) - [Mạng Nơ-ron](../lessons/3-NeuralNetworks/README.md) -- [Thị Giác Máy Tính](../lessons/4-ComputerVision/README.md) -- [Xử Lý Ngôn Ngữ Tự Nhiên](../lessons/5-NLP/README.md) +- [Thị giác máy tính](../lessons/4-ComputerVision/README.md) +- [Xử lý ngôn ngữ tự nhiên](../lessons/5-NLP/README.md) -## 🤝 Đóng Góp +## 🤝 Đóng góp -Thấy các ví dụ này hữu ích? Hãy giúp chúng tôi cải thiện: +Bạn thấy các ví dụ này hữu ích? Giúp chúng tôi cải thiện chúng: - Báo cáo lỗi hoặc đề xuất cải tiến -- Thêm nhiều ví dụ hơn cho người mới bắt đầu -- Cải thiện tài liệu và các bình luận +- Thêm nhiều ví dụ cho người mới bắt đầu +- Cải thiện tài liệu và chú thích --- -*Hãy nhớ: Mọi chuyên gia đều từng là người mới bắt đầu. Chúc bạn học tập vui vẻ! 🎓* +*Hãy nhớ: Mỗi chuyên gia đều từng là người mới bắt đầu. Chúc bạn học vui vẻ! 🎓* --- -**Tuyên bố miễn trừ trách nhiệm**: -Tài liệu này đã được dịch bằng dịch vụ dịch thuật AI [Co-op Translator](https://github.com/Azure/co-op-translator). Mặc dù chúng tôi cố gắng đảm bảo độ chính xác, xin lưu ý rằng các bản dịch tự động có thể chứa lỗi hoặc không chính xác. Tài liệu gốc bằng ngôn ngữ bản địa nên được coi là nguồn thông tin chính thức. Đối với các thông tin quan trọng, khuyến nghị sử dụng dịch vụ dịch thuật chuyên nghiệp bởi con người. Chúng tôi không chịu trách nhiệm cho bất kỳ sự hiểu lầm hoặc diễn giải sai nào phát sinh từ việc sử dụng bản dịch này. \ No newline at end of file + +**Tuyên bố miễn trừ trách nhiệm**: +Tài liệu này đã được dịch bằng dịch vụ dịch thuật AI [Co-op Translator](https://github.com/Azure/co-op-translator). Mặc dù chúng tôi cố gắng đảm bảo độ chính xác, xin lưu ý rằng bản dịch tự động có thể chứa lỗi hoặc sai sót. Tài liệu gốc bằng ngôn ngữ gốc nên được coi là nguồn tin chính thức. Đối với thông tin quan trọng, nên sử dụng dịch vụ dịch thuật chuyên nghiệp bởi con người. Chúng tôi không chịu trách nhiệm về bất kỳ hiểu lầm hoặc giải thích sai nào phát sinh từ việc sử dụng bản dịch này. + \ No newline at end of file diff --git a/translations/vi/lessons/0-course-setup/how-to-run.md b/translations/vi/lessons/0-course-setup/how-to-run.md index 881bdbf6..81a22109 100644 --- a/translations/vi/lessons/0-course-setup/how-to-run.md +++ b/translations/vi/lessons/0-course-setup/how-to-run.md @@ -1,12 +1,12 @@ -# Cách Chạy Mã Lệnh +# Cách Chạy Mã -Chương trình học này chứa nhiều ví dụ và bài thực hành có thể chạy được mà bạn sẽ muốn thử. Để làm điều này, bạn cần khả năng thực thi mã Python trong Jupyter Notebooks được cung cấp như một phần của chương trình học này. Bạn có một số lựa chọn để chạy mã: +Khóa học này bao gồm nhiều ví dụ và bài lab có thể thực thi mà bạn sẽ muốn chạy. Để làm được điều này, bạn cần khả năng thực thi mã Python trong các Jupyter Notebooks được cung cấp như một phần của khóa học này. Bạn có một số lựa chọn để chạy mã: -## Chạy trên máy tính cá nhân +## Chạy cục bộ trên máy tính của bạn -Để chạy mã trên máy tính cá nhân, bạn cần cài đặt Python. Một gợi ý là cài **[miniconda](https://conda.io/en/latest/miniconda.html)** - đây là một bản cài đặt nhẹ hỗ trợ trình quản lý gói `conda` cho các **môi trường ảo** Python khác nhau. +Để chạy mã cục bộ trên máy tính của bạn, cần phải cài đặt Python. Một khuyến nghị là cài đặt **[miniconda](https://conda.io/en/latest/miniconda.html)** - đây là một bản cài đặt nhẹ hỗ trợ trình quản lý gói `conda` cho các **môi trường ảo** Python khác nhau. -Sau khi cài miniconda, bạn clone kho và tạo môi trường ảo để dùng cho khóa học này: +Sau khi bạn cài đặt miniconda, sao chép repository và tạo một môi trường ảo để sử dụng cho khóa học này: ```bash git clone http://github.com/microsoft/ai-for-beginners @@ -15,57 +15,57 @@ conda env create --name ai4beg --file .devcontainer/environment.yml conda activate ai4beg ``` -### Sử dụng Visual Studio Code với Phần mở rộng Python +### Sử dụng Visual Studio Code với Extension Python -Chương trình học này sẽ sử dụng hiệu quả nhất khi mở trong [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) với [Phần mở rộng Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste). +Khóa học này hoạt động tốt nhất khi mở trong [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) với [Extension Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste). -> **Lưu ý**: Khi bạn clone và mở thư mục trong VS Code, nó sẽ tự động gợi ý bạn cài đặt phần mở rộng Python. Bạn cũng cần phải cài miniconda như mô tả ở trên. +> **Lưu ý**: Khi bạn sao chép và mở thư mục trong VS Code, nó sẽ tự động đề xuất bạn cài đặt mở rộng Python. Bạn cũng cần cài miniconda như mô tả ở trên. -> **Lưu ý**: Nếu VS Code gợi ý bạn mở lại kho trong container, bạn nên từ chối để sử dụng cài đặt Python cục bộ. +> **Lưu ý**: Nếu VS Code đề xuất bạn mở lại repository trong container, bạn nên từ chối để sử dụng cài đặt Python cục bộ. ### Sử dụng Jupyter trên trình duyệt -Bạn cũng có thể sử dụng môi trường Jupyter từ trình duyệt trên máy cá nhân. Cả Jupyter truyền thống và JupyterHub đều cung cấp môi trường phát triển tiện lợi với tự động hoàn thành, tô sáng mã, v.v. +Bạn cũng có thể sử dụng môi trường Jupyter trên trình duyệt ngay trên máy tính của mình. Cả Jupyter cổ điển và JupyterHub đều cung cấp môi trường phát triển tiện lợi với tính năng tự động hoàn thành, tô sáng mã, v.v. -Để khởi động Jupyter trên máy, hãy chuyển đến thư mục của khóa học, và chạy: +Để khởi động Jupyter cục bộ, hãy vào thư mục khóa học và thực thi: ```bash jupyter notebook ``` -hoặc + hoặc ```bash jupyterhub ``` -Bạn sau đó có thể mở bất kỳ tập tin `.ipynb` nào để bắt đầu làm việc. +Sau đó bạn có thể điều hướng đến bất kỳ tệp `.ipynb` nào, mở chúng và bắt đầu làm việc. ### Chạy trong container -Một lựa chọn thay thế cho việc cài đặt Python là chạy mã trong container. Vì kho của chúng tôi cung cấp thư mục `.devcontainer` đặc biệt hướng dẫn cách xây dựng container cho kho này, VS Code sẽ cung cấp tùy chọn mở lại mã trong container. Điều này yêu cầu cài Docker, và cũng phức tạp hơn, nên chúng tôi khuyến nghị cho người dùng có kinh nghiệm hơn. +Một lựa chọn thay thế cho việc cài đặt Python là chạy mã trong container. Vì repository của chúng tôi cung cấp một thư mục `.devcontainer` đặc biệt hướng dẫn cách xây dựng container cho repo này, VS Code cung cấp cơ hội mở lại mã trong container. Điều này yêu cầu cài đặt Docker và cũng phức tạp hơn, nên chúng tôi khuyến nghị cách này cho người dùng có kinh nghiệm hơn. -## Chạy trên điện toán đám mây +## Chạy trên đám mây -Nếu bạn không muốn cài Python trên máy và có quyền truy cập một số tài nguyên đám mây - lựa chọn tốt là chạy mã trên đám mây. Có một số cách bạn có thể làm điều này: +Nếu bạn không muốn cài đặt Python cục bộ và có quyền truy cập vào một số tài nguyên đám mây - một lựa chọn tốt là chạy mã trên đám mây. Có một số cách bạn có thể làm điều này: -* Sử dụng **[GitHub Codespaces](https://github.com/features/codespaces)**, một môi trường ảo được tạo trên GitHub cho bạn, truy cập qua giao diện trình duyệt VS Code. Nếu bạn có quyền truy cập Codespaces, bạn chỉ cần bấm nút **Code** trong repo, khởi tạo một codespace và bắt đầu ngay lập tức. -* Sử dụng **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) cung cấp tài nguyên tính toán miễn phí trên đám mây cho người dùng như bạn để thử mã trên GitHub. Có một nút ở trang đầu để mở kho trong Binder - điều này sẽ nhanh chóng đưa bạn đến trang Binder, nơi xây dựng một container bên dưới và khởi động giao diện web Jupyter cho bạn một cách liền mạch. +* Sử dụng **[GitHub Codespaces](https://github.com/features/codespaces)**, một môi trường ảo được tạo cho bạn trên GitHub, có thể truy cập qua giao diện trình duyệt VS Code. Nếu bạn có quyền truy cập vào Codespaces, bạn chỉ cần nhấn nút **Code** trong repo, bắt đầu một codespace và chạy ngay trong tích tắc. +* Sử dụng **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) cung cấp tài nguyên tính toán miễn phí trên đám mây cho bạn thử nghiệm mã trên GitHub. Có một nút ở trang chính để mở repository trong Binder - điều này sẽ nhanh chóng đưa bạn đến trang binder, nơi xây dựng một container nền và khởi động giao diện web Jupyter cho bạn một cách liền mạch. -> **Lưu ý**: Để ngăn ngừa sử dụng sai mục đích, Binder chặn truy cập một số tài nguyên web. Điều này có thể làm một số mã không hoạt động vì phải lấy mô hình và/hoặc bộ dữ liệu từ Internet công cộng. Bạn có thể cần tìm cách giải quyết. Ngoài ra, tài nguyên tính toán do Binder cung cấp khá cơ bản, nên việc huấn luyện sẽ chậm, đặc biệt trong các bài học phức tạp hơn sau này. +> **Lưu ý**: Để ngăn chặn việc sử dụng sai mục đích, Binder chặn truy cập một số tài nguyên web. Điều này có thể khiến một số đoạn mã không hoạt động, đặc biệt là những đoạn lấy mô hình và/hoặc bộ dữ liệu từ Internet công cộng. Bạn có thể cần tìm các giải pháp thay thế. Ngoài ra, tài nguyên tính toán do Binder cung cấp khá cơ bản, nên việc huấn luyện sẽ chậm, đặc biệt trong các bài học phức tạp hơn. ## Chạy trên đám mây với GPU -Một số bài học sau trong chương trình sẽ rất cần GPU. Việc huấn luyện mô hình, ví dụ, có thể rất chậm nếu không có GPU. Có vài tùy chọn bạn có thể theo, nhất là nếu bạn có quyền truy cập đám mây thông qua [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste), hoặc qua tổ chức của bạn: +Một số bài học sau trong khóa học này sẽ hưởng lợi rất nhiều từ việc hỗ trợ GPU. Việc huấn luyện mô hình, ví dụ, sẽ cực kỳ chậm nếu không có GPU. Có một vài lựa chọn bạn có thể theo, đặc biệt nếu bạn có quyền truy cập đám mây thông qua [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste), hoặc qua tổ chức của bạn: -* Tạo [Máy ảo Khoa học Dữ liệu](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) và kết nối đến nó qua Jupyter. Bạn có thể clone repo ngay lên máy và bắt đầu học. Máy ảo dòng NC có hỗ trợ GPU. +* Tạo [Máy ảo Khoa học Dữ liệu](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) và kết nối với nó qua Jupyter. Bạn có thể sao chép repository trực tiếp lên máy ảo và bắt đầu học. Máy ảo dòng NC hỗ trợ GPU. -> **Lưu ý**: Một số gói đăng ký, bao gồm Azure for Students, không cung cấp GPU mặc định. Bạn có thể cần gửi yêu cầu hỗ trợ kỹ thuật để nhận thêm lõi GPU. +> **Lưu ý**: Một số đăng ký, gồm Azure for Students, không hỗ trợ GPU ngay khi mới mở. Bạn có thể cần yêu cầu thêm lõi GPU thông qua yêu cầu hỗ trợ kỹ thuật. -* Tạo [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) và sử dụng tính năng Notebook ở đó. [Video này](https://azure-for-academics.github.io/quickstart/azureml-papers/) hướng dẫn cách clone repo vào notebook Azure ML và bắt đầu sử dụng. +* Tạo [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) và sử dụng tính năng Notebook tại đó. [Video này](https://azure-for-academics.github.io/quickstart/azureml-papers/) hướng dẫn cách sao chép repository vào notebook Azure ML và bắt đầu sử dụng. -Bạn cũng có thể sử dụng Google Colab, có hỗ trợ GPU miễn phí, và tải các Jupyter Notebooks lên đó để thực thi từng notebook một. +Bạn cũng có thể dùng Google Colab, nơi có hỗ trợ GPU miễn phí, và tải Jupyter Notebooks lên đó để thực thi từng cái một. --- -**Tuyên bố từ chối trách nhiệm**: -Tài liệu này đã được dịch bằng dịch vụ dịch thuật AI [Co-op Translator](https://github.com/Azure/co-op-translator). Mặc dù chúng tôi cố gắng đảm bảo độ chính xác, xin lưu ý rằng các bản dịch tự động có thể chứa lỗi hoặc không chính xác. Tài liệu gốc bằng ngôn ngữ gốc nên được xem là nguồn tham khảo chính thức. Đối với những thông tin quan trọng, nên sử dụng dịch vụ dịch thuật chuyên nghiệp do con người thực hiện. Chúng tôi không chịu trách nhiệm về bất kỳ sự hiểu lầm hay giải thích sai nào phát sinh từ việc sử dụng bản dịch này. +**Tuyên bố miễn trừ trách nhiệm**: +Tài liệu này đã được dịch bằng dịch vụ dịch thuật AI [Co-op Translator](https://github.com/Azure/co-op-translator). Mặc dù chúng tôi cố gắng đảm bảo độ chính xác, xin lưu ý rằng bản dịch tự động có thể chứa lỗi hoặc sai sót. Tài liệu gốc bằng ngôn ngữ gốc nên được coi là nguồn tin chính thức. Đối với thông tin quan trọng, nên sử dụng dịch vụ dịch thuật chuyên nghiệp bởi con người. Chúng tôi không chịu trách nhiệm về bất kỳ hiểu lầm hoặc giải thích sai nào phát sinh từ việc sử dụng bản dịch này. \ No newline at end of file diff --git a/translations/vi/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb b/translations/vi/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb index bca706a9..cf2afec5 100644 --- a/translations/vi/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb +++ b/translations/vi/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb @@ -4,11 +4,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Các mô hình đã được huấn luyện trước và học chuyển giao\n", + "# Mô hình tiền huấn luyện và học chuyển giao\n", "\n", - "Huấn luyện CNN có thể mất rất nhiều thời gian, và cần một lượng lớn dữ liệu cho nhiệm vụ này. Tuy nhiên, phần lớn thời gian được dành để học các bộ lọc cấp thấp tốt nhất mà mạng sử dụng để trích xuất các mẫu từ hình ảnh. Một câu hỏi tự nhiên được đặt ra - liệu chúng ta có thể sử dụng một mạng nơ-ron đã được huấn luyện trên một tập dữ liệu và điều chỉnh nó để phân loại các hình ảnh khác nhau mà không cần quá trình huấn luyện đầy đủ?\n", + "Việc huấn luyện CNN có thể mất nhiều thời gian và yêu cầu nhiều dữ liệu cho nhiệm vụ đó. Tuy nhiên, phần lớn thời gian được dành để học các bộ lọc cấp thấp tốt nhất mà mạng sử dụng để trích xuất các mẫu từ hình ảnh. Một câu hỏi tự nhiên đặt ra - liệu chúng ta có thể sử dụng một mạng nơ-ron đã được huấn luyện trên một bộ dữ liệu và điều chỉnh nó để phân loại các hình ảnh khác mà không cần quá trình huấn luyện đầy đủ?\n", "\n", - "Phương pháp này được gọi là **học chuyển giao**, bởi vì chúng ta chuyển một phần kiến thức từ một mô hình mạng nơ-ron sang một mô hình khác. Trong học chuyển giao, chúng ta thường bắt đầu với một mô hình đã được huấn luyện trước, mô hình này đã được huấn luyện trên một tập dữ liệu hình ảnh lớn, chẳng hạn như **ImageNet**. Những mô hình này đã có khả năng tốt trong việc trích xuất các đặc điểm khác nhau từ hình ảnh tổng quát, và trong nhiều trường hợp, chỉ cần xây dựng một bộ phân loại dựa trên những đặc điểm đã được trích xuất đó cũng có thể mang lại kết quả tốt.\n" + "Cách tiếp cận này được gọi là **học chuyển giao**, vì chúng ta chuyển giao một số kiến thức từ một mô hình mạng nơ-ron này sang một mô hình khác. Trong học chuyển giao, chúng ta thường bắt đầu với một mô hình tiền huấn luyện, vốn đã được huấn luyện trên một bộ dữ liệu hình ảnh lớn nào đó, như **ImageNet**. Những mô hình này đã có thể làm tốt việc trích xuất các đặc trưng khác nhau từ các hình ảnh tổng quát, và trong nhiều trường hợp chỉ cần xây dựng một bộ phân loại dựa trên các đặc trưng đã trích xuất đó có thể mang lại kết quả tốt.\n" ] }, { @@ -29,11 +29,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Bộ dữ liệu Cats vs. Dogs\n", + "## Bộ dữ liệu Mèo vs. Chó\n", "\n", - "Trong bài học này, chúng ta sẽ giải quyết một vấn đề thực tế về phân loại hình ảnh của mèo và chó. Vì lý do này, chúng ta sẽ sử dụng [Bộ dữ liệu Cats vs. Dogs trên Kaggle](https://www.kaggle.com/c/dogs-vs-cats), bộ dữ liệu này cũng có thể được tải xuống [từ Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n", + "Trong đơn vị này, chúng ta sẽ giải quyết một vấn đề thực tế về phân loại hình ảnh mèo và chó. Vì lý do này, chúng ta sẽ sử dụng [Bộ dữ liệu Mèo vs. Chó Kaggle](https://www.kaggle.com/c/dogs-vs-cats), cũng có thể được tải xuống [từ Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n", "\n", - "Hãy tải xuống bộ dữ liệu này và giải nén nó vào thư mục `data` (quá trình này có thể mất một chút thời gian!):\n" + "Hãy tải bộ dữ liệu này và giải nén vào thư mục `data` (quá trình này có thể mất một chút thời gian!):\n" ] }, { @@ -64,7 +64,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Thật không may, có một số tệp hình ảnh bị hỏng trong tập dữ liệu. Chúng ta cần thực hiện việc làm sạch nhanh để kiểm tra các tệp bị hỏng. Để không làm rối hướng dẫn này, chúng tôi đã chuyển mã kiểm tra tập dữ liệu vào một mô-đun.\n" + "Thật không may, có một số tệp hình ảnh bị hỏng trong bộ dữ liệu. Chúng ta cần làm sạch nhanh để kiểm tra các tệp bị hỏng. Để không làm hỏng hướng dẫn này, chúng tôi đã chuyển mã kiểm tra bộ dữ liệu sang một mô-đun.\n" ] }, { @@ -333,13 +333,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Tải Dữ Liệu\n", + "## Tải Bộ Dữ Liệu\n", "\n", - "Trong các ví dụ trước, chúng ta đã tải các tập dữ liệu được tích hợp sẵn trong Keras. Bây giờ, chúng ta sẽ làm việc với tập dữ liệu của riêng mình, cần được tải từ một thư mục chứa các hình ảnh.\n", + "Trong các ví dụ trước, chúng ta đã tải các bộ dữ liệu được tích hợp trong Keras. Bây giờ chúng ta sẽ làm việc với bộ dữ liệu của riêng mình, mà ta cần tải từ một thư mục chứa hình ảnh.\n", "\n", - "Trong thực tế, kích thước của các tập dữ liệu hình ảnh có thể khá lớn, và không thể dựa vào việc tất cả dữ liệu có thể được lưu trữ trong bộ nhớ. Do đó, các tập dữ liệu thường được biểu diễn dưới dạng **generators** có thể trả về dữ liệu theo từng minibatch phù hợp để huấn luyện.\n", + "Trong thực tế, kích thước của các bộ dữ liệu hình ảnh có thể rất lớn, và không thể đảm bảo tất cả dữ liệu đều vừa trong bộ nhớ. Do đó, các bộ dữ liệu thường được biểu diễn dưới dạng **bộ sinh** có thể trả về dữ liệu theo các lô nhỏ phù hợp để huấn luyện.\n", "\n", - "Để xử lý phân loại hình ảnh, Keras bao gồm một hàm đặc biệt `image_dataset_from_directory`, có thể tải hình ảnh từ các thư mục con tương ứng với các lớp khác nhau. Hàm này cũng tự động xử lý việc chuẩn hóa hình ảnh và có thể chia tập dữ liệu thành các tập con huấn luyện và kiểm tra:\n" + "Để xử lý phân loại hình ảnh, Keras bao gồm hàm đặc biệt `image_dataset_from_directory`, có khả năng tải hình ảnh từ các thư mục con tương ứng với các lớp khác nhau. Hàm này cũng đảm nhận việc chuẩn hóa kích thước ảnh, và còn có thể chia bộ dữ liệu thành các tập huấn luyện và kiểm tra:\n" ] }, { @@ -383,9 +383,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Điều quan trọng là phải đặt cùng một giá trị `seed` cho cả hai lần gọi, vì nó ảnh hưởng đến việc phân chia hình ảnh giữa tập dữ liệu huấn luyện và kiểm tra.\n", + "Việc đặt cùng giá trị `seed` cho cả hai lần gọi là quan trọng, vì nó ảnh hưởng đến sự phân chia hình ảnh giữa tập train và test.\n", "\n", - "Tập dữ liệu tự động lấy tên lớp từ các thư mục, và bạn có thể truy cập chúng nếu cần bằng cách gọi:\n" + "Dataset tự động lấy tên lớp từ các thư mục, và bạn có thể truy cập chúng nếu cần bằng cách gọi:\n" ] }, { @@ -412,7 +412,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Các tập dữ liệu mà chúng tôi đã thu thập có thể được truyền trực tiếp vào hàm `fit` để huấn luyện mô hình. Chúng chứa cả hình ảnh và nhãn tương ứng, có thể được lặp qua bằng cách sử dụng cấu trúc sau:\n" + "Các bộ dữ liệu mà chúng tôi đã thu thập có thể được truyền trực tiếp cho hàm `fit` để huấn luyện mô hình. Chúng bao gồm cả hình ảnh tương ứng và nhãn, có thể được duyệt qua bằng cách sử dụng cấu trúc sau:\n" ] }, { @@ -453,16 +453,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "> **Lưu ý**: Tất cả các hình ảnh trong tập dữ liệu được biểu diễn dưới dạng tensor điểm nổi với phạm vi 0-255. Trước khi đưa chúng vào mạng nơ-ron, chúng ta cần thu nhỏ các giá trị đó vào phạm vi 0-1. Khi vẽ hình ảnh, chúng ta cũng cần làm tương tự, hoặc chuyển đổi các giá trị sang kiểu `int` (như chúng ta đã làm trong đoạn mã trên), để hiển thị cho `matplotlib` rằng chúng ta muốn vẽ hình ảnh gốc chưa được thu nhỏ.\n" + "> **Lưu ý**: Tất cả các hình ảnh trong bộ dữ liệu được biểu diễn dưới dạng tensor số thực với phạm vi 0-255. Trước khi truyền chúng vào mạng nơ-ron, chúng ta cần chuyển đổi các giá trị này về phạm vi 0-1. Khi vẽ các hình ảnh, ta cần làm điều tương tự, hoặc chuyển giá trị sang kiểu `int` (như trong đoạn mã trên), để cho `matplotlib` biết rằng chúng ta muốn vẽ hình ảnh gốc chưa được chuẩn hóa.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Các mô hình đã được huấn luyện trước\n", + "## Mô hình đã được huấn luyện trước\n", "\n", - "Đối với nhiều tác vụ phân loại hình ảnh, bạn có thể tìm thấy các mô hình mạng nơ-ron đã được huấn luyện trước. Nhiều mô hình trong số đó có sẵn trong không gian tên `keras.applications`, và còn nhiều mô hình khác có thể được tìm thấy trên Internet. Hãy cùng xem cách tải và sử dụng mô hình VGG-16 đơn giản nhất:\n" + "Đối với nhiều tác vụ phân loại hình ảnh, người ta có thể tìm thấy các mô hình mạng nơ-ron đã được huấn luyện trước. Nhiều trong số các mô hình này có sẵn trong không gian tên `keras.applications`, và còn nhiều mô hình hơn nữa có thể được tìm thấy trên Internet. Hãy cùng xem cách tải và sử dụng mô hình VGG-16 đơn giản nhất:\n" ] }, { @@ -497,7 +497,17 @@ } ], "source": [ - "vgg = keras.applications.VGG16()\n", + "# SHA-256 of VGG16 weights (with top)\n", + "VGG16_WEIGHTS_SHA256 = '64373286793e3c8b2b4e3219cbf3544bce2f55ab4682710a29f5e7af8f5e4f61'\n", + "\n", + "_weights_path = keras.utils.get_file(\n", + " 'vgg16_weights_tf_dim_ordering_tf_kernels.h5',\n", + " 'https://storage.googleapis.com/tensorflow/keras-applications/vgg16/vgg16_weights_tf_dim_ordering_tf_kernels.h5',\n", + " file_hash=VGG16_WEIGHTS_SHA256,\n", + " hash_algorithm='sha256',\n", + ")\n", + "\n", + "vgg = keras.applications.VGG16(weights=_weights_path)\n", "inp = keras.applications.vgg16.preprocess_input(x_sample[:1])\n", "\n", "res = vgg(inp)\n", @@ -510,20 +520,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Có một vài điều quan trọng ở đây:\n", - "\n", - "* Trước khi đưa một đầu vào vào bất kỳ mạng nơ-ron đã được huấn luyện nào, nó cần được tiền xử lý theo một cách nhất định. Điều này được thực hiện bằng cách gọi hàm `preprocess_input` tương ứng, hàm này nhận một lô hình ảnh và trả về dạng đã được xử lý của chúng. Trong trường hợp của VGG-16, các hình ảnh được chuẩn hóa và một giá trị trung bình được định nghĩa trước cho mỗi kênh sẽ được trừ đi. Điều này là do VGG-16 ban đầu được huấn luyện với cách tiền xử lý này.\n", - "\n", - "* Mạng nơ-ron được áp dụng cho lô đầu vào, và kết quả chúng ta nhận được là một lô các tensor 1000 phần tử, thể hiện xác suất của mỗi lớp. Chúng ta có thể tìm số lớp có xác suất cao nhất bằng cách gọi `argmax` trên tensor này.\n", - "\n", - "* Kết quả thu được là [số của một lớp `ImageNet`](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). Để hiểu ý nghĩa của kết quả này, chúng ta cũng có thể sử dụng hàm `decode_predictions`, hàm này trả về n lớp hàng đầu cùng với tên của chúng.\n" + "Có vài điều quan trọng ở đây:\n", + "* Trước khi đưa đầu vào vào bất kỳ mạng đã được huấn luyện trước nào, nó cần được tiền xử lý theo một cách nhất định. Điều này được thực hiện bằng cách gọi hàm `preprocess_input` tương ứng, nhận một loạt các ảnh, và trả lại dạng đã được xử lý của chúng. Trong trường hợp VGG-16, các ảnh được chuẩn hóa, và một giá trị trung bình được định sẵn cho mỗi kênh được trừ đi. Điều đó là vì VGG-16 ban đầu được huấn luyện với việc tiền xử lý này.\n", + "* Mạng nơ-ron được áp dụng cho lô đầu vào, và chúng ta nhận được kết quả là một lô tensor 1000 phần tử biểu thị xác suất của mỗi lớp. Chúng ta có thể tìm số lớp có xác suất lớn nhất bằng cách gọi `argmax` trên tensor này.\n", + "* Kết quả thu được là [số của một lớp `ImageNet`](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). Để hiểu kết quả này, chúng ta cũng có thể sử dụng hàm `decode_predictions`, hàm này trả về n lớp hàng đầu cùng với tên của chúng.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Hãy cùng xem kiến trúc của mạng VGG-16:\n" + "Chúng ta cũng hãy xem kiến trúc của mạng VGG-16:\n" ] }, { @@ -602,7 +609,7 @@ "source": [ "## Tính toán GPU\n", "\n", - "Các mạng nơ-ron sâu, chẳng hạn như VGG-16 và các kiến trúc hiện đại hơn, yêu cầu khá nhiều sức mạnh tính toán để chạy. Việc sử dụng tăng tốc GPU là hợp lý nếu nó khả dụng. May mắn thay, Keras tự động tăng tốc các tính toán trên GPU nếu nó có sẵn. Chúng ta có thể kiểm tra xem Tensorflow có thể sử dụng GPU hay không bằng cách sử dụng đoạn mã sau:\n" + "Mạng nơ-ron sâu, như VGG-16 và các kiến trúc hiện đại khác, cần rất nhiều sức mạnh tính toán để chạy. Việc sử dụng tăng tốc GPU là hợp lý nếu có sẵn. May mắn thay, Keras tự động tăng tốc tính toán trên GPU nếu có sẵn. Chúng ta có thể kiểm tra xem Tensorflow có thể sử dụng GPU hay không bằng đoạn mã sau: \n" ] }, { @@ -629,9 +636,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "\n", "## Trích xuất đặc trưng từ VGG\n", "\n", - "Nếu chúng ta muốn sử dụng VGG-16 để trích xuất đặc trưng từ các hình ảnh, chúng ta cần mô hình không có các lớp phân loại cuối cùng. Chúng ta có thể khởi tạo mô hình VGG-16 mà không có các lớp trên cùng bằng đoạn mã sau:\n" + "Nếu chúng ta muốn sử dụng VGG-16 để trích xuất các đặc trưng từ hình ảnh của mình, chúng ta cần mô hình không có các lớp phân loại cuối cùng. Chúng ta có thể khởi tạo mô hình VGG-16 mà không có các lớp trên cùng bằng đoạn mã sau: \n" ] }, { @@ -683,9 +691,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Kích thước của tensor đặc trưng là 7x7x512, nhưng để trực quan hóa, chúng ta cần chuyển đổi nó sang dạng 2D.\n", + "Kích thước tensor đặc trưng là 7x7x512, nhưng để trực quan hóa nó, chúng tôi phải đổi dạng thành 2 chiều.\n", "\n", - "Bây giờ, hãy thử xem liệu những đặc trưng này có thể được sử dụng để phân loại hình ảnh hay không. Chúng ta sẽ tự tay lấy một phần hình ảnh (50 minibatch trong trường hợp này) và tính trước các vector đặc trưng của chúng. Chúng ta có thể sử dụng API **dataset** của Tensorflow để thực hiện điều này. Hàm `map` nhận một dataset và áp dụng một lambda-function được chỉ định để biến đổi nó. Chúng ta sử dụng cơ chế này để tạo ra các dataset mới, `ds_features_train` và `ds_features_test`, chứa các đặc trưng được trích xuất từ VGG thay vì hình ảnh gốc.\n" + "Bây giờ hãy thử xem liệu các đặc trưng đó có thể được sử dụng để phân loại hình ảnh không. Hãy tự tay lấy một phần hình ảnh (50 minibatches, trong trường hợp của chúng ta), và tính trước các vector đặc trưng của chúng. Chúng ta có thể sử dụng API **dataset** của Tensorflow để làm điều đó. Hàm `map` lấy một dataset và áp dụng một hàm lambda cho trước để biến đổi nó. Chúng tôi sử dụng cơ chế này để tạo các dataset mới, `ds_features_train` và `ds_features_test`, chứa các đặc trưng được trích xuất từ VGG thay vì các hình ảnh gốc.\n" ] }, { @@ -715,9 +723,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Chúng tôi đã sử dụng cấu trúc `.take(50)` để giới hạn kích thước tập dữ liệu, nhằm tăng tốc độ cho phần minh họa. Tất nhiên, bạn có thể thực hiện thí nghiệm này trên toàn bộ tập dữ liệu.\n", + "Chúng tôi đã sử dụng cú pháp `.take(50)` để giới hạn kích thước bộ dữ liệu, nhằm tăng tốc cho phần trình diễn của mình. Tất nhiên bạn có thể thực hiện thử nghiệm này trên bộ dữ liệu đầy đủ.\n", "\n", - "Bây giờ, khi chúng ta đã có một tập dữ liệu với các đặc trưng được trích xuất, chúng ta có thể huấn luyện một bộ phân loại dày đặc đơn giản để phân biệt giữa mèo và chó. Mạng này sẽ nhận một vector đặc trưng có dạng (7,7,512) và tạo ra một đầu ra tương ứng với chó hoặc mèo. Vì đây là bài toán phân loại nhị phân, chúng ta sử dụng hàm kích hoạt `sigmoid` và hàm mất mát `binary_crossentropy`.\n" + "Bây giờ chúng ta đã có bộ dữ liệu với các đặc trưng đã trích xuất, ta có thể huấn luyện một bộ phân loại dày đơn giản để phân biệt giữa mèo và chó. Mạng này sẽ nhận vector đặc trưng có dạng (7,7,512), và tạo ra một đầu ra tương ứng với chó hoặc mèo. Vì đây là bài toán phân loại nhị phân, ta sử dụng hàm kích hoạt `sigmoid` và hàm mất mát `binary_crossentropy`.\n" ] }, { @@ -746,13 +754,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Kết quả thật tuyệt vời, chúng ta có thể phân biệt giữa mèo và chó với xác suất gần 95%! Tuy nhiên, chúng ta chỉ mới thử nghiệm phương pháp này trên một phần nhỏ của tất cả các hình ảnh, vì việc trích xuất đặc trưng thủ công dường như mất rất nhiều thời gian.\n", + "Kết quả rất tuyệt, chúng ta có thể phân biệt giữa mèo và chó với xác suất gần 95%! Tuy nhiên, chúng tôi chỉ mới thử nghiệm phương pháp này trên một tập con của tất cả các hình ảnh, vì việc trích xuất đặc trưng thủ công có vẻ mất nhiều thời gian.\n", "\n", "## Học chuyển giao sử dụng một mạng VGG\n", "\n", - "Chúng ta cũng có thể tránh việc tính toán đặc trưng thủ công bằng cách sử dụng toàn bộ mạng VGG-16 gốc trong quá trình huấn luyện, bằng cách thêm bộ trích xuất đặc trưng vào mạng của chúng ta như một lớp đầu tiên.\n", + "Chúng ta cũng có thể tránh việc tính toán trước các đặc trưng thủ công bằng cách sử dụng toàn bộ mạng VGG-16 gốc trong quá trình huấn luyện, bằng cách thêm bộ trích xuất đặc trưng vào mạng của chúng ta như một lớp đầu tiên.\n", "\n", - "Điều tuyệt vời của kiến trúc Keras là mô hình VGG-16 mà chúng ta đã định nghĩa ở trên cũng có thể được sử dụng như một lớp trong một mạng nơ-ron khác! Chúng ta chỉ cần xây dựng một mạng với bộ phân loại dày đặc ở trên cùng, sau đó huấn luyện toàn bộ mạng bằng cách sử dụng lan truyền ngược.\n" + "Ưu điểm của kiến trúc Keras là mô hình VGG-16 mà chúng ta đã định nghĩa ở trên cũng có thể được sử dụng như một lớp trong một mạng nơ-ron khác! Chúng ta chỉ cần xây dựng một mạng với bộ phân loại dày đặc phía trên nó, rồi huấn luyện toàn bộ mạng bằng cách lan truyền ngược.\n" ] }, { @@ -796,13 +804,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Mô hình này trông giống như một mạng phân loại đầu-cuối, nhận một hình ảnh và trả về lớp tương ứng. Tuy nhiên, điều phức tạp ở đây là chúng ta muốn VGG16 hoạt động như một bộ trích xuất đặc trưng, chứ không phải để được huấn luyện lại. Do đó, chúng ta cần **đóng băng trọng số của bộ trích xuất đặc trưng tích chập**. Chúng ta có thể truy cập lớp đầu tiên của mạng bằng cách gọi `model.layers[0]`, và chỉ cần đặt thuộc tính `trainable` thành `False`.\n", + "Mô hình này trông giống như một mạng phân loại đầu-cuối, lấy một hình ảnh và trả về lớp. Tuy nhiên, điều khó là chúng ta muốn VGG16 hoạt động như một bộ trích xuất đặc trưng, và không được đào tạo lại. Do đó, chúng ta cần **đóng băng trọng số của bộ trích xuất đặc trưng tích chập**. Chúng ta có thể truy cập lớp đầu tiên của mạng bằng cách gọi `model.layers[0]`, và chỉ cần đặt thuộc tính `trainable` thành `False`.\n", "\n", - "> **Lưu ý**: Việc đóng băng trọng số của bộ trích xuất đặc trưng là cần thiết, bởi vì nếu không, lớp phân loại chưa được huấn luyện có thể làm hỏng các trọng số đã được huấn luyện trước của bộ trích xuất tích chập.\n", + "> **Lưu ý**: Việc đóng băng trọng số của bộ trích xuất đặc trưng là cần thiết, bởi vì nếu không lớp phân loại chưa được đào tạo có thể phá hủy trọng số đã được đào tạo trước của bộ trích xuất tích chập.\n", "\n", - "Bạn có thể nhận thấy rằng mặc dù tổng số tham số trong mạng của chúng ta vào khoảng 15 triệu, nhưng chúng ta chỉ huấn luyện 25 nghìn tham số. Tất cả các tham số khác của các bộ lọc tích chập cấp cao đã được huấn luyện trước. Điều này rất tốt, vì chúng ta có thể tinh chỉnh một số lượng nhỏ tham số với một số lượng nhỏ ví dụ.\n", + "Bạn có thể nhận thấy rằng trong khi tổng số tham số trong mạng của chúng ta khoảng 15 triệu, chúng ta chỉ đang đào tạo 25k tham số. Tất cả các tham số khác của bộ lọc tích chập cấp cao nhất đã được đào tạo trước. Điều đó là tốt, vì chúng ta có thể tinh chỉnh số lượng tham số nhỏ hơn với số lượng ví dụ nhỏ hơn.\n", "\n", - "Bây giờ chúng ta sẽ huấn luyện mạng và xem kết quả đạt được tốt đến mức nào. Hãy chuẩn bị cho thời gian chạy khá lâu, và đừng lo lắng nếu quá trình thực thi có vẻ như bị \"đóng băng\" trong một khoảng thời gian.\n" + "Bây giờ chúng ta sẽ đào tạo mạng và xem nó tốt đến mức nào. Hãy mong đợi thời gian chạy khá lâu, và đừng lo nếu quá trình thực thi có vẻ bị đứng trong một thời gian.\n" ] }, { @@ -827,11 +835,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Có vẻ như chúng ta đã có một bộ phân loại mèo và chó khá chính xác!\n", + "Có vẻ như chúng ta đã có được một bộ phân loại mèo và chó với độ chính xác khá tốt!\n", "\n", "## Lưu và Tải Mô Hình\n", "\n", - "Sau khi chúng ta đã huấn luyện mô hình, chúng ta có thể lưu kiến trúc mô hình và các trọng số đã được huấn luyện vào một tệp để sử dụng sau này:\n" + "Khi đã huấn luyện xong mô hình, chúng ta có thể lưu kiến trúc mô hình và trọng số đã được huấn luyện vào một tập tin để sử dụng sau này:\n" ] }, { @@ -855,7 +863,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Chúng ta có thể tải mô hình từ tệp bất kỳ lúc nào. Bạn có thể thấy điều này hữu ích trong trường hợp thí nghiệm tiếp theo làm hỏng mô hình - bạn sẽ không phải bắt đầu lại từ đầu.\n" + "Sau đó, chúng ta có thể tải mô hình từ tệp bất cứ lúc nào. Bạn có thể thấy điều này hữu ích trong trường hợp thí nghiệm tiếp theo làm hỏng mô hình - bạn sẽ không phải bắt đầu lại từ đầu.\n" ] }, { @@ -873,13 +881,13 @@ "source": [ "## Tinh chỉnh học chuyển giao\n", "\n", - "Trong phần trước, chúng ta đã huấn luyện lớp phân loại cuối cùng để phân loại hình ảnh trong tập dữ liệu của riêng mình. Tuy nhiên, chúng ta chưa huấn luyện lại bộ trích xuất đặc trưng, và mô hình của chúng ta dựa vào các đặc trưng mà mô hình đã học được từ dữ liệu ImageNet. Nếu các đối tượng của bạn có sự khác biệt về mặt hình ảnh so với các hình ảnh thông thường trong ImageNet, sự kết hợp các đặc trưng này có thể không hoạt động tốt nhất. Vì vậy, việc bắt đầu huấn luyện các lớp tích chập cũng là điều hợp lý.\n", + "Trong phần trước, chúng ta đã huấn luyện lớp phân loại cuối cùng để phân loại hình ảnh trong bộ dữ liệu của riêng mình. Tuy nhiên, chúng ta không huấn luyện lại bộ trích xuất đặc trưng, và mô hình của chúng ta dựa trên các đặc trưng mà mô hình đã học trên dữ liệu ImageNet. Nếu các đối tượng của bạn khác biệt về hình ảnh so với các hình ảnh thông thường của ImageNet, sự kết hợp các đặc trưng này có thể không hoạt động tốt nhất. Do đó, việc bắt đầu huấn luyện các lớp convolution cũng là hợp lý.\n", "\n", - "Để làm điều đó, chúng ta có thể mở khóa các tham số bộ lọc tích chập mà trước đó đã bị khóa.\n", + "Để làm điều đó, chúng ta có thể mở khóa các tham số bộ lọc convolution mà trước đó chúng ta đã đóng băng.\n", "\n", - "> **Note:** Điều quan trọng là bạn phải khóa các tham số trước và thực hiện vài epoch huấn luyện để ổn định trọng số trong lớp phân loại. Nếu bạn ngay lập tức bắt đầu huấn luyện mạng từ đầu với các tham số được mở khóa, các lỗi lớn có thể làm hỏng các trọng số đã được huấn luyện trước trong các lớp tích chập.\n", + "> **Lưu ý:** Điều quan trọng là bạn phải đóng băng các tham số trước và thực hiện một vài epoch huấn luyện để ổn định trọng số trong lớp phân loại. Nếu bạn ngay lập tức bắt đầu huấn luyện toàn bộ mạng với các tham số mở khóa, các lỗi lớn có thể phá hủy các trọng số đã được huấn luyện trước trong các lớp convolution.\n", "\n", - "Mô hình VGG-16 tích chập của chúng ta nằm trong lớp đầu tiên, và nó bao gồm nhiều lớp bên trong. Chúng ta có thể xem cấu trúc của nó:\n" + "Mô hình VGG-16 convolution của chúng ta nằm bên trong lớp đầu tiên, và nó bao gồm nhiều lớp con. Chúng ta có thể xem qua cấu trúc của nó:\n" ] }, { @@ -947,7 +955,9 @@ { "cell_type": "markdown", "metadata": {}, - "source": [] + "source": [ + "Chúng ta có thể mở khóa tất cả các lớp của cơ sở tích chập:\n" + ] }, { "cell_type": "code", @@ -962,7 +972,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Tuy nhiên, việc mở khóa tất cả chúng cùng một lúc không phải là ý tưởng tốt nhất. Chúng ta có thể bắt đầu bằng cách chỉ mở khóa một vài lớp cuối cùng của các lớp tích chập, vì chúng chứa các mẫu cấp cao hơn liên quan đến hình ảnh của chúng ta. Ví dụ, để bắt đầu, chúng ta có thể đóng băng tất cả các lớp ngoại trừ 4 lớp cuối cùng:\n" + "Tuy nhiên, bỏ đóng băng tất cả cùng lúc không phải là ý tưởng tốt nhất. Chúng ta có thể bắt đầu bằng cách chỉ bỏ đóng băng một vài lớp cuối cùng của các lớp tích chập, vì chúng chứa các mẫu ở cấp độ cao hơn liên quan đến hình ảnh của chúng ta. Ví dụ, để bắt đầu, chúng ta có thể giữ nguyên đóng băng tất cả các lớp ngoại trừ 4 lớp cuối cùng:\n" ] }, { @@ -1001,11 +1011,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Quan sát rằng số lượng tham số có thể huấn luyện đã tăng lên đáng kể, nhưng vẫn chỉ khoảng 50% tổng số tham số.\n", + "Quan sát thấy số lượng tham số có thể huấn luyện đã tăng đáng kể, nhưng vẫn chỉ khoảng 50% tổng số tham số.\n", "\n", - "Sau khi mở khóa, chúng ta có thể thực hiện thêm một vài epoch huấn luyện nữa (trong ví dụ này, chúng ta chỉ thực hiện một epoch). Bạn cũng có thể chọn tốc độ học thấp hơn để giảm thiểu ảnh hưởng lên các trọng số đã được huấn luyện trước. Tuy nhiên, ngay cả với tốc độ học thấp, bạn có thể mong đợi độ chính xác giảm xuống ở giai đoạn đầu của quá trình huấn luyện, cho đến khi cuối cùng đạt mức cao hơn một chút so với trường hợp giữ nguyên trọng số.\n", + "Sau khi mở khóa, chúng ta có thể thực hiện thêm vài epoch huấn luyện nữa (trong ví dụ của chúng tôi, chúng tôi sẽ chỉ làm một). Bạn cũng có thể chọn tỉ lệ học thấp hơn để giảm thiểu tác động lên các trọng số đã được huấn luyện trước. Tuy nhiên, ngay cả với tỉ lệ học thấp, bạn cũng có thể mong đợi độ chính xác giảm trong giai đoạn đầu của quá trình huấn luyện, cho đến khi cuối cùng đạt mức cao hơn một chút so với trường hợp trọng số cố định.\n", "\n", - "> **Note:** Quá trình huấn luyện này diễn ra chậm hơn nhiều, vì chúng ta cần truyền ngược gradient qua nhiều lớp của mạng!\n" + "> **Lưu ý:** Quá trình huấn luyện này diễn ra chậm hơn nhiều, vì chúng ta cần truyền ngược gradient qua nhiều lớp của mạng!\n" ] }, { @@ -1029,9 +1039,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Chúng ta có khả năng đạt được độ chính xác cao hơn trong quá trình huấn luyện, vì chúng ta đang sử dụng một mạng mạnh mẽ hơn với nhiều tham số hơn, nhưng độ chính xác khi kiểm định có thể không tăng nhiều như vậy.\n", + "Chúng ta có khả năng đạt được độ chính xác huấn luyện cao hơn, bởi vì chúng ta đang sử dụng mạng mạnh hơn với nhiều tham số hơn, nhưng độ chính xác xác thực sẽ không tăng nhiều như vậy.\n", "\n", - "Hãy thoải mái mở khóa thêm một vài lớp của mạng và huấn luyện thêm, để xem liệu bạn có thể đạt được độ chính xác cao hơn không!\n" + "Hãy thoải mái mở khóa thêm một vài lớp của mạng và huấn luyện thêm, để xem bạn có thể đạt được độ chính xác cao hơn không!\n" ] }, { @@ -1040,7 +1050,7 @@ "source": [ "## Các mô hình thị giác máy tính khác\n", "\n", - "VGG-16 là một trong những kiến trúc thị giác máy tính đơn giản nhất. Keras cung cấp nhiều mạng đã được huấn luyện trước khác. Những mạng được sử dụng phổ biến nhất trong số đó là các kiến trúc **ResNet**, được phát triển bởi Microsoft, và **Inception** của Google. Ví dụ, hãy cùng khám phá kiến trúc của mô hình ResNet-50 đơn giản nhất (ResNet là một họ các mô hình với độ sâu khác nhau, bạn có thể thử nghiệm với ResNet-152 nếu muốn xem một mô hình thực sự sâu trông như thế nào):\n" + "VGG-16 là một trong những kiến trúc thị giác máy tính đơn giản nhất. Keras cung cấp nhiều mạng đã được huấn luyện trước hơn nữa. Những kiến trúc được sử dụng thường xuyên nhất trong số đó là **ResNet**, được phát triển bởi Microsoft, và **Inception** của Google. Ví dụ, hãy cùng khám phá kiến trúc của mô hình ResNet-50 đơn giản nhất (ResNet là một họ các mô hình với độ sâu khác nhau, bạn có thể thử nghiệm với ResNet-152 nếu muốn xem một mô hình thực sự sâu trông như thế nào):\n" ] }, { @@ -1442,11 +1452,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Như bạn thấy, mô hình này chứa các thành phần quen thuộc: các lớp tích chập, các lớp pooling và lớp phân loại cuối cùng dạng dense. Chúng ta có thể sử dụng mô hình này theo cách tương tự như đã sử dụng VGG-16 cho học chuyển giao. Bạn có thể thử nghiệm với đoạn mã trên, sử dụng các mô hình ResNet khác nhau làm mô hình cơ sở, và xem độ chính xác thay đổi như thế nào.\n", + "Như bạn có thể thấy, mô hình chứa các khối xây dựng quen thuộc: các lớp convolution, lớp pooling và phân loại cuối cùng dày đặc. Chúng ta có thể sử dụng mô hình này hoàn toàn giống như cách chúng ta đã sử dụng VGG-16 cho học chuyển giao. Bạn có thể thử nghiệm với mã trên, sử dụng các mô hình ResNet khác nhau làm mô hình cơ sở, và xem độ chính xác thay đổi như thế nào.\n", "\n", - "## Batch Normalization\n", + "## Chuẩn hóa theo lô\n", "\n", - "Mạng này chứa một loại lớp khác: **Batch Normalization**. Ý tưởng của batch normalization là đưa các giá trị chảy qua mạng nơ-ron về khoảng phù hợp. Thông thường, mạng nơ-ron hoạt động tốt nhất khi tất cả các giá trị nằm trong khoảng [-1,1] hoặc [0,1], và đó là lý do chúng ta điều chỉnh/chuẩn hóa dữ liệu đầu vào tương ứng. Tuy nhiên, trong quá trình huấn luyện mạng sâu, có thể xảy ra trường hợp các giá trị vượt ra khỏi khoảng này một cách đáng kể, điều này làm cho việc huấn luyện trở nên khó khăn. Lớp batch normalization tính toán giá trị trung bình và độ lệch chuẩn cho tất cả các giá trị của minibatch hiện tại, và sử dụng chúng để chuẩn hóa tín hiệu trước khi truyền qua một lớp mạng nơ-ron. Điều này cải thiện đáng kể sự ổn định của các mạng sâu.\n" + "Mạng này chứa thêm một loại lớp nữa: **Chuẩn hóa theo lô (Batch Normalization)**. Ý tưởng của chuẩn hóa theo lô là đưa các giá trị truyền qua mạng nơ-ron về khoảng giá trị thích hợp. Thông thường, mạng nơ-ron hoạt động tốt nhất khi tất cả các giá trị nằm trong phạm vi [-1,1] hoặc [0,1], và đó là lý do chúng ta tỉ lệ hóa/chuẩn hóa dữ liệu đầu vào tương ứng. Tuy nhiên, trong quá trình huấn luyện mạng sâu, có thể xảy ra tình trạng giá trị vượt ra ngoài phạm vi này đáng kể, điều này làm cho việc huấn luyện gặp vấn đề. Lớp chuẩn hóa theo lô tính toán trung bình và độ lệch chuẩn cho tất cả các giá trị trong minibatch hiện tại và sử dụng chúng để chuẩn hóa tín hiệu trước khi truyền qua lớp mạng nơ-ron. Điều này cải thiện đáng kể độ ổn định của các mạng sâu.\n" ] }, { @@ -1455,16 +1465,16 @@ "source": [ "## Kết luận\n", "\n", - "Sử dụng học chuyển giao, chúng ta đã có thể nhanh chóng tạo ra một bộ phân loại cho nhiệm vụ phân loại đối tượng tùy chỉnh của mình và đạt được độ chính xác cao. Tuy nhiên, ví dụ này không hoàn toàn công bằng, vì mạng VGG-16 ban đầu đã được huấn luyện trước để nhận diện mèo và chó, do đó chúng ta chỉ tái sử dụng hầu hết các mẫu đã có sẵn trong mạng. Bạn có thể mong đợi độ chính xác thấp hơn đối với các đối tượng đặc thù thuộc lĩnh vực ít phổ biến hơn, chẳng hạn như chi tiết trên dây chuyền sản xuất trong nhà máy, hoặc các loại lá cây khác nhau.\n", + "Sử dụng học chuyển giao, chúng tôi có thể nhanh chóng xây dựng một bộ phân loại cho nhiệm vụ phân loại đối tượng tùy chỉnh của mình và đạt được độ chính xác cao. Tuy nhiên, ví dụ này không hoàn toàn công bằng, vì mạng VGG-16 ban đầu đã được huấn luyện trước để nhận diện mèo và chó, do đó chúng tôi chỉ tái sử dụng hầu hết các mẫu đã có trong mạng. Bạn có thể mong đợi độ chính xác thấp hơn với những đối tượng đặc thù hơn trong các lĩnh vực khác, chẳng hạn như chi tiết trên dây chuyền sản xuất trong nhà máy, hoặc các loại lá cây khác nhau.\n", "\n", - "Bạn có thể thấy rằng các nhiệm vụ phức tạp hơn mà chúng ta đang giải quyết hiện nay đòi hỏi sức mạnh tính toán cao hơn và không thể dễ dàng thực hiện trên CPU. Trong bài học tiếp theo, chúng ta sẽ thử sử dụng một cách triển khai nhẹ hơn để huấn luyện cùng một mô hình với tài nguyên tính toán thấp hơn, điều này chỉ dẫn đến độ chính xác giảm nhẹ.\n" + "Bạn có thể thấy rằng các nhiệm vụ phức tạp hơn mà chúng ta đang giải quyết hiện nay đòi hỏi công suất tính toán cao hơn, và không thể dễ dàng giải quyết trên CPU. Ở đơn vị tiếp theo, chúng ta sẽ cố gắng sử dụng triển khai nhẹ hơn để đào tạo cùng một mô hình sử dụng tài nguyên tính toán thấp hơn, điều này dẫn đến độ chính xác chỉ giảm nhẹ.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "\n---\n\n**Tuyên bố miễn trừ trách nhiệm**: \nTài liệu này đã được dịch bằng dịch vụ dịch thuật AI [Co-op Translator](https://github.com/Azure/co-op-translator). Mặc dù chúng tôi cố gắng đảm bảo độ chính xác, xin lưu ý rằng các bản dịch tự động có thể chứa lỗi hoặc không chính xác. Tài liệu gốc bằng ngôn ngữ bản địa nên được coi là nguồn tham khảo chính thức. Đối với các thông tin quan trọng, chúng tôi khuyến nghị sử dụng dịch vụ dịch thuật chuyên nghiệp từ con người. Chúng tôi không chịu trách nhiệm cho bất kỳ sự hiểu lầm hoặc diễn giải sai nào phát sinh từ việc sử dụng bản dịch này.\n" + "---\n\n\n**Tuyên bố miễn trừ trách nhiệm**:\nTài liệu này đã được dịch bằng dịch vụ dịch thuật AI [Co-op Translator](https://github.com/Azure/co-op-translator). Mặc dù chúng tôi cố gắng đảm bảo độ chính xác, xin lưu ý rằng bản dịch tự động có thể chứa lỗi hoặc sai sót. Tài liệu gốc bằng ngôn ngữ gốc nên được coi là nguồn tin chính thức. Đối với thông tin quan trọng, nên sử dụng dịch vụ dịch thuật chuyên nghiệp bởi con người. Chúng tôi không chịu trách nhiệm về bất kỳ hiểu lầm hoặc giải thích sai nào phát sinh từ việc sử dụng bản dịch này.\n\n" ] } ], @@ -1485,12 +1495,6 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.10" - }, - "coopTranslator": { - "original_hash": "c189abc107848f96051085cc30945129", - "translation_date": "2025-08-29T13:35:15+00:00", - "source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb", - "language_code": "vi" } }, "nbformat": 4, diff --git a/translations/vi/lessons/5-NLP/README.md b/translations/vi/lessons/5-NLP/README.md index 3d527d48..855a72fd 100644 --- a/translations/vi/lessons/5-NLP/README.md +++ b/translations/vi/lessons/5-NLP/README.md @@ -1,36 +1,36 @@ # Xử lý Ngôn ngữ Tự nhiên -![Tóm tắt các nhiệm vụ NLP trong một hình vẽ](../../../../translated_images/vi/ai-nlp.b22dcb8ca4707cea.webp) +![Tóm tắt các nhiệm vụ NLP bằng hình vẽ phác thảo](../../../../translated_images/vi/ai-nlp.b22dcb8ca4707cea.webp) -Trong phần này, chúng ta sẽ tập trung vào việc sử dụng Mạng Nơ-ron để xử lý các nhiệm vụ liên quan đến **Xử lý Ngôn ngữ Tự nhiên (NLP)**. Có rất nhiều vấn đề NLP mà chúng ta muốn máy tính có thể giải quyết: +Trong phần này, chúng ta sẽ tập trung vào việc sử dụng Mạng Nơ-ron để xử lý các nhiệm vụ liên quan đến **Xử lý Ngôn ngữ Tự nhiên (NLP)**. Có nhiều vấn đề NLP mà chúng ta muốn máy tính có thể giải quyết: -* **Phân loại văn bản** là một vấn đề phân loại điển hình liên quan đến các chuỗi văn bản. Ví dụ bao gồm phân loại email thành spam và không spam, hoặc phân loại bài viết thành các chủ đề như thể thao, kinh doanh, chính trị, v.v. Ngoài ra, khi phát triển chatbot, chúng ta thường cần hiểu người dùng muốn nói gì -- trong trường hợp này, chúng ta đang xử lý **phân loại ý định**. Thường thì, trong phân loại ý định, chúng ta cần xử lý nhiều danh mục khác nhau. -* **Phân tích cảm xúc** là một vấn đề hồi quy điển hình, nơi chúng ta cần gán một con số (cảm xúc) tương ứng với mức độ tích cực/tiêu cực của ý nghĩa câu. Một phiên bản nâng cao hơn của phân tích cảm xúc là **phân tích cảm xúc theo khía cạnh** (ABSA), nơi chúng ta gán cảm xúc không phải cho toàn bộ câu, mà cho các phần khác nhau của nó (các khía cạnh), ví dụ: *Ở nhà hàng này, tôi thích món ăn, nhưng không khí thì thật tệ*. -* **Nhận diện thực thể có tên** (NER) đề cập đến vấn đề trích xuất các thực thể nhất định từ văn bản. Ví dụ, chúng ta cần hiểu rằng trong câu *Tôi cần bay đến Paris vào ngày mai* từ *ngày mai* là DATE, và *Paris* là LOCATION. -* **Trích xuất từ khóa** tương tự như NER, nhưng chúng ta cần tự động trích xuất các từ quan trọng đối với ý nghĩa của câu mà không cần huấn luyện trước cho các loại thực thể cụ thể. -* **Phân cụm văn bản** có thể hữu ích khi chúng ta muốn nhóm các câu tương tự lại với nhau, ví dụ, các yêu cầu tương tự trong các cuộc trò chuyện hỗ trợ kỹ thuật. -* **Trả lời câu hỏi** đề cập đến khả năng của mô hình trả lời một câu hỏi cụ thể. Mô hình nhận một đoạn văn bản và một câu hỏi làm đầu vào, và nó cần cung cấp vị trí trong văn bản nơi chứa câu trả lời cho câu hỏi (hoặc đôi khi, tạo ra văn bản câu trả lời). -* **Tạo văn bản** là khả năng của mô hình tạo ra văn bản mới. Nó có thể được xem như một nhiệm vụ phân loại dự đoán chữ/từ tiếp theo dựa trên một *gợi ý văn bản*. Các mô hình tạo văn bản tiên tiến, như GPT-3, có thể giải quyết các nhiệm vụ NLP khác như phân loại bằng cách sử dụng kỹ thuật gọi là [lập trình gợi ý](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) hoặc [kỹ thuật gợi ý](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29). -* **Tóm tắt văn bản** là một kỹ thuật khi chúng ta muốn máy tính "đọc" văn bản dài và tóm tắt nó trong vài câu. -* **Dịch máy** có thể được xem như sự kết hợp giữa việc hiểu văn bản ở một ngôn ngữ và tạo văn bản ở ngôn ngữ khác. +* **Phân loại văn bản** là một bài toán phân loại điển hình liên quan đến các chuỗi văn bản. Ví dụ bao gồm phân loại email thành spam hoặc không spam, hoặc phân loại các bài viết thành thể thao, kinh doanh, chính trị, v.v. Ngoài ra, khi phát triển chatbot, chúng ta thường cần hiểu người dùng muốn nói gì — trong trường hợp này chúng ta xử lý **phân loại ý định**. Thường thì, trong phân loại ý định chúng ta cần xử lý nhiều loại khác nhau. +* **Phân tích đánh giá cảm xúc** là một bài toán hồi quy điển hình, trong đó chúng ta cần gán một số (một điểm cảm xúc) tương ứng với mức độ tích cực/tiêu cực của ý nghĩa câu. Phiên bản nâng cao hơn của phân tích cảm xúc là **phân tích cảm xúc dựa trên khía cạnh** (ABSA), trong đó chúng ta gán cảm xúc không phải cho toàn bộ câu mà cho các phần khác nhau của nó (các khía cạnh), ví dụ *Ở nhà hàng này, tôi thích ẩm thực, nhưng không khí lại tồi tệ*. +* **Nhận diện Thực thể Có tên** (NER) đề cập đến bài toán trích xuất các thực thể nhất định từ văn bản. Ví dụ, chúng ta có thể cần hiểu rằng trong câu *Tôi cần bay đến Paris vào ngày mai* thì từ *ngày mai* đề cập đến NGÀY THÁNG, và *Paris* là một ĐỊA ĐIỂM. +* **Trích xuất từ khóa** tương tự như NER, nhưng chúng ta cần trích xuất tự động các từ quan trọng với ý nghĩa của câu, không sử dụng đào tạo trước cho các loại thực thể cụ thể. +* **Phân cụm văn bản** có thể hữu ích khi chúng ta muốn nhóm các câu tương tự lại với nhau, ví dụ như các yêu cầu giống nhau trong cuộc trò chuyện hỗ trợ kỹ thuật. +* **Trả lời câu hỏi** đề cập đến khả năng của mô hình trả lời một câu hỏi cụ thể. Mô hình nhận đầu vào là đoạn văn bản và câu hỏi, và cần cung cấp vị trí trong văn bản chứa câu trả lời cho câu hỏi (hoặc, đôi khi, tạo ra văn bản câu trả lời). +* **Tạo văn bản** là khả năng của mô hình tạo ra văn bản mới. Nó có thể được coi là bài toán phân loại dự đoán ký tự/từ tiếp theo dựa trên một *đoạn kích thích văn bản*. Các mô hình tạo văn bản tiên tiến, như GPT-3, có thể giải các nhiệm vụ NLP khác như phân loại bằng kỹ thuật gọi là [lập trình kích thích](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) hoặc [kỹ thuật kích thích](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29) +* **Tóm tắt văn bản** là kỹ thuật khi bạn muốn máy tính "đọc" văn bản dài và tóm tắt nó trong vài câu. +* **Dịch máy** có thể được xem như sự kết hợp của việc hiểu văn bản trong một ngôn ngữ, và tạo văn bản trong một ngôn ngữ khác. -Ban đầu, hầu hết các nhiệm vụ NLP được giải quyết bằng các phương pháp truyền thống như ngữ pháp. Ví dụ, trong dịch máy, các bộ phân tích cú pháp được sử dụng để chuyển đổi câu ban đầu thành cây cú pháp, sau đó các cấu trúc ngữ nghĩa cấp cao hơn được trích xuất để đại diện cho ý nghĩa của câu, và dựa trên ý nghĩa này và ngữ pháp của ngôn ngữ đích, kết quả được tạo ra. Ngày nay, nhiều nhiệm vụ NLP được giải quyết hiệu quả hơn bằng cách sử dụng mạng nơ-ron. +Ban đầu, hầu hết các nhiệm vụ NLP được giải quyết bằng các phương pháp truyền thống như ngữ pháp. Ví dụ, trong dịch máy người ta dùng bộ phân tích cú pháp để chuyển câu ban đầu thành cây cú pháp, rồi trích xuất các cấu trúc ngữ nghĩa cấp cao hơn để biểu diễn ý nghĩa câu, và dựa trên ý nghĩa này và ngữ pháp ngôn ngữ đích kết quả được tạo ra. Ngày nay, nhiều nhiệm vụ NLP được giải quyết hiệu quả hơn bằng cách sử dụng mạng nơ-ron. -> Nhiều phương pháp NLP cổ điển được triển khai trong thư viện Python [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org). Có một [Sách NLTK](https://www.nltk.org/book/) tuyệt vời có sẵn trực tuyến, cung cấp cách giải quyết các nhiệm vụ NLP khác nhau bằng NLTK. +> Nhiều phương pháp NLP cổ điển được cài đặt trong thư viện Python [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org). Có một cuốn [Sách NLTK](https://www.nltk.org/book/) tuyệt vời trực tuyến hướng dẫn cách giải quyết các nhiệm vụ NLP khác nhau bằng NLTK. -Trong khóa học của chúng ta, chúng ta sẽ chủ yếu tập trung vào việc sử dụng Mạng Nơ-ron cho NLP, và sẽ sử dụng NLTK khi cần thiết. +Trong khóa học này, chúng ta sẽ chủ yếu tập trung vào việc sử dụng Mạng Nơ-ron cho NLP, và sử dụng NLTK khi cần. -Chúng ta đã học về việc sử dụng mạng nơ-ron để xử lý dữ liệu dạng bảng và hình ảnh. Sự khác biệt chính giữa các loại dữ liệu đó và văn bản là văn bản là một chuỗi có độ dài thay đổi, trong khi kích thước đầu vào trong trường hợp hình ảnh được biết trước. Mặc dù mạng tích chập có thể trích xuất các mẫu từ dữ liệu đầu vào, các mẫu trong văn bản phức tạp hơn. Ví dụ, chúng ta có thể có sự phủ định được tách khỏi chủ ngữ bởi nhiều từ (ví dụ: *Tôi không thích cam*, so với *Tôi không thích những quả cam lớn, đầy màu sắc, ngon*), và điều đó vẫn cần được hiểu là một mẫu. Do đó, để xử lý ngôn ngữ, chúng ta cần giới thiệu các loại mạng nơ-ron mới, như *mạng hồi quy* và *transformers*. +Chúng ta đã học về việc sử dụng mạng nơ-ron để xử lý dữ liệu bảng và hình ảnh. Sự khác biệt chính giữa các loại dữ liệu đó và văn bản là văn bản là một chuỗi có độ dài thay đổi, trong khi kích thước đầu vào trong trường hợp hình ảnh đã biết trước. Trong khi mạng tích chập có thể trích xuất mẫu từ dữ liệu đầu vào, các mẫu trong văn bản phức tạp hơn. Ví dụ, chúng ta có thể có sự phủ định tách rời ra khỏi chủ ngữ với khoảng cách bất kỳ bao nhiêu từ (ví dụ *Tôi không thích cam*, vs. *Tôi không thích những quả cam to nhiều màu sắc và ngon*), và điều đó vẫn phải được hiểu là một mẫu duy nhất. Do đó, để xử lý ngôn ngữ chúng ta cần giới thiệu các loại mạng nơ-ron mới, như *mạng hồi tiếp* và *transformers*. ## Cài đặt Thư viện -Nếu bạn đang sử dụng cài đặt Python cục bộ để chạy khóa học này, bạn có thể cần cài đặt tất cả các thư viện cần thiết cho NLP bằng các lệnh sau: +Nếu bạn sử dụng cài đặt Python cục bộ để chạy khóa học này, bạn có thể cần cài đặt tất cả các thư viện cần thiết cho NLP bằng các lệnh sau: -**Đối với PyTorch** +**Dành cho PyTorch** ```bash -pip install -r requirements-torch.txt +pip install -r requirements-pytorch.txt ``` -**Đối với TensorFlow** +**Dành cho TensorFlow** ```bash pip install -r requirements-tf.txt ``` @@ -39,13 +39,13 @@ pip install -r requirements-tf.txt ## Cảnh báo GPU -Trong phần này, trong một số ví dụ, chúng ta sẽ huấn luyện các mô hình khá lớn. -* **Sử dụng Máy tính Có GPU**: Nên chạy các notebook của bạn trên một máy tính có GPU để giảm thời gian chờ khi làm việc với các mô hình lớn. -* **Hạn chế Bộ nhớ GPU**: Chạy trên GPU có thể dẫn đến tình trạng hết bộ nhớ GPU, đặc biệt khi huấn luyện các mô hình lớn. -* **Tiêu thụ Bộ nhớ GPU**: Lượng bộ nhớ GPU tiêu thụ trong quá trình huấn luyện phụ thuộc vào nhiều yếu tố, bao gồm kích thước minibatch. -* **Giảm Kích thước Minibatch**: Nếu bạn gặp vấn đề về bộ nhớ GPU, hãy cân nhắc giảm kích thước minibatch trong mã của bạn như một giải pháp tiềm năng. -* **Giải phóng Bộ nhớ GPU của TensorFlow**: Các phiên bản cũ của TensorFlow có thể không giải phóng bộ nhớ GPU đúng cách khi huấn luyện nhiều mô hình trong một kernel Python. Để quản lý việc sử dụng bộ nhớ GPU hiệu quả, bạn có thể cấu hình TensorFlow để chỉ phân bổ bộ nhớ GPU khi cần thiết. -* **Bao gồm Mã**: Để thiết lập TensorFlow chỉ phân bổ bộ nhớ GPU khi cần, hãy thêm mã sau vào các notebook của bạn: +Trong phần này, trong một số ví dụ chúng ta sẽ huấn luyện các mô hình khá lớn. +* **Sử dụng máy tính có GPU**: Nên chạy notebook của bạn trên máy tính có GPU để giảm thời gian chờ khi làm việc với các mô hình lớn. +* **Hạn chế bộ nhớ GPU**: Chạy trên GPU có thể dẫn đến tình trạng hết bộ nhớ GPU, đặc biệt khi huấn luyện các mô hình lớn. +* **Tiêu thụ bộ nhớ GPU**: Lượng bộ nhớ GPU sử dụng trong quá trình huấn luyện phụ thuộc vào nhiều yếu tố, bao gồm kích thước minibatch. +* **Giảm kích thước Minibatch**: Nếu gặp vấn đề về bộ nhớ GPU, hãy cân nhắc giảm kích thước minibatch trong code của bạn như một giải pháp tiềm năng. +* **Giải phóng bộ nhớ GPU của TensorFlow**: Các phiên bản TensorFlow cũ có thể không giải phóng bộ nhớ GPU đúng cách khi huấn luyện nhiều mô hình trong một kernel Python. Để quản lý hiệu quả bộ nhớ GPU, bạn có thể cấu hình TensorFlow để cấp phát bộ nhớ GPU chỉ khi cần. +* **Bao gồm mã code**: Để đặt TensorFlow chỉ tăng bộ nhớ GPU khi cần, hãy bao gồm đoạn mã sau trong notebook của bạn: ```python physical_devices = tf.config.list_physical_devices('GPU') @@ -53,19 +53,21 @@ if len(physical_devices)>0: tf.config.experimental.set_memory_growth(physical_devices[0], True) ``` -Nếu bạn quan tâm đến việc học về NLP từ góc độ ML cổ điển, hãy truy cập [bộ bài học này](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP). +Nếu bạn quan tâm đến việc học NLP từ góc nhìn ML cổ điển, hãy truy cập [bộ bài học này](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP) ## Trong Phần này -Trong phần này, chúng ta sẽ học về: +Trong phần này chúng ta sẽ học về: * [Biểu diễn văn bản dưới dạng tensor](13-TextRep/README.md) * [Word Embeddings](14-Emdeddings/README.md) -* [Mô hình ngôn ngữ](15-LanguageModeling/README.md) -* [Mạng Nơ-ron Hồi quy](16-RNN/README.md) -* [Mạng Tạo sinh](17-GenerativeNetworks/README.md) +* [Mô hình Ngôn ngữ](15-LanguageModeling/README.md) +* [Mạng Nơ-ron Hồi tiếp](16-RNN/README.md) +* [Mạng Sinh tạo](17-GenerativeNetworks/README.md) * [Transformers](18-Transformers/README.md) --- -**Tuyên bố miễn trừ trách nhiệm**: -Tài liệu này đã được dịch bằng dịch vụ dịch thuật AI [Co-op Translator](https://github.com/Azure/co-op-translator). Mặc dù chúng tôi cố gắng đảm bảo độ chính xác, xin lưu ý rằng các bản dịch tự động có thể chứa lỗi hoặc không chính xác. Tài liệu gốc bằng ngôn ngữ bản địa nên được coi là nguồn thông tin chính thức. Đối với các thông tin quan trọng, khuyến nghị sử dụng dịch vụ dịch thuật chuyên nghiệp từ con người. Chúng tôi không chịu trách nhiệm cho bất kỳ sự hiểu lầm hoặc diễn giải sai nào phát sinh từ việc sử dụng bản dịch này. \ No newline at end of file + +**Tuyên bố miễn trừ trách nhiệm**: +Tài liệu này đã được dịch bằng dịch vụ dịch thuật AI [Co-op Translator](https://github.com/Azure/co-op-translator). Mặc dù chúng tôi cố gắng đảm bảo độ chính xác, xin lưu ý rằng bản dịch tự động có thể chứa lỗi hoặc sai sót. Tài liệu gốc bằng ngôn ngữ gốc nên được coi là nguồn tin chính thức. Đối với thông tin quan trọng, nên sử dụng dịch vụ dịch thuật chuyên nghiệp bởi con người. Chúng tôi không chịu trách nhiệm về bất kỳ hiểu lầm hoặc giải thích sai nào phát sinh từ việc sử dụng bản dịch này. + \ No newline at end of file