From de95c0ccf062f6e7d81478564c10d3cf2421483a Mon Sep 17 00:00:00 2001 From: "localizeflow[bot]" Date: Wed, 8 Jul 2026 18:04:13 +0000 Subject: [PATCH] chore(i18n): sync translations with latest source changes (chunk 1/1, 18 changes) --- translations/da/.co-op-translator.json | 37 ++++- translations/da/CONTRIBUTING.md | 29 ++++ translations/da/examples/README.md | 52 +++---- .../da/lessons/0-course-setup/how-to-run.md | 46 +++--- .../TransferLearningTF.ipynb | 135 +++++++++-------- translations/da/lessons/5-NLP/README.md | 76 +++++----- translations/sv/.co-op-translator.json | 37 ++++- translations/sv/CONTRIBUTING.md | 29 ++++ translations/sv/examples/README.md | 44 +++--- .../sv/lessons/0-course-setup/how-to-run.md | 38 ++--- .../TransferLearningTF.ipynb | 127 ++++++++-------- translations/sv/lessons/5-NLP/README.md | 62 ++++---- translations/th/.co-op-translator.json | 37 ++++- translations/th/CONTRIBUTING.md | 29 ++++ translations/th/examples/README.md | 58 +++---- .../th/lessons/0-course-setup/how-to-run.md | 55 ++++--- .../TransferLearningTF.ipynb | 141 +++++++++--------- translations/th/lessons/5-NLP/README.md | 70 ++++----- 18 files changed, 646 insertions(+), 456 deletions(-) create mode 100644 translations/da/CONTRIBUTING.md create mode 100644 translations/sv/CONTRIBUTING.md create mode 100644 translations/th/CONTRIBUTING.md diff --git a/translations/da/.co-op-translator.json b/translations/da/.co-op-translator.json index a69c32bb..03c3beef 100644 --- a/translations/da/.co-op-translator.json +++ b/translations/da/.co-op-translator.json @@ -5,6 +5,12 @@ "source_file": "AGENTS.md", "language_code": "da" }, + "CONTRIBUTING.md": { + "original_hash": "c6fd7e781b67111a90abd166d0ce4aa0", + "translation_date": "2026-07-08T18:04:07+00:00", + "source_file": "CONTRIBUTING.md", + "language_code": "da" + }, "README.md": { "original_hash": "12c8eb6bf0867d2f1c32daf613ac5b8b", "translation_date": "2026-04-06T16:25:23+00:00", @@ -17,6 +23,19 @@ "source_file": "SECURITY.md", "language_code": "da" }, + "__translation_failures__": { + "lessons/sketchnotes/LICENSE.md": { + "original_hash": "45ab63a2cd8f5faef6c9b150618837a4", + "source_file": "lessons/sketchnotes/LICENSE.md", + "language_code": "da", + "failure_date": "2026-07-08T18:03:38+00:00", + "status": "failed", + "error_type": "TranslationIncompleteError", + "error_message": "Markdown translation remained incomplete for chunk 1.1.2 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-28T16:06:55+00:00", @@ -54,8 +73,8 @@ "language_code": "da" }, "examples/README.md": { - "original_hash": "0d1babfdcbeb46525f2db3fbaaa54cd7", - "translation_date": "2025-10-03T11:31:26+00:00", + "original_hash": "7883d52c2e2a221e0b07a7b112a149b9", + "translation_date": "2026-07-08T17:58:12+00:00", "source_file": "examples/README.md", "language_code": "da" }, @@ -66,8 +85,8 @@ "language_code": "da" }, "lessons/0-course-setup/how-to-run.md": { - "original_hash": "a4717bd9103b9f6cd84d534b83534689", - "translation_date": "2026-01-16T02:27:08+00:00", + "original_hash": "7ad8c7d8604c53649b3d4d1e2f3a6fa1", + "translation_date": "2026-07-08T17:58:31+00:00", "source_file": "lessons/0-course-setup/how-to-run.md", "language_code": "da" }, @@ -191,6 +210,12 @@ "source_file": "lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md", "language_code": "da" }, + "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb": { + "original_hash": "99b816b6a4957ef4100cee4c4221dff9", + "translation_date": "2026-07-08T17:46:09+00:00", + "source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb", + "language_code": "da" + }, "lessons/4-ComputerVision/08-TransferLearning/lab/README.md": { "original_hash": "7765935c35fcee69b9fe2d0cfd6963e2", "translation_date": "2025-08-28T15:17:52+00:00", @@ -330,8 +355,8 @@ "language_code": "da" }, "lessons/5-NLP/README.md": { - "original_hash": "8ef02a9318257ea140ed3ed74442096d", - "translation_date": "2025-08-28T15:51:00+00:00", + "original_hash": "038df6f1a73e49f6430740da083bfd6d", + "translation_date": "2026-07-08T17:58:55+00:00", "source_file": "lessons/5-NLP/README.md", "language_code": "da" }, diff --git a/translations/da/CONTRIBUTING.md b/translations/da/CONTRIBUTING.md new file mode 100644 index 00000000..e17a1d01 --- /dev/null +++ b/translations/da/CONTRIBUTING.md @@ -0,0 +1,29 @@ +# Bidrage til AI-For-Beginners + +Tak for din interesse i at bidrage til AI-For-Beginners! Vi byder velkommen til oversættelser, rettelser af lektioner og formateringskorrektioner. + +## Microsoft Contributor License Agreement (CLA) + +Dette projekt byder på bidrag og forslag velkommen. De fleste bidrag kræver, at du accepterer en Contributor License Agreement (CLA), som erklærer, at du har ret til, og faktisk gør, at give os rettighederne til at bruge dit bidrag. For detaljer, besøg [https://cla.microsoft.com](https://cla.microsoft.com). + +Når du indsender en pull request, vil en CLA-bot automatisk afgøre, om du skal levere en CLA og dekorere PR'en passende (f.eks. label, kommentar). Følg blot instruktionerne, som botten giver. Du skal kun gøre dette én gang for alle repositories, der bruger vores CLA. + +## Sådan bidrager du + +### 1. Rettelse af tastefejl / kodefejl +Hvis du finder en tastefejl eller fejl i en hvilken som helst Jupyter-notebook eller lektion markdown-fil: +1. Fork repoet. +2. Ret tastefejlen eller den døde link. +3. Indsend en Pull Request med en klar beskrivelse af rettelsen. + +### 2. Indsendelse af oversættelser +Vi byder oversættelser af lektionerne til andre sprog velkommen! Placer venligst oversættelser i `translations/` mappen ved at bruge de eksisterende mappenavne der (for eksempel `translations/es/`, `translations/pt-BR/`, `translations/zh-CN/`). + +For flere detaljer, se [etc/CONTRIBUTING.md](etc/CONTRIBUTING.md). + +--- + + +**Ansvarsfraskrivelse**: +Dette dokument er blevet oversat ved hjælp af AI-oversættelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selvom vi bestræber os på nøjagtighed, skal du være opmærksom på, at automatiserede oversættelser kan indeholde fejl eller unøjagtigheder. Det originale dokument på dets oprindelige sprog bør betragtes som den autoritative kilde. For kritisk information anbefales professionel menneskelig oversættelse. Vi påtager os intet ansvar for misforståelser eller fejltolkninger, der opstår som følge af brugen af denne oversættelse. + \ No newline at end of file diff --git a/translations/da/examples/README.md b/translations/da/examples/README.md index 67eac562..81488999 100644 --- a/translations/da/examples/README.md +++ b/translations/da/examples/README.md @@ -1,27 +1,27 @@ # Begynder-venlige AI-eksempler -Velkommen! Denne mappe indeholder enkle, selvstændige eksempler, der hjælper dig med at komme i gang med AI og maskinlæring. Hvert eksempel er designet til at være begyndervenligt med detaljerede kommentarer og trin-for-trin forklaringer. +Velkommen! Dette bibliotek indeholder simple, selvstændige eksempler til at hjælpe dig i gang med AI og maskinlæring. Hvert eksempel er designet til at være begynder-venligt med detaljerede kommentarer og trin-for-trin forklaringer. ## 📚 Oversigt over eksempler | Eksempel | Beskrivelse | Sværhedsgrad | Forudsætninger | -|----------|-------------|--------------|----------------| -| [Hello AI World](../../../examples/01-hello-ai-world.py) | Dit første AI-program - simpel mønstergenkendelse | ⭐ Begynder | Grundlæggende Python | -| [Simple Neural Network](../../../examples/02-simple-neural-network.py) | Byg et neuralt netværk fra bunden | ⭐⭐ Begynder+ | Python, basal matematik | -| [Image Classifier](./03-image-classifier.ipynb) | Klassificér billeder med en forudtrænet model | ⭐⭐ Begynder+ | Python, numpy | -| [Text Sentiment](../../../examples/04-text-sentiment.py) | Analyser tekststemning (positiv/negativ) | ⭐⭐ Begynder+ | Python | +|---------|-------------|------------|---------------| +| [Hello AI World](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/01-hello-ai-world.py) | Dit første AI-program - enkel mønstergenkendelse | ⭐ Begynder | Grundlæggende Python | +| [Simple Neural Network](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/02-simple-neural-network.py) | Byg et neuralt netværk fra bunden | ⭐⭐ Begynder+ | Python, grundlæggende matematik | +| [Image Classifier](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/03-image-classifier.ipynb) | Klassificer billeder med en foruddannet model | ⭐⭐ Begynder+ | Python, numpy | +| [Text Sentiment](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/04-text-sentiment.py) | Analyser tekstfølelse (positiv/negativ) | ⭐⭐ Begynder+ | Python | -## 🚀 Kom godt i gang +## 🚀 Kom i gang ### Forudsætninger -Sørg for, at du har Python installeret (3.8 eller nyere anbefales). Installer de nødvendige pakker: +Sørg for, at du har Python installeret (version 3.8 eller nyere anbefales). Installer nødvendige pakker: ```bash -# For Python scripts +# Til Python-scripts pip install numpy -# For Jupyter notebooks (image classifier) +# Til Jupyter-notebooks (billedklassifikator) pip install jupyter numpy pillow tensorflow ``` @@ -32,33 +32,33 @@ conda env create --name ai4beg --file ../environment.yml conda activate ai4beg ``` -### Sådan kører du eksemplerne +### Kør eksemplerne -**For Python-scripts (.py-filer):** +**For Python-scripts (.py filer):** ```bash python 01-hello-ai-world.py ``` -**For Jupyter-notebooks (.ipynb-filer):** +**For Jupyter-notebooks (.ipynb filer):** ```bash jupyter notebook 03-image-classifier.ipynb ``` -## 📖 Læringssti +## 📖 Læringsvej -Vi anbefaler at følge eksemplerne i rækkefølge: +Vi anbefaler at følge eksemplerne i denne rækkefølge: 1. **Start med "Hello AI World"** - Lær det grundlæggende om mønstergenkendelse 2. **Byg et simpelt neuralt netværk** - Forstå, hvordan neurale netværk fungerer -3. **Prøv Image Classifier** - Se AI i aktion med rigtige billeder -4. **Analyser tekststemning** - Udforsk naturlig sprogbehandling +3. **Prøv billedklassifikatoren** - Se AI i aktion med rigtige billeder +4. **Analyser tekstfølelse** - Udforsk naturlig sprogbehandling ## 💡 Tips til begyndere - **Læs kodekommentarerne grundigt** - De forklarer, hvad hver linje gør -- **Eksperimentér!** - Prøv at ændre værdier og se, hvad der sker -- **Vær ikke bekymret for at forstå alt** - Læring tager tid -- **Stil spørgsmål** - Brug [diskussionsforummet](https://github.com/microsoft/AI-For-Beginners/discussions) +- **Eksperimenter!** - Prøv at ændre værdier og se, hvad der sker +- **Bekymr dig ikke om at forstå alt med det samme** - Læring tager tid +- **Stil spørgsmål** - Brug [diskussionsbordet](https://github.com/microsoft/AI-For-Beginners/discussions) ## 🔗 Næste skridt @@ -70,16 +70,18 @@ Efter at have gennemført disse eksempler, kan du udforske hele pensum: ## 🤝 Bidrag -Fandt du disse eksempler nyttige? Hjælp os med at forbedre dem: -- Rapportér problemer eller foreslå forbedringer +Synes du, disse eksempler er hjælpsomme? Hjælp os med at forbedre dem: +- Rapporter problemer eller foreslå forbedringer - Tilføj flere eksempler for begyndere - Forbedr dokumentation og kommentarer --- -*Husk: Hver ekspert har engang været en begynder. God læring! 🎓* +*Husk: Enhver ekspert har engang været begynder. God læring! 🎓* --- -**Ansvarsfraskrivelse**: -Dette dokument er blevet oversat ved hjælp af AI-oversættelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selvom vi bestræber os på nøjagtighed, skal det bemærkes, at automatiserede oversættelser kan indeholde fejl eller unøjagtigheder. Det originale dokument på dets oprindelige sprog bør betragtes som den autoritative kilde. For kritisk information anbefales professionel menneskelig oversættelse. Vi påtager os intet ansvar for misforståelser eller fejltolkninger, der måtte opstå som følge af brugen af denne oversættelse. \ No newline at end of file + +**Ansvarsfraskrivelse**: +Dette dokument er blevet oversat ved hjælp af AI-oversættelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selvom vi bestræber os på nøjagtighed, skal du være opmærksom på, at automatiserede oversættelser kan indeholde fejl eller unøjagtigheder. Det originale dokument på dets oprindelige sprog bør betragtes som den autoritative kilde. For kritisk information anbefales professionel menneskelig oversættelse. Vi påtager os intet ansvar for misforståelser eller fejltolkninger, der opstår som følge af brugen af denne oversættelse. + \ No newline at end of file diff --git a/translations/da/lessons/0-course-setup/how-to-run.md b/translations/da/lessons/0-course-setup/how-to-run.md index ecabe398..9b10a34b 100644 --- a/translations/da/lessons/0-course-setup/how-to-run.md +++ b/translations/da/lessons/0-course-setup/how-to-run.md @@ -1,12 +1,12 @@ -# Sådan kører du koden +# Hvordan man kører koden -Dette kursusindhold indeholder mange eksekverbare eksempler og laboratorier, som du vil ønske at køre. For at kunne gøre dette, har du brug for muligheden for at eksekvere Python-kode i Jupyter Notebooks, som leveres som en del af dette kursusindhold. Du har flere muligheder for at køre koden: +Dette pensum indeholder mange eksekverbare eksempler og laboratorier, som du vil få brug for at køre. For at gøre dette, skal du kunne eksekvere Python-kode i Jupyter Notebooks, som er en del af dette pensum. Du har flere muligheder for at køre koden: ## Kør lokalt på din computer -For at køre koden lokalt på din computer, er der brug for en Python-installation. En anbefaling er at installere **[miniconda](https://conda.io/en/latest/miniconda.html)** - det er en forholdsvis letvægtsinstallation, der understøtter `conda` pakkestyringsværktøjet til forskellige Python **virtuelle miljøer**. +For at køre koden lokalt på din computer, er en Python-installation nødvendig. En anbefaling er at installere **[miniconda](https://conda.io/en/latest/miniconda.html)** - det er en relativt let installation, der understøtter `conda` pakkehåndteringen til forskellige Python **virtuelle miljøer**. -Efter du har installeret miniconda, klon da repositoryet og opret et virtuelt miljø, der skal bruges til dette kursus: +Efter du har installeret miniconda, klon repositoriet og opret et virtuelt miljø til brug for dette kursus: ```bash git clone http://github.com/microsoft/ai-for-beginners @@ -15,19 +15,19 @@ conda env create --name ai4beg --file .devcontainer/environment.yml conda activate ai4beg ``` -### Brug af Visual Studio Code med Python Extension +### Brug af Visual Studio Code med Python-udvidelsen -Dette kursusindhold bruges bedst ved at åbne det i [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) med [Python Extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste). +Dette pensum bruges bedst ved at åbne det i [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) med [Python-udvidelsen](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste). -> **Note**: Når du har klonet og åbnet mappen i VS Code, vil det automatisk foreslå dig at installere Python-udvidelser. Du skal også installere miniconda som beskrevet ovenfor. +> **Note**: Når du har klonet og åbnet mappen i VS Code, vil den automatisk foreslå at installere Python-udvidelser. Du skal også installere miniconda som beskrevet ovenfor. -> **Note**: Hvis VS Code foreslår dig at genåbne repositoryet i en container, bør du afslå dette for at bruge den lokale Python-installation. +> **Note**: Hvis VS Code foreslår at genåbne repositoriet i en container, skal du afslå dette for at bruge den lokale Python-installation. ### Brug af Jupyter i browseren -Du kan også bruge et Jupyter-miljø fra browseren på din egen computer. Både klassisk Jupyter og JupyterHub tilbyder et praktisk udviklingsmiljø med autofuldendelse, kodefremhævning osv. +Du kan også bruge et Jupyter-miljø fra browseren på din egen computer. Både klassisk Jupyter og JupyterHub giver et bekvemt udviklingsmiljø med autoudfyldning, kodehighlighting osv. -For at starte Jupyter lokalt, gå til kursusmappen, og eksekver: +For at starte Jupyter lokalt, gå til kursusmappen, og kør: ```bash jupyter notebook @@ -36,36 +36,36 @@ eller ```bash jupyterhub ``` -Du kan derefter navigere til en hvilken som helst af `.ipynb` filerne, åbne dem og begynde at arbejde. +Du kan herefter navigere til enhver `.ipynb` fil, åbne den og begynde at arbejde. ### Kørsel i container -Et alternativ til Python-installation ville være at køre koden i en container. Da vores repository leverer en særlig `.devcontainer` mappe, der instruerer hvordan man bygger en container til dette repo, tilbyder VS Code muligheden for at genåbne koden i en container. Dette kræver installation af Docker og er også mere komplekst, så vi anbefaler dette til mere erfarne brugere. +Et alternativ til Python-installation ville være at køre koden i en container. Da vores repo leverer en speciel `.devcontainer` mappe, der vejleder, hvordan man bygger en container til dette repo, tilbyder VS Code muligheden for at genåbne koden inde i en container. Dette kræver Docker-installation og er også mere komplekst, så vi anbefaler dette til mere erfarne brugere. ## Kørsel i skyen -Hvis du ikke ønsker at installere Python lokalt, og har adgang til nogle skyeressourcer – er et godt alternativ at køre koden i skyen. Der er flere måder, du kan gøre dette på: +Hvis du ikke ønsker at installere Python lokalt, og har adgang til nogle skyressourcer - er et godt alternativ at køre koden i skyen. Der er flere måder du kan gøre det på: -* Brug af **[GitHub Codespaces](https://github.com/features/codespaces)**, som er et virtuelt miljø oprettet for dig på GitHub, tilgængeligt gennem en VS Code browsergrænseflade. Hvis du har adgang til Codespaces, kan du blot klikke på **Code** knappen i repositoriet, starte et codespace og komme i gang med det samme. -* Brug af **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) tilbyder gratis beregningsressourcer i skyen til folk som dig, der vil teste noget kode på GitHub. Der er en knap på forsiden til at åbne repositoryet i Binder – dette vil hurtigt føre dig til binder-sitet, som vil bygge en underliggende container og starte en Jupyter webgrænseflade for dig glidende. +* Brug af **[GitHub Codespaces](https://github.com/features/codespaces)**, som er et virtuelt miljø oprettet til dig på GitHub, tilgængeligt gennem et VS Code browserinterface. Hvis du har adgang til Codespaces, kan du bare klikke på **Code** knappen i repoet, starte en codespace, og være i gang på ingen tid. +* Brug af **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) tilbyder gratis computerressourcer leveret i skyen til folk som dig, så man kan teste noget kode fra GitHub. Der er en knap på forside, som åbner repositoriet i Binder - dette fører dig hurtigt til bindersiden, som bygger en underliggende container og starter et Jupyter webinterface for dig problemfrit. -> **Note**: For at forhindre misbrug har Binder adgang til nogle webressourcer blokeret. Dette kan forhindre noget kode i at fungere, som henter modeller og/eller datasæt fra det offentlige Internet. Du skal måske finde nogle alternative løsninger. Derudover er de beregningsressourcer, som Binder tilbyder, ret simple, så træning vil gå langsomt, især i de senere, mere komplekse lektioner. +> **Note**: For at forhindre misbrug, har Binder blokeret adgang til nogle webressourcer. Dette kan forhindre, at noget kode virker, som henter modeller og/eller datasæt fra det offentlige internet. Du kan blive nødt til at finde nogle løsninger. Derudover er de computerressourcer, som Binder leverer, ret grundlæggende, så træning vil være langsom, især i de senere, mere komplekse lektioner. ## Kørsel i skyen med GPU -Nogle af de senere lektioner i dette kursusindhold vil have stor gavn af GPU-understøttelse. Modeltræning, for eksempel, kan være smertefuldt langsomt ellers. Der er et par muligheder, du kan følge, især hvis du har adgang til skyen enten gennem [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste), eller gennem din institution: +Nogle af de senere lektioner i dette pensum vil have stor fordel af GPU-understøttelse. Modeltræning kan for eksempel være smertefuldt langsom ellers. Der er nogle muligheder, som du kan følge, især hvis du har adgang til skyen gennem [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste), eller via din institution: -* Opret en [Data Science Virtual Machine](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) og forbind til den gennem Jupyter. Du kan så klone repoet direkte på maskinen og begynde at lære. NC-serie VM’er har GPU-understøttelse. +* Opret en [Data Science Virtual Machine](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) og forbind til den gennem Jupyter. Du kan så klone repoet direkte på maskinen og begynde at lære. NC-seriens VM'er har GPU-understøttelse. -> **Note**: Nogle abonnementer, inklusiv Azure for Students, tilbyder ikke GPU-understøttelse som standard. Du skal muligvis anmode om ekstra GPU-kerner via en teknisk supportsag. +> **Note**: Nogle abonnementer, inklusive Azure for Students, tilbyder ikke GPU-understøttelse som standard. Du skal muligvis anmode om ekstra GPU-kerner via en teknisk supportanmodning. -* Opret et [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) og brug dernæst Notebook-funktionen. [Denne video](https://azure-for-academics.github.io/quickstart/azureml-papers/) viser, hvordan man kloner et repository ind i Azure ML notebook og begynder at bruge det. +* Opret et [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) og brug derefter Notebook-funktionen dér. [Denne video](https://azure-for-academics.github.io/quickstart/azureml-papers/) viser, hvordan man kloner et repository ind i Azure ML notebook og begynder at bruge det. -Du kan også bruge Google Colab, som kommer med noget gratis GPU-understøttelse, og uploade Jupyter Notebooks der for at eksekvere dem én efter én. +Du kan også bruge Google Colab, som har noget gratis GPU-understøttelse, og uploade Jupyter Notebooks der for at eksekvere dem én ad gangen. --- -**Ansvarsfraskrivelse**: -Dette dokument er blevet oversat ved hjælp af AI-oversættelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selvom vi bestræber os på nøjagtighed, skal du være opmærksom på, at automatiserede oversættelser kan indeholde fejl eller unøjagtigheder. Det oprindelige dokument på dets modersmål skal betragtes som den autoritative kilde. For kritisk information anbefales professionel menneskelig oversættelse. Vi påtager os ikke ansvar for misforståelser eller fejltolkninger, der opstår ved brug af denne oversættelse. +**Ansvarsfraskrivelse**: +Dette dokument er blevet oversat ved hjælp af AI-oversættelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selvom vi bestræber os på nøjagtighed, skal du være opmærksom på, at automatiserede oversættelser kan indeholde fejl eller unøjagtigheder. Det originale dokument på dets oprindelige sprog bør betragtes som den autoritative kilde. For kritisk information anbefales professionel menneskelig oversættelse. Vi påtager os intet ansvar for misforståelser eller fejltolkninger, der opstår som følge af brugen af denne oversættelse. \ No newline at end of file diff --git a/translations/da/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb b/translations/da/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb index f6f1e265..e83574f7 100644 --- a/translations/da/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb +++ b/translations/da/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb @@ -4,11 +4,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Forudtrænede modeller og transfer learning\n", + "# Foruddannede modeller og transfer learning\n", "\n", - "Træning af CNN'er kan tage meget tid, og der kræves en stor mængde data til denne opgave. Dog bruges en stor del af tiden på at lære de bedste lavniveaufiltre, som et netværk anvender til at udtrække mønstre fra billeder. Et naturligt spørgsmål opstår - kan vi bruge et neuralt netværk, der er trænet på ét datasæt, og tilpasse det til at klassificere forskellige billeder uden en fuld træningsproces?\n", + "Træning af CNN’er kan tage meget tid, og der kræves mange data til den opgave. Dog bruges meget af tiden på at lære de bedste lavniveau-filtre, som et netværk bruger til at udtrække mønstre fra billeder. Et naturligt spørgsmål opstår – kan vi bruge et neuralt netværk, der er trænet på et datasæt, og tilpasse det til at klassificere forskellige billeder uden en fuld træningsproces?\n", "\n", - "Denne tilgang kaldes **transfer learning**, fordi vi overfører noget viden fra én neuralt netværksmodel til en anden. I transfer learning starter vi typisk med en forudtrænet model, som er blevet trænet på et stort billeddatasæt, såsom **ImageNet**. Disse modeller kan allerede gøre et godt stykke arbejde med at udtrække forskellige funktioner fra generiske billeder, og i mange tilfælde kan det give gode resultater blot at bygge en klassifikator oven på de udtrukne funktioner.\n" + "Denne tilgang kaldes **transfer learning**, fordi vi overfører noget viden fra én neural netværksmodel til en anden. I transfer learning starter vi typisk med en foruddannet model, som er blevet trænet på et stort billeddatasæt, såsom **ImageNet**. Disse modeller kan allerede gøre et godt stykke arbejde med at udtrække forskellige funktioner fra generiske billeder, og i mange tilfælde kan blot at bygge en klassifikator ovenpå disse udtrukne funktioner give et godt resultat.\n" ] }, { @@ -29,11 +29,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Katte vs. Hunde-datasæt\n", + "## Katte vs. Hunde Datasæt\n", "\n", - "I denne enhed vil vi løse et virkelighedsnært problem med at klassificere billeder af katte og hunde. Af denne grund vil vi bruge [Kaggle Cats vs. Dogs Dataset](https://www.kaggle.com/c/dogs-vs-cats), som også kan downloades [fra Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n", + "I denne enhed vil vi løse et problem fra det virkelige liv med at klassificere billeder af katte og hunde. Af denne grund vil vi bruge [Kaggle Cats vs. Dogs Dataset](https://www.kaggle.com/c/dogs-vs-cats), som også kan downloades [fra Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n", "\n", - "Lad os downloade dette datasæt og udpakke det i `data`-mappen (denne proces kan tage noget tid!):\n" + "Lad os downloade dette datasæt og udpakke det i `data`-mappen (denne proces kan tage lidt tid!):\n" ] }, { @@ -64,7 +64,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Desværre er der nogle korrupte billedfiler i datasættet. Vi skal hurtigt rense for at kontrollere for korrupte filer. For ikke at overbelaste denne tutorial har vi flyttet koden til at verificere datasættet ind i et modul.\n" + "Desværre er der nogle beskadigede billedfiler i datasættet. Vi skal lave en hurtig oprydning for at kontrollere for beskadigede filer. For ikke at ødelægge denne tutorial har vi flyttet koden til at verificere datasættet ind i en modul.\n" ] }, { @@ -335,11 +335,11 @@ "source": [ "## Indlæsning af datasættet\n", "\n", - "I tidligere eksempler indlæste vi datasæt, der er indbygget i Keras. Nu skal vi arbejde med vores eget datasæt, som vi skal indlæse fra en mappe med billeder.\n", + "I tidligere eksempler har vi indlæst datasæt, der er indbygget i Keras. Nu skal vi håndtere vores eget datasæt, som vi skal indlæse fra en mappe med billeder.\n", "\n", - "I virkeligheden kan størrelsen på billeddatasæt være ret stor, og man kan ikke regne med, at al data kan passe ind i hukommelsen. Derfor repræsenteres datasæt ofte som **generatorer**, der kan returnere data i minibatches, der er egnede til træning.\n", + "I virkeligheden kan billeddatasæt være temmelig store, og man kan ikke regne med, at alle data kan være i hukommelsen på én gang. Derfor repræsenteres datasæt ofte som **generatorer**, der kan returnere data i minibatcher, som er velegnede til træning.\n", "\n", - "For at håndtere billedklassifikation inkluderer Keras en speciel funktion `image_dataset_from_directory`, som kan indlæse billeder fra undermapper, der svarer til forskellige klasser. Denne funktion tager også hånd om skalering af billeder, og den kan desuden opdele datasættet i trænings- og testundersæt:\n" + "For at håndtere billedklassifikation inkluderer Keras en speciel funktion `image_dataset_from_directory`, der kan indlæse billeder fra undermapper, som svarer til forskellige klasser. Denne funktion tager sig også af at skalere billederne, og den kan også opdele datasættet i trænings- og testdelmængder:\n" ] }, { @@ -383,9 +383,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Det er vigtigt at angive den samme `seed`-værdi for begge kald, da det påvirker opdelingen af billeder mellem trænings- og testdatasættet.\n", + "Det er vigtigt at sætte den samme `seed` værdi for begge kald, fordi det påvirker opdelingen af billeder mellem trænings- og testdatasættet.\n", "\n", - "Datasættet henter automatisk klassenavne fra mapperne, og du kan få adgang til dem, hvis nødvendigt, ved at kalde:\n" + "Datasættet henter automatisk klassenavne fra mapper, og du kan tilgå dem, hvis nødvendigt, ved at kalde:\n" ] }, { @@ -412,7 +412,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Datasæt, som vi har opnået, kan direkte sendes til `fit`-funktionen for at træne modellen. De indeholder både tilsvarende billeder og labels, som kan loopes over ved hjælp af følgende konstruktion:\n" + "Datasæt, som vi har indhentet, kan direkte videregives til `fit`-funktionen for at træne modellen. De indeholder både tilsvarende billeder og etiketter, som kan gennemløbes ved hjælp af følgende konstruktion:\n" ] }, { @@ -453,16 +453,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "> **Bemærk**: Alle billeder i datasættet er repræsenteret som flydende punkt-tensorer med rækkevidde 0-255. Før vi sender dem til neurale netværk, skal vi skalere disse værdier til rækkevidden 0-1. Når vi plotter billeder, skal vi enten gøre det samme eller konvertere værdierne til typen `int` (hvilket vi gør i koden ovenfor) for at vise `matplotlib`, at vi ønsker at plotte det originale, uskalede billede.\n" + "> **Bemærk**: Alle billeder i datasættet er repræsenteret som flydende punkt tensorer med intervallet 0-255. Før vi sender dem til det neurale netværk, skal vi skalere disse værdier til intervallet 0-1. Når vi plottet billeder, skal vi enten gøre det samme eller konvertere værdier til `int` typen (hvilket vi gør i koden ovenfor), for at vise `matplotlib`, at vi ønsker at plotte det originale uskalerede billede.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Forudtrænede modeller\n", + "## Fortrænede modeller\n", "\n", - "Til mange opgaver inden for billedklassifikation kan man finde forudtrænede neurale netværksmodeller. Mange af disse modeller er tilgængelige inden for `keras.applications`-navneområdet, og endnu flere modeller kan findes på internettet. Lad os se, hvordan den simpleste VGG-16-model kan indlæses og bruges:\n" + "For mange billedklassificeringsopgaver kan man finde fortrænede neurale netværksmodeller. Mange af disse modeller er tilgængelige inde i `keras.applications`-navnerummet, og endnu flere modeller kan findes på internettet. Lad os se, hvordan den simpleste VGG-16-model kan indlæses og bruges:\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,17 +520,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Der er et par vigtige ting at bemærke her: \n", - "* Før man sender en input til et forudtrænet netværk, skal det forbehandles på en bestemt måde. Dette gøres ved at kalde den tilsvarende `preprocess_input`-funktion, som modtager et batch af billeder og returnerer deres forarbejdede form. I tilfældet med VGG-16 bliver billederne normaliseret, og en foruddefineret gennemsnitsværdi for hver kanal bliver trukket fra. Dette skyldes, at VGG-16 oprindeligt blev trænet med denne forbehandling. \n", - "* Det neurale netværk anvendes på input-batchen, og som resultat modtager vi et batch af 1000-elementers tensorer, der viser sandsynligheden for hver klasse. Vi kan finde nummeret på den mest sandsynlige klasse ved at kalde `argmax` på denne tensor. \n", - "* Det opnåede resultat er et [nummer på en `ImageNet`-klasse](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). For at give mening til dette resultat kan vi også bruge funktionen `decode_predictions`, som returnerer de øverste n klasser sammen med deres navne. \n" + "Der er et par vigtige ting her:\n", + "* Før man sender en input til et forudtrænet netværk, skal det forbehandles på en bestemt måde. Dette gøres ved at kalde den tilsvarende `preprocess_input` funktion, som modtager en batch af billeder, og returnerer deres behandlede form. I tilfælde af VGG-16 normaliseres billederne, og en foruddefineret gennemsnitsværdi for hver kanal fratrækkes. Det skyldes, at VGG-16 oprindeligt blev trænet med denne forbehandling.\n", + "* Det neurale netværk anvendes på input-batchen, og vi modtager som resultat en batch af 1000-element tensorer, som viser sandsynligheden for hver klasse. Vi kan finde det mest sandsynlige klassenummer ved at kalde `argmax` på denne tensor.\n", + "* Det opnåede resultat er et [nummer for en `ImageNet`-klasse](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). For at forstå dette resultat bedre, kan vi også bruge `decode_predictions` funktionen, som returnerer de top n klasser sammen med deres navne.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Lad os også se arkitekturen af VGG-16-netværket:\n" + "Lad os også se arkitekturen af VGG-16 netværket:\n" ] }, { @@ -599,7 +609,7 @@ "source": [ "## GPU-beregninger\n", "\n", - "Dybe neurale netværk, såsom VGG-16 og andre mere moderne arkitekturer, kræver en hel del regnekraft for at køre. Det giver mening at bruge GPU-acceleration, hvis det er tilgængeligt. Heldigvis optimerer Keras automatisk beregningerne på GPU'en, hvis den er tilgængelig. Vi kan kontrollere, om Tensorflow er i stand til at bruge GPU'en ved hjælp af følgende kode:\n" + "Dybe neurale netværk, såsom VGG-16 og andre mere moderne arkitekturer, kræver ret meget beregningskraft for at køre. Det giver god mening at bruge GPU-acceleration, hvis det er tilgængeligt. Heldigvis fremskynder Keras automatisk beregningerne på GPU'en, hvis den er tilgængelig. Vi kan tjekke, om Tensorflow kan bruge GPU med følgende kode:\n" ] }, { @@ -626,9 +636,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "\n", "## Udtrækning af VGG-funktioner\n", "\n", - "Hvis vi ønsker at bruge VGG-16 til at udtrække funktioner fra vores billeder, skal vi bruge modellen uden de sidste klassifikationslag. Vi kan oprette en VGG-16 model uden de øverste lag ved hjælp af denne kode:\n" + "Hvis vi vil bruge VGG-16 til at udtrække funktioner fra vores billeder, har vi brug for modellen uden de afsluttende klassifikationslag. Vi kan instantiere VGG-16-modellen uden top lag ved hjælp af denne kode:\n" ] }, { @@ -680,9 +691,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Dimensionen af feature-tensoren er 7x7x512, men for at visualisere den var vi nødt til at omforme den til en 2D-form.\n", + "Dimensionen af feature-tensoren er 7x7x512, men for at visualisere den var vi nødt til at omforme den til 2D-form.\n", "\n", - "Lad os nu prøve at se, om disse features kan bruges til at klassificere billeder. Vi tager manuelt en del af billederne (50 minibatches i vores tilfælde) og forudberegner deres feature-vektorer. Vi kan bruge Tensorflow **dataset** API til dette. `map`-funktionen tager et datasæt og anvender en given lambda-funktion for at transformere det. Vi bruger denne mekanisme til at konstruere nye datasæt, `ds_features_train` og `ds_features_test`, som indeholder VGG-ekstraherede features i stedet for de originale billeder.\n" + "Lad os nu prøve at se, om disse features kan bruges til at klassificere billeder. Lad os manuelt tage en delmængde af billeder (50 minibatches i vores tilfælde) og forudberegne deres feature-vektorer. Vi kan bruge Tensorflow **dataset** API til det. `map`-funktionen tager et dataset og anvender en given lambda-funktion til at transformere det. Vi bruger denne mekanisme til at konstruere nye datasæt, `ds_features_train` og `ds_features_test`, som indeholder VGG-ekstraherede features i stedet for de originale billeder.\n" ] }, { @@ -712,9 +723,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Vi brugte konstruktionen `.take(50)` for at begrænse datasættets størrelse og dermed fremskynde vores demonstration. Du kan naturligvis udføre dette eksperiment på det fulde datasæt.\n", + "Vi brugte konstruktionen `.take(50)` til at begrænse datasættets størrelse for at fremskynde vores demonstration. Du kan selvfølgelig udføre dette eksperiment på det fulde datasæt.\n", "\n", - "Nu hvor vi har et datasæt med udtrukne funktioner, kan vi træne en simpel tæt klassifikator til at skelne mellem katte og hunde. Dette netværk vil tage en feature-vektor med formen (7,7,512) og producere en output, der enten svarer til en hund eller en kat. Da det er en binær klassifikation, bruger vi aktiveringsfunktionen `sigmoid` og tabet `binary_crossentropy`.\n" + "Nu hvor vi har et datasæt med udtrukne features, kan vi træne en simpel tæt klassifikator til at skelne mellem katte og hunde. Dette netværk tager en feature-vektor af formen (7,7,512) og producerer et output, der svarer til enten en hund eller en kat. Fordi det er en binær klassifikation, bruger vi `sigmoid` aktiveringsfunktion og `binary_crossentropy` tab.\n" ] }, { @@ -743,13 +754,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Resultatet er fantastisk, vi kan skelne mellem en kat og en hund med næsten 95% sandsynlighed! Dog har vi kun testet denne tilgang på et udsnit af alle billeder, da manuel feature-ekstraktion ser ud til at tage meget tid.\n", + "Resultatet er fremragende, vi kan skelne mellem en kat og en hund med næsten 95% sandsynlighed! Dog har vi kun testet denne tilgang på et delmængde af alle billeder, fordi manuel feature-ekstraktion ser ud til at tage meget tid.\n", "\n", - "## Transfer learning ved brug af én VGG-netværk\n", + "## Transfer learning ved brug af et VGG-netværk\n", "\n", - "Vi kan også undgå manuelt at forudberegne funktionerne ved at bruge det originale VGG-16 netværk som helhed under træning, ved at tilføje en feature-ekstraktor til vores netværk som første lag.\n", + "Vi kan også undgå manuelt at forberegne features ved at bruge det oprindelige VGG-16 netværk som helhed under træningen, ved at tilføje feature-ekstraktor til vores netværk som et første lag.\n", "\n", - "Det smukke ved Keras-arkitekturen er, at VGG-16 modellen, som vi har defineret ovenfor, også kan bruges som et lag i et andet neuralt netværk! Vi skal blot konstruere et netværk med en tæt classifier ovenpå, og derefter træne hele netværket ved hjælp af backpropagation.\n" + "Skønheden ved Keras' arkitektur er, at VGG-16 modellen, som vi har defineret ovenfor, også kan bruges som et lag i et andet neuralt netværk! Vi skal bare konstruere et netværk med en tæt klassifikator ovenpå, og så træne hele netværket ved hjælp af backpropagation.\n" ] }, { @@ -793,13 +804,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Denne model ligner et end-to-end klassifikationsnetværk, som tager et billede og returnerer klassen. Det vanskelige er dog, at vi ønsker, at VGG16 skal fungere som en feature extractor og ikke blive gen-trænet. Derfor skal vi **fryse vægtene i den konvolutionelle feature extractor**. Vi kan få adgang til det første lag i netværket ved at kalde `model.layers[0]`, og vi skal blot sætte egenskaben `trainable` til `False`.\n", + "Denne model ligner et ende-til-ende klassifikationsnetværk, som tager et billede og returnerer klassen. Det svære er dog, at vi ønsker, at VGG16 skal fungere som en feature-udtrækker, og ikke genuddannes. Derfor skal vi **fryse vægtene i den konvolutionelle feature-udtrækker**. Vi kan få adgang til det første lag i netværket ved at kalde `model.layers[0]`, og vi skal blot sætte `trainable`-egenskaben til `False`.\n", "\n", - "> **Note**: Det er nødvendigt at fryse vægtene i feature extractoren, fordi et ellers utrænet klassifikationslag kan ødelægge de oprindelige fortrænede vægte i den konvolutionelle extractor.\n", + "> **Bemærk**: Frysing af feature-udtrækkerens vægte er nødvendigt, fordi ellers kan det ikke-trænede klassifikationslag ødelægge de oprindelige foruddannede vægte i den konvolutionelle udtrækker.\n", "\n", - "Du kan bemærke, at selvom det samlede antal parametre i vores netværk er omkring 15 millioner, træner vi kun 25.000 parametre. Alle andre parametre i de øverste konvolutionelle filtre er fortrænede. Det er godt, fordi vi kan finjustere et mindre antal parametre med et mindre antal eksempler.\n", + "Du kan bemærke, at mens det totale antal parametre i vores netværk er omkring 15 millioner, træner vi kun 25k parametre. Alle andre parametre i topniveau konvolutionelle filtre er foruddannet. Det er godt, fordi vi er i stand til at finjustere et mindre antal parametre med et mindre antal eksempler.\n", "\n", - "Vi vil nu træne vores netværk og se, hvor gode resultater vi kan opnå. Forvent en ret lang køretid, og vær ikke bekymret, hvis det ser ud til, at udførelsen er frosset i et stykke tid.\n" + "Vi vil nu træne vores netværk og se, hvor godt vi kan blive. Forvent en ret lang køretid, og vær ikke bekymret, hvis udførelsen virker frosset i et stykke tid.\n" ] }, { @@ -824,11 +835,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Det ser ud til, at vi har opnået en rimelig præcis klassificering af katte vs. hunde!\n", + "Det ser ud til, at vi har opnået en rimelig præcis katte- vs. hunde-klassifikator! \n", "\n", "## Gemme og indlæse modellen\n", "\n", - "Når vi har trænet modellen, kan vi gemme modelarkitekturen og de trænede vægte i en fil til fremtidig brug:\n" + "Når vi har trænet modellen, kan vi gemme modelarkitektur og trænede vægte til en fil til fremtidig brug:\n" ] }, { @@ -852,7 +863,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Vi kan derefter indlæse modellen fra filen når som helst. Du kan finde det nyttigt, hvis det næste eksperiment ødelægger modellen - du behøver ikke at starte forfra.\n" + "Vi kan så indlæse modellen fra fil når som helst. Det kan være nyttigt, hvis det næste eksperiment ødelægger modellen – så behøver du ikke starte forfra.\n" ] }, { @@ -870,13 +881,13 @@ "source": [ "## Finjustering af transfer learning\n", "\n", - "I det forrige afsnit har vi trænet det sidste klassifikationslag til at klassificere billeder i vores eget datasæt. Dog har vi ikke gen-trænet feature-udtrækkeren, og vores model har været afhængig af de features, som modellen har lært fra ImageNet-data. Hvis dine objekter visuelt adskiller sig fra almindelige ImageNet-billeder, kan denne kombination af features muligvis ikke fungere optimalt. Derfor giver det mening at begynde at træne de konvolutionelle lag også.\n", + "I det foregående afsnit har vi trænet det sidste klassifikationslag til at klassificere billeder i vores eget datasæt. Vi gen-trænede dog ikke feature-ekstraktoren, og vores model byggede på de features, som modellen havde lært på ImageNet-data. Hvis dine objekter visuelt adskiller sig fra almindelige ImageNet-billeder, virker denne kombination af features måske ikke optimalt. Derfor giver det mening også at begynde at træne convolutional lag.\n", "\n", - "For at gøre dette kan vi ophæve frysningsstatus for de konvolutionelle filterparametre, som vi tidligere har frosset.\n", + "For at gøre det kan vi ophæve frysningen af de convolutional filterparametre, som vi tidligere har frosset. \n", "\n", - "> **Note:** Det er vigtigt, at du først fryser parametrene og udfører flere trænings-epoker for at stabilisere vægtene i klassifikationslaget. Hvis du straks begynder at træne et end-to-end netværk med ikke-frosne parametre, er der stor sandsynlighed for, at store fejl vil ødelægge de forudtrænede vægte i de konvolutionelle lag.\n", + "> **Note:** Det er vigtigt, at du først fryser parametrene og gennemfører flere trænings-epoker for at stabilisere vægtene i klassifikationslaget. Hvis du straks begynder at træne hele netværket med optøede parametre, risikerer du, at store fejl ødelægger de fortrænede vægte i convolutional lagene.\n", "\n", - "Vores konvolutionelle VGG-16-model er placeret i det første lag og består af mange lag i sig selv. Vi kan tage et kig på dens struktur:\n" + "Vores convolutional VGG-16-model er placeret inde i det første lag, og den består selv af mange lag. Lad os tage et kig på dens struktur: \n" ] }, { @@ -945,7 +956,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Vi kan ophæve frysningen af alle lag i den konvolutionelle base:\n" + "Vi kan optø alle lag i den konvolutionsbaserede kerne:\n" ] }, { @@ -961,7 +972,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Men at fryse dem alle op på én gang er ikke den bedste idé. Vi kan først fryse kun nogle få af de sidste lag af konvolutioner op, fordi de indeholder højere niveau mønstre, der er relevante for vores billeder. For eksempel kan vi til at begynde med fryse alle lag undtagen de sidste 4:\n" + "Det er dog ikke den bedste idé at optø dem alle på én gang. Vi kan først optø blot nogle få af de sidste lag af konvolutioner, fordi de indeholder højere niveau mønstre, som er relevante for vores billeder. For eksempel kan vi til at begynde med fryse alle lag undtagen de sidste 4: \n" ] }, { @@ -1000,11 +1011,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Bemærk, at antallet af trænbare parametre er steget markant, men det er stadig omkring 50% af alle parametre.\n", + "Bemærk, at antallet af trænbare parametre steg betydeligt, men det er stadig omkring 50 % af alle parametre.\n", "\n", - "Efter at have låst op for træningen, kan vi køre et par flere trænings-epoker (i vores eksempel vil vi kun køre én). Du kan også vælge en lavere læringsrate for at minimere påvirkningen på de fortrænede vægte. Dog kan du, selv med en lav læringsrate, forvente, at nøjagtigheden falder i starten af træningen, indtil den til sidst når et lidt højere niveau end i tilfældet med faste vægte.\n", + "Efter optøning kan vi lave et par flere trænings-epoker (i vores eksempel laver vi kun én). Du kan også vælge en lavere læringsrate for at minimere påvirkningen på de fortrænede vægte. Dog kan du, selv med lav læringsrate, forvente, at nøjagtigheden falder i starten af træningen, indtil den til sidst når et lidt højere niveau end i tilfælde af faste vægte.\n", "\n", - "> **Bemærk:** Denne træning foregår meget langsommere, fordi vi skal propagere gradienter tilbage gennem mange lag i netværket!\n" + "> **Bemærk:** Denne træning sker meget langsommere, fordi vi skal propagere gradienter tilbage gennem mange lag af netværket!\n" ] }, { @@ -1028,18 +1039,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Vi vil sandsynligvis opnå en højere træningsnøjagtighed, fordi vi bruger et mere kraftfuldt netværk med flere parametre, men valideringsnøjagtigheden vil ikke stige lige så meget.\n", + "Vi vil sandsynligvis opnå en højere træningsnøjagtighed, fordi vi bruger et mere kraftfuldt netværk med flere parametre, men valideringsnøjagtigheden vil ikke stige lige så meget. \n", "\n", - "Du er velkommen til at frigøre et par flere lag af netværket og træne videre for at se, om du kan opnå en højere nøjagtighed!\n" + "Du er velkommen til at ophæve frysningen af et par flere lag i netværket og træne mere for at se, om du kan opnå en højere nøjagtighed! \n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Andre computervisionsmodeller\n", + "## Andre computervisningsmodeller\n", "\n", - "VGG-16 er en af de enkleste computervisionsarkitekturer. Keras tilbyder mange flere forudtrænede netværk. De mest anvendte blandt disse er **ResNet**-arkitekturer, udviklet af Microsoft, og **Inception** fra Google. For eksempel, lad os undersøge arkitekturen af den enkleste ResNet-50 model (ResNet er en familie af modeller med forskellig dybde, du kan prøve at eksperimentere med ResNet-152, hvis du vil se, hvordan en virkelig dyb model ser ud):\n" + "VGG-16 er en af de simpleste computervisningsarkitekturer. Keras tilbyder mange flere fortrænede netværk. Blandt de mest brugte er **ResNet**-arkitekturer, udviklet af Microsoft, og **Inception** af Google. For eksempel, lad os udforske arkitekturen af den simpleste ResNet-50 model (ResNet er en familie af modeller med forskellig dybde, du kan prøve at eksperimentere med ResNet-152, hvis du vil se, hvordan en virkelig dyb model ser ud):\n" ] }, { @@ -1441,29 +1452,29 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Som du kan se, indeholder modellen de samme velkendte byggesten: konvolutionslag, poolinglag og en endelig tæt klassifikator. Vi kan bruge denne model på præcis samme måde, som vi har brugt VGG-16 til transfer learning. Du kan prøve at eksperimentere med koden ovenfor, ved at bruge forskellige ResNet-modeller som basemodel, og se hvordan nøjagtigheden ændrer sig.\n", + "Som du kan se, indeholder modellen de samme velkendte byggesten: konvolutionslag, poolingslag og den endelige tætte klassifikator. Vi kan bruge denne model på præcis samme måde, som vi har brugt VGG-16 til transfer learning. Du kan prøve at eksperimentere med koden ovenfor ved at bruge forskellige ResNet-modeller som basismodellen og se, hvordan nøjagtigheden ændrer sig.\n", "\n", - "## Batch Normalisering\n", + "## Batch Normalization\n", "\n", - "Dette netværk indeholder endnu en type lag: **Batch Normalisering**. Ideen med batch normalisering er at bringe værdier, der flyder gennem det neurale netværk, til det rette interval. Normalt fungerer neurale netværk bedst, når alle værdier er i intervallet [-1,1] eller [0,1], og det er derfor, vi skalerer/normaliserer vores inputdata tilsvarende. Men under træning af et dybt netværk kan det ske, at værdierne kommer betydeligt uden for dette interval, hvilket gør træningen problematisk. Batch normaliseringslaget beregner gennemsnit og standardafvigelse for alle værdier i den aktuelle minibatch og bruger dem til at normalisere signalet, før det sendes gennem et neuralt netværkslag. Dette forbedrer stabiliteten af dybe netværk markant.\n" + "Dette netværk indeholder endnu en type lag: **Batch Normalization**. Ideen med batch normalisering er at bringe værdier, som flyder gennem det neurale netværk, til rette interval. Normalt fungerer neurale netværk bedst, når alle værdier er i intervallet [-1,1] eller [0,1], og det er grunden til, at vi skalerer/normaliserer vores inputdata tilsvarende. Dog kan det ske under træning af et dybt netværk, at værdier kommer betydeligt uden for dette interval, hvilket gør træningen problematisk. Batch normaliseringslag beregner gennemsnit og standardafvigelse for alle værdier i den aktuelle minibatch og bruger dem til at normalisere signalet, inden det sendes gennem et neuralt netværkslag. Dette forbedrer betydeligt stabiliteten af dybe netværk.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Vigtig pointe\n", + "## Erfaringer\n", "\n", - "Ved at bruge transfer learning kunne vi hurtigt sammensætte en klassifikator til vores opgave med klassificering af brugerdefinerede objekter og opnå høj nøjagtighed. Dog var dette eksempel ikke helt retfærdigt, da det oprindelige VGG-16-netværk var forudtrænet til at genkende katte og hunde, og vi genbrugte derfor de fleste af de mønstre, der allerede var til stede i netværket. Du kan forvente lavere nøjagtighed på mere eksotiske, domænespecifikke objekter, såsom detaljer på produktionslinjen i en fabrik eller forskellige træblade.\n", + "Ved at bruge transfer learning kunne vi hurtigt sammensætte en klassificeringsmodel til vores brugerdefinerede objektklassificeringsopgave og opnå høj nøjagtighed. Dog var dette eksempel ikke helt retfærdigt, fordi det oprindelige VGG-16-netværk var forudtrænet til at genkende katte og hunde, og derfor genbrugte vi blot de fleste af de mønstre, der allerede var til stede i netværket. Du kan forvente lavere nøjagtighed på mere eksotiske domænespecifikke objekter, såsom detaljer på en produktionslinje i en fabrik eller forskellige træs blade.\n", "\n", - "Du kan se, at mere komplekse opgaver, som vi løser nu, kræver højere computerkraft og ikke nemt kan løses på CPU'en. I næste enhed vil vi forsøge at bruge en mere letvægtsimplementering til at træne den samme model med lavere computerressourcer, hvilket resulterer i kun en lidt lavere nøjagtighed.\n" + "Du kan se, at mere komplekse opgaver, som vi løser nu, kræver højere beregningskraft og ikke let kan løses på CPU'en. I næste enhed vil vi prøve at bruge en mere letvægtsimplementering til at træne den samme model ved brug af færre beregningsressourcer, hvilket resulterer i kun en lidt lavere nøjagtighed. \n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "\n---\n\n**Ansvarsfraskrivelse**: \nDette dokument er blevet oversat ved hjælp af AI-oversættelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selvom vi bestræber os på at sikre nøjagtighed, skal det bemærkes, at automatiserede oversættelser kan indeholde fejl eller unøjagtigheder. Det originale dokument på dets oprindelige sprog bør betragtes som den autoritative kilde. For kritisk information anbefales professionel menneskelig oversættelse. Vi påtager os ikke ansvar for misforståelser eller fejltolkninger, der måtte opstå som følge af brugen af denne oversættelse.\n" + "---\n\n\n**Ansvarsfraskrivelse**:\nDette dokument er blevet oversat ved hjælp af AI-oversættelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selvom vi bestræber os på nøjagtighed, skal du være opmærksom på, at automatiserede oversættelser kan indeholde fejl eller unøjagtigheder. Det originale dokument på dets oprindelige sprog bør betragtes som den autoritative kilde. For kritisk information anbefales professionel menneskelig oversættelse. Vi påtager os intet ansvar for misforståelser eller fejltolkninger, der opstår som følge af brugen af denne oversættelse.\n\n" ] } ], @@ -1484,12 +1495,6 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.10" - }, - "coopTranslator": { - "original_hash": "c189abc107848f96051085cc30945129", - "translation_date": "2025-08-28T16:29:42+00:00", - "source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb", - "language_code": "da" } }, "nbformat": 4, diff --git a/translations/da/lessons/5-NLP/README.md b/translations/da/lessons/5-NLP/README.md index d9d6b46e..9c0fef65 100644 --- a/translations/da/lessons/5-NLP/README.md +++ b/translations/da/lessons/5-NLP/README.md @@ -1,51 +1,51 @@ -# Naturlig Sprogbehandling +# Naturlig Sprogbearbejdning ![Oversigt over NLP-opgaver i en doodle](../../../../translated_images/da/ai-nlp.b22dcb8ca4707cea.webp) -I denne sektion vil vi fokusere på at bruge neurale netværk til at håndtere opgaver relateret til **naturlig sprogbehandling (NLP)**. Der er mange NLP-problemer, som vi ønsker, at computere skal kunne løse: +I denne sektion vil vi fokusere på at bruge Neurale Netværk til at håndtere opgaver relateret til **Naturlig Sprogbearbejdning (NLP)**. Der er mange NLP-problemer, som vi ønsker, at computere skal kunne løse: -* **Tekstklassifikation** er et typisk klassifikationsproblem, der vedrører tekstsekvenser. Eksempler inkluderer at klassificere e-mails som spam vs. ikke-spam eller kategorisere artikler som sport, erhverv, politik osv. Når vi udvikler chatbots, har vi ofte brug for at forstå, hvad en bruger ønskede at sige – i dette tilfælde arbejder vi med **intentionklassifikation**. Ofte skal vi i intentionklassifikation håndtere mange kategorier. -* **Sentimentanalyse** er et typisk regressionsproblem, hvor vi skal tildele et tal (et sentiment), der svarer til, hvor positivt/negativt betydningen af en sætning er. En mere avanceret version af sentimentanalyse er **aspektbaseret sentimentanalyse** (ABSA), hvor vi tilskriver sentiment ikke til hele sætningen, men til forskellige dele af den (aspekter), fx *På denne restaurant kunne jeg godt lide maden, men atmosfæren var forfærdelig*. -* **Genkendelse af navngivne entiteter** (NER) refererer til problemet med at udtrække visse entiteter fra tekst. For eksempel kan vi have brug for at forstå, at i sætningen *Jeg skal flyve til Paris i morgen* refererer ordet *i morgen* til en DATO, og *Paris* er en LOKATION. -* **Nøgleordsudtrækning** ligner NER, men her skal vi automatisk udtrække ord, der er vigtige for sætningens betydning, uden forudgående træning for specifikke entitetstyper. -* **Tekstgruppering** kan være nyttigt, når vi vil samle lignende sætninger, for eksempel lignende forespørgsler i tekniske support-samtaler. -* **Spørgsmål-besvarelse** refererer til en models evne til at besvare et specifikt spørgsmål. Modellen modtager et tekstafsnit og et spørgsmål som input og skal angive et sted i teksten, hvor svaret på spørgsmålet findes (eller nogle gange generere selve svaret). -* **Tekstgenerering** er en models evne til at generere ny tekst. Det kan betragtes som en klassifikationsopgave, der forudsiger næste bogstav/ord baseret på en *tekstprompt*. Avancerede tekstgenereringsmodeller, såsom GPT-3, er i stand til at løse andre NLP-opgaver som klassifikation ved hjælp af en teknik kaldet [prompt-programmering](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) eller [prompt-engineering](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29). -* **Tekstsammenfatning** er en teknik, hvor vi ønsker, at en computer skal "læse" en lang tekst og opsummere den i få sætninger. -* **Maskinoversættelse** kan ses som en kombination af tekstforståelse på ét sprog og tekstgenerering på et andet. +* **Tekstklassifikation** er et typisk klassifikationsproblem vedrørende tekstsekvenser. Eksempler inkluderer klassificering af e-mails som spam vs. ikke-spam eller kategorisering af artikler som sport, erhverv, politik osv. Også når vi udvikler chatbots, har vi ofte behov for at forstå, hvad en bruger ønskede at sige – i dette tilfælde arbejder vi med **intentionklassifikation**. Ofte er der i intentionklassifikation mange kategorier. +* **Følelsesanalyse** er et typisk regressionsproblem, hvor vi skal tildele et tal (en følelse) svarende til, hvor positiv/negativ meningen med en sætning er. En mere avanceret version af følelsesanalyse er **aspektbaseret følelsesanalyse** (ABSA), hvor vi tilskriver følelser ikke til hele sætningen, men til forskellige dele af den (aspekter), fx *På denne restaurant kunne jeg lide køkkenet, men atmosfæren var forfærdelig*. +* **Navngiven Entitetsgenkendelse** (NER) henviser til problemet med at udtrække bestemte enheder fra tekst. For eksempel skal vi måske forstå, at i sætningen *Jeg skal flyve til Paris i morgen* henviser ordet *i morgen* til DATO, og *Paris* er en LOKATION. +* **Nøgleordsudtrækning** minder om NER, men vi skal automatisk udtrække ord, der er vigtige for meningen i sætningen, uden forudgående træning for specifikke entitetstyper. +* **Tekstklyngedannelse** kan være nyttigt, når vi vil gruppere lignende sætninger sammen, for eksempel lignende forespørgsler i teknisk support-samtaler. +* **Spørgsmålsbesvarelse** refererer til en models evne til at svare på et specifikt spørgsmål. Modellen modtager et tekstuddrag og et spørgsmål som input, og den skal angive et sted i teksten, hvor svaret på spørgsmålet findes (eller nogle gange generere svaret i tekst). +* **Tekstgenerering** er en models evne til at generere ny tekst. Det kan betragtes som en klassifikationsopgave, der forudsiger næste bogstav/ord baseret på en *tekstprompt*. Avancerede tekstgenereringsmodeller, som GPT-3, kan løse andre NLP-opgaver såsom klassifikation ved hjælp af en teknik kaldet [prompt programming](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) eller [prompt engineering](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29) +* **Tekstopsummering** er en teknik, hvor vi ønsker, at en computer "læser" lang tekst og sammenfatter den i et par sætninger. +* **Maskinoversættelse** kan ses som en kombination af tekstforståelse på et sprog og tekstgenerering på et andet. -Oprindeligt blev de fleste NLP-opgaver løst ved hjælp af traditionelle metoder som grammatikker. For eksempel blev der i maskinoversættelse brugt parsere til at transformere den oprindelige sætning til et syntakstræ, hvorefter højere niveau semantiske strukturer blev udtrukket for at repræsentere sætningens betydning. Baseret på denne betydning og grammatikken for målsproget blev resultatet genereret. I dag løses mange NLP-opgaver mere effektivt ved hjælp af neurale netværk. +Oprindeligt blev de fleste NLP-opgaver løst ved hjælp af traditionelle metoder såsom grammatikker. For eksempel blev parsere brugt i maskinoversættelse til at omdanne den oprindelige sætning til et syntakstræ, derefter blev højere niveau semantiske strukturer udtrukket for at repræsentere sætningens betydning, og baseret på denne betydning og målsprogets grammatik blev resultatet genereret. I dag bliver mange NLP-opgaver mere effektivt løst ved hjælp af neurale netværk. -> Mange klassiske NLP-metoder er implementeret i [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org) Python-biblioteket. Der findes en fremragende [NLTK-bog](https://www.nltk.org/book/), der er tilgængelig online og dækker, hvordan forskellige NLP-opgaver kan løses ved hjælp af NLTK. +> Mange klassiske NLP-metoder er implementeret i [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org) Python-bibliotek. Der findes en fremragende [NLTK-bog](https://www.nltk.org/book/) online, som dækker, hvordan forskellige NLP-opgaver kan løses ved hjælp af NLTK. -I dette kursus vil vi primært fokusere på at bruge neurale netværk til NLP, og vi vil bruge NLTK, hvor det er nødvendigt. +I vores kursus vil vi primært fokusere på brugen af neurale netværk til NLP, og vi vil bruge NLTK hvor det er nødvendigt. -Vi har allerede lært at bruge neurale netværk til at håndtere tabeldata og billeder. Den største forskel mellem disse datatyper og tekst er, at tekst er en sekvens af variabel længde, mens inputstørrelsen i tilfælde af billeder er kendt på forhånd. Mens konvolutionsnetværk kan udtrække mønstre fra inputdata, er mønstre i tekst mere komplekse. For eksempel kan negation være adskilt fra subjektet med mange ord (fx *Jeg kan ikke lide appelsiner* vs. *Jeg kan ikke lide de store farverige lækre appelsiner*), og det skal stadig fortolkes som ét mønster. Derfor har vi brug for nye typer neurale netværk, såsom *rekurrente netværk* og *transformere*, for at håndtere sprog. +Vi har allerede lært om brug af neurale netværk til at håndtere tabeldata og billeder. Den største forskel mellem disse datatyper og tekst er, at tekst er en sekvens med variabel længde, mens inputstørrelsen i tilfælde af billeder er kendt på forhånd. Mens konvolutionsnetværk kan udtrække mønstre fra inputdata, er mønstrene i tekst mere komplekse. Fx kan negation være adskilt fra subjektet med et vilkårligt antal ord (fx *Jeg kan ikke lide appelsiner* vs. *Jeg kan ikke lide de store farverige lækre appelsiner*), og det skal stadig fortolkes som ét mønster. Derfor skal vi for at håndtere sprog introducere nye typer neurale netværk, såsom *recurrent networks* og *transformers*. -## Installation af biblioteker +## Installer Biblioteker -Hvis du bruger en lokal Python-installation til at køre dette kursus, skal du muligvis installere alle nødvendige biblioteker til NLP ved hjælp af følgende kommandoer: +Hvis du bruger en lokal Python-installation til at køre dette kursus, kan du have behov for at installere alle nødvendige biblioteker til NLP ved hjælp af følgende kommandoer: -**For PyTorch** +**For PyTorch** ```bash -pip install -r requirements-torch.txt -``` -**For TensorFlow** +pip install -r requirements-pytorch.txt +``` +**For TensorFlow** ```bash pip install -r requirements-tf.txt -``` +``` > Du kan prøve NLP med TensorFlow på [Microsoft Learn](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-tensorflow/?WT.mc_id=academic-77998-cacaste) ## GPU-advarsel I denne sektion vil vi i nogle af eksemplerne træne ret store modeller. -* **Brug en GPU-aktiveret computer**: Det anbefales at køre dine notebooks på en GPU-aktiveret computer for at reducere ventetiden, når du arbejder med store modeller. -* **GPU-hukommelsesbegrænsninger**: Kørsel på en GPU kan føre til situationer, hvor du løber tør for GPU-hukommelse, især når du træner store modeller. -* **GPU-hukommelsesforbrug**: Mængden af GPU-hukommelse, der forbruges under træning, afhænger af forskellige faktorer, herunder minibatch-størrelsen. -* **Minimer minibatch-størrelse**: Hvis du oplever GPU-hukommelsesproblemer, kan du overveje at reducere minibatch-størrelsen i din kode som en mulig løsning. -* **TensorFlow GPU-hukommelsesfrigivelse**: Ældre versioner af TensorFlow frigiver muligvis ikke GPU-hukommelse korrekt, når der trænes flere modeller inden for én Python-kerne. For at håndtere GPU-hukommelsesforbrug effektivt kan du konfigurere TensorFlow til kun at allokere GPU-hukommelse efter behov. -* **Inklusion af kode**: For at indstille TensorFlow til kun at øge GPU-hukommelsesallokering, når det er nødvendigt, skal du inkludere følgende kode i dine notebooks: +* **Brug en computer med GPU**: Det anbefales at køre dine notebooks på en computer med GPU for at reducere ventetider, når du arbejder med store modeller. +* **Begrænsninger i GPU-hukommelsen**: Kørsel på en GPU kan føre til situationer, hvor du løber tør for GPU-hukommelse, især ved træning af store modeller. +* **GPU-hukommelsesforbrug**: Mængden af GPU-hukommelse, der forbruges under træning, afhænger af forskellige faktorer, inklusive minibatch-størrelse. +* **Minimer minibatch-størrelse**: Hvis du oplever problemer med GPU-hukommelsen, kan du overveje at reducere minibatch-størrelsen i din kode som en mulig løsning. +* **TensorFlow GPU-hukommelsesfrigivelse**: Ældre versioner af TensorFlow frigiver muligvis ikke GPU-hukommelse korrekt, når flere modeller trænes inden for én Python-kerne. For at håndtere GPU-hukommelsesforbrug effektivt kan du konfigurere TensorFlow til kun at allokere GPU-hukommelse efter behov. +* **Kodeinklusion**: For at sætte TensorFlow til at øge GPU-hukommelsesallokering kun efter behov, inkluder følgende kode i dine notebooks: ```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) ``` -Hvis du er interesseret i at lære om NLP fra et klassisk ML-perspektiv, kan du besøge [denne samling af lektioner](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP). +Hvis du er interesseret i at lære om NLP fra et klassisk ML-perspektiv, besøg [dette sæt af lektioner](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP) ## I denne sektion I denne sektion vil vi lære om: -* [Repræsentation af tekst som tensorer](13-TextRep/README.md) -* [Ordindlejringer](14-Emdeddings/README.md) -* [Sproglig modellering](15-LanguageModeling/README.md) -* [Rekurrente neurale netværk](16-RNN/README.md) -* [Generative netværk](17-GenerativeNetworks/README.md) -* [Transformere](18-Transformers/README.md) +* [At repræsentere tekst som tensors](13-TextRep/README.md) +* [Word Embeddings](14-Emdeddings/README.md) +* [Sprogsmodellering](15-LanguageModeling/README.md) +* [Recurrent Neural Networks](16-RNN/README.md) +* [Generative Networks](17-GenerativeNetworks/README.md) +* [Transformers](18-Transformers/README.md) --- -**Ansvarsfraskrivelse**: -Dette dokument er blevet oversat ved hjælp af AI-oversættelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selvom vi bestræber os på nøjagtighed, skal du være opmærksom på, at automatiserede oversættelser kan indeholde fejl eller unøjagtigheder. Det originale dokument på dets oprindelige sprog bør betragtes som den autoritative kilde. For kritisk information anbefales professionel menneskelig oversættelse. Vi er ikke ansvarlige for eventuelle misforståelser eller fejltolkninger, der opstår som følge af brugen af denne oversættelse. \ No newline at end of file + +**Ansvarsfraskrivelse**: +Dette dokument er blevet oversat ved hjælp af AI-oversættelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selvom vi bestræber os på nøjagtighed, skal du være opmærksom på, at automatiserede oversættelser kan indeholde fejl eller unøjagtigheder. Det originale dokument på dets oprindelige sprog bør betragtes som den autoritative kilde. For kritisk information anbefales professionel menneskelig oversættelse. Vi påtager os intet ansvar for misforståelser eller fejltolkninger, der opstår som følge af brugen af denne oversættelse. + \ No newline at end of file diff --git a/translations/sv/.co-op-translator.json b/translations/sv/.co-op-translator.json index 93e0530a..ce7bb3e4 100644 --- a/translations/sv/.co-op-translator.json +++ b/translations/sv/.co-op-translator.json @@ -5,6 +5,12 @@ "source_file": "AGENTS.md", "language_code": "sv" }, + "CONTRIBUTING.md": { + "original_hash": "c6fd7e781b67111a90abd166d0ce4aa0", + "translation_date": "2026-07-08T18:04:00+00:00", + "source_file": "CONTRIBUTING.md", + "language_code": "sv" + }, "README.md": { "original_hash": "12c8eb6bf0867d2f1c32daf613ac5b8b", "translation_date": "2026-04-06T16:23:14+00:00", @@ -17,6 +23,19 @@ "source_file": "SECURITY.md", "language_code": "sv" }, + "__translation_failures__": { + "lessons/sketchnotes/LICENSE.md": { + "original_hash": "45ab63a2cd8f5faef6c9b150618837a4", + "source_file": "lessons/sketchnotes/LICENSE.md", + "language_code": "sv", + "failure_date": "2026-07-08T17:57:55+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-28T16:06:50+00:00", @@ -54,8 +73,8 @@ "language_code": "sv" }, "examples/README.md": { - "original_hash": "0d1babfdcbeb46525f2db3fbaaa54cd7", - "translation_date": "2025-10-03T11:31:15+00:00", + "original_hash": "7883d52c2e2a221e0b07a7b112a149b9", + "translation_date": "2026-07-08T17:52:33+00:00", "source_file": "examples/README.md", "language_code": "sv" }, @@ -66,8 +85,8 @@ "language_code": "sv" }, "lessons/0-course-setup/how-to-run.md": { - "original_hash": "a4717bd9103b9f6cd84d534b83534689", - "translation_date": "2026-01-16T02:22:35+00:00", + "original_hash": "7ad8c7d8604c53649b3d4d1e2f3a6fa1", + "translation_date": "2026-07-08T17:52:58+00:00", "source_file": "lessons/0-course-setup/how-to-run.md", "language_code": "sv" }, @@ -191,6 +210,12 @@ "source_file": "lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md", "language_code": "sv" }, + "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb": { + "original_hash": "99b816b6a4957ef4100cee4c4221dff9", + "translation_date": "2026-07-08T17:44:25+00:00", + "source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb", + "language_code": "sv" + }, "lessons/4-ComputerVision/08-TransferLearning/lab/README.md": { "original_hash": "7765935c35fcee69b9fe2d0cfd6963e2", "translation_date": "2025-08-28T15:17:45+00:00", @@ -330,8 +355,8 @@ "language_code": "sv" }, "lessons/5-NLP/README.md": { - "original_hash": "8ef02a9318257ea140ed3ed74442096d", - "translation_date": "2025-08-28T15:50:08+00:00", + "original_hash": "038df6f1a73e49f6430740da083bfd6d", + "translation_date": "2026-07-08T17:53:29+00:00", "source_file": "lessons/5-NLP/README.md", "language_code": "sv" }, diff --git a/translations/sv/CONTRIBUTING.md b/translations/sv/CONTRIBUTING.md new file mode 100644 index 00000000..feaa374d --- /dev/null +++ b/translations/sv/CONTRIBUTING.md @@ -0,0 +1,29 @@ +# Bidra till AI-For-Beginners + +Tack för ditt intresse att bidra till AI-For-Beginners! Vi välkomnar översättningar, lektionfixar och korrigeringar av formatering. + +## Microsoft Contributor License Agreement (CLA) + +Det här projektet välkomnar bidrag och förslag. De flesta bidrag kräver att du godkänner ett Contributor License Agreement (CLA) där du intygar att du har rätt att, och faktiskt ger oss rättigheterna att använda ditt bidrag. För detaljer, besök [https://cla.microsoft.com](https://cla.microsoft.com). + +När du skickar en pull-begäran kommer en CLA-bot automatiskt avgöra om du behöver lämna en CLA och märka PR på lämpligt sätt (t.ex. etikett, kommentar). Följ bara instruktionerna från boten. Du behöver bara göra detta en gång för alla förvar som använder vår CLA. + +## Hur man bidrar + +### 1. Rätta stavfel / kodfel +Om du hittar ett stavfel eller bugg i någon Jupyter-notebook eller lektionens markdown-fil: +1. Fork:a förvaret. +2. Rätta stavfelet eller den brutna länken. +3. Skicka en Pull Request med en tydlig beskrivning av rättelsen. + +### 2. Skicka in översättningar +Vi välkomnar översättningar av lektionerna till andra språk! Placera översättningarna i katalogen `translations/` med de befintliga mappnamnen där (till exempel `translations/es/`, `translations/pt-BR/`, `translations/zh-CN/`). + +För mer information, se [etc/CONTRIBUTING.md](etc/CONTRIBUTING.md). + +--- + + +**Ansvarsfriskrivning**: +Detta dokument har översatts med hjälp av AI-översättningstjänsten [Co-op Translator](https://github.com/Azure/co-op-translator). Även om vi strävar efter noggrannhet, var vänlig notera att automatiska översättningar kan innehålla fel eller brister. Det ursprungliga dokumentet på dess modersmål bör betraktas som den auktoritativa källan. För kritisk information rekommenderas professionell mänsklig översättning. Vi ansvarar inte för några missförstånd eller feltolkningar som uppstår till följd av användningen av denna översättning. + \ No newline at end of file diff --git a/translations/sv/examples/README.md b/translations/sv/examples/README.md index ccb060ac..b025ed5b 100644 --- a/translations/sv/examples/README.md +++ b/translations/sv/examples/README.md @@ -1,31 +1,31 @@ # Nybörjarvänliga AI-exempel -Välkommen! Den här katalogen innehåller enkla, fristående exempel för att hjälpa dig komma igång med AI och maskininlärning. Varje exempel är utformat för att vara nybörjarvänligt med detaljerade kommentarer och steg-för-steg-förklaringar. +Välkommen! Denna katalog innehåller enkla, fristående exempel för att hjälpa dig komma igång med AI och maskininlärning. Varje exempel är utformat för att vara nybörjarvänligt med detaljerade kommentarer och steg-för-steg-förklaringar. -## 📚 Översikt över exempel +## 📚 Exempelöversikt | Exempel | Beskrivning | Svårighetsgrad | Förkunskaper | -|---------|-------------|----------------|--------------| -| [Hello AI World](../../../examples/01-hello-ai-world.py) | Ditt första AI-program - enkel mönsterigenkänning | ⭐ Nybörjare | Grundläggande Python | -| [Simple Neural Network](../../../examples/02-simple-neural-network.py) | Bygg ett neuralt nätverk från grunden | ⭐⭐ Nybörjare+ | Python, grundläggande matematik | -| [Image Classifier](./03-image-classifier.ipynb) | Klassificera bilder med en förtränad modell | ⭐⭐ Nybörjare+ | Python, numpy | -| [Text Sentiment](../../../examples/04-text-sentiment.py) | Analysera textens sentiment (positivt/negativt) | ⭐⭐ Nybörjare+ | Python | +|---------|-------------|------------|---------------| +| [Hello AI World](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/01-hello-ai-world.py) | Ditt första AI-program - enkel mönsterigenkänning | ⭐ Nybörjare | Grundläggande Python | +| [Simple Neural Network](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/02-simple-neural-network.py) | Bygg ett neuralt nätverk från grunden | ⭐⭐ Nybörjare+ | Python, grundläggande matematik | +| [Image Classifier](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/03-image-classifier.ipynb) | Klassificera bilder med en förtränad modell | ⭐⭐ Nybörjare+ | Python, numpy | +| [Text Sentiment](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/04-text-sentiment.py) | Analysera textens känsloläge (positiv/negativ) | ⭐⭐ Nybörjare+ | Python | ## 🚀 Kom igång ### Förkunskaper -Se till att du har Python installerat (version 3.8 eller högre rekommenderas). Installera nödvändiga paket: +Se till att du har Python installerat (3.8 eller högre rekommenderas). Installera nödvändiga paket: ```bash -# For Python scripts +# För Python-skript pip install numpy -# For Jupyter notebooks (image classifier) +# För Jupyter-notebooks (bildklassificerare) pip install jupyter numpy pillow tensorflow ``` -Eller använd conda-miljön från huvudkursplanen: +Eller använd conda-miljön från huvudkursen: ```bash conda env create --name ai4beg --file ../environment.yml @@ -44,25 +44,25 @@ python 01-hello-ai-world.py jupyter notebook 03-image-classifier.ipynb ``` -## 📖 Lärandebana +## 📖 Lärväg -Vi rekommenderar att du följer exemplen i ordning: +Vi rekommenderar att följa exemplen i ordning: 1. **Börja med "Hello AI World"** - Lär dig grunderna i mönsterigenkänning 2. **Bygg ett enkelt neuralt nätverk** - Förstå hur neurala nätverk fungerar -3. **Testa bildklassificeraren** - Se AI i praktiken med riktiga bilder -4. **Analysera textens sentiment** - Utforska naturlig språkbehandling +3. **Testa bildklassificeraren** - Se AI i arbete med riktiga bilder +4. **Analysera textens känsloläge** - Utforska naturlig språkbehandling ## 💡 Tips för nybörjare - **Läs kodkommentarerna noggrant** - De förklarar vad varje rad gör - **Experimentera!** - Prova att ändra värden och se vad som händer -- **Oroa dig inte för att förstå allt direkt** - Lärande tar tid +- **Oroa dig inte för att förstå allt** - Inlärning tar tid - **Ställ frågor** - Använd [Diskussionsforumet](https://github.com/microsoft/AI-For-Beginners/discussions) ## 🔗 Nästa steg -Efter att ha slutfört dessa exempel, utforska hela kursplanen: +När du har gått igenom dessa exempel, utforska hela kursplanen: - [Introduktion till AI](../lessons/1-Intro/README.md) - [Neurala nätverk](../lessons/3-NeuralNetworks/README.md) - [Datorseende](../lessons/4-ComputerVision/README.md) @@ -70,16 +70,18 @@ Efter att ha slutfört dessa exempel, utforska hela kursplanen: ## 🤝 Bidra -Tyckte du att dessa exempel var hjälpsamma? Hjälp oss att förbättra dem: +Tyckte du att dessa exempel var hjälpsamma? Hjälp oss förbättra dem: - Rapportera problem eller föreslå förbättringar - Lägg till fler exempel för nybörjare - Förbättra dokumentation och kommentarer --- -*Kom ihåg: Varje expert var en gång nybörjare. Lycka till med lärandet! 🎓* +*Kom ihåg: Varje expert har en gång varit nybörjare. Lycka till med lärandet! 🎓* --- -**Ansvarsfriskrivning**: -Detta dokument har översatts med hjälp av AI-översättningstjänsten [Co-op Translator](https://github.com/Azure/co-op-translator). Även om vi strävar efter noggrannhet, bör det noteras att automatiska översättningar kan innehålla fel eller felaktigheter. Det ursprungliga dokumentet på dess originalspråk bör betraktas som den auktoritativa källan. För kritisk information rekommenderas professionell mänsklig översättning. Vi ansvarar inte för eventuella missförstånd eller feltolkningar som uppstår vid användning av denna översättning. \ No newline at end of file + +**Ansvarsfriskrivning**: +Detta dokument har översatts med hjälp av AI-översättningstjänsten [Co-op Translator](https://github.com/Azure/co-op-translator). Även om vi strävar efter noggrannhet, var vänlig notera att automatiska översättningar kan innehålla fel eller brister. Det ursprungliga dokumentet på dess modersmål bör betraktas som den auktoritativa källan. För kritisk information rekommenderas professionell mänsklig översättning. Vi ansvarar inte för några missförstånd eller feltolkningar som uppstår till följd av användningen av denna översättning. + \ No newline at end of file diff --git a/translations/sv/lessons/0-course-setup/how-to-run.md b/translations/sv/lessons/0-course-setup/how-to-run.md index a3701216..dec7017d 100644 --- a/translations/sv/lessons/0-course-setup/how-to-run.md +++ b/translations/sv/lessons/0-course-setup/how-to-run.md @@ -1,12 +1,12 @@ # Hur man kör koden -Detta kursmaterial innehåller många exekverbara exempel och labbar som du vill köra. För att göra detta behöver du möjligheten att köra Python-kod i Jupyter Notebook-filer som tillhandahålls som en del av detta kursmaterial. Du har flera alternativ för att köra koden: +Denna kursplan innehåller många körbara exempel och laborationer som du vill köra. För att göra detta behöver du möjligheten att köra Python-kod i Jupyter Notebooks som tillhandahålls som en del av denna kurs. Du har flera alternativ för att köra koden: ## Kör lokalt på din dator -För att köra koden lokalt på din dator behövs en Python-installation. Ett rekommenderat alternativ är att installera **[miniconda](https://conda.io/en/latest/miniconda.html)** – det är en ganska lätt installation som stöder `conda` paketförvaltaren för olika Python **virtuella miljöer**. +För att köra koden lokalt på din dator behövs en Python-installation. Ett rekommenderat alternativ är att installera **[miniconda](https://conda.io/en/latest/miniconda.html)** – det är en ganska lätt installation som stöder `conda` paket hanterare för olika Python **virtuella miljöer**. -Efter att du installerat miniconda, klona repot och skapa en virtuell miljö som ska användas för denna kurs: +Efter att du installerat miniconda, klona repositoryt och skapa en virtuell miljö som ska användas för denna kurs: ```bash git clone http://github.com/microsoft/ai-for-beginners @@ -17,55 +17,55 @@ conda activate ai4beg ### Använda Visual Studio Code med Python Extension -Detta kursmaterial används bäst när du öppnar det i [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) med [Python Extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste). +Denna kursplan används bäst när du öppnar den i [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) med [Python Extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste). -> **Notera**: När du klonar och öppnar katalogen i VS Code kommer det automatiskt att föreslå att du installerar Python extensions. Du behöver också installera miniconda som beskrivs ovan. +> **Obs**: När du har klonat och öppnat katalogen i VS Code kommer det automatiskt att föreslå att du installerar Python-tillägg. Du måste också installera miniconda som beskrivs ovan. -> **Notera**: Om VS Code föreslår att du öppnar repot i en container bör du tacka nej till detta för att kunna använda den lokala Python-installationen. +> **Obs**: Om VS Code föreslår att du öppnar repositoryt igen i en container bör du tacka nej till detta för att kunna använda den lokala Python-installationen. ### Använda Jupyter i webbläsaren -Du kan också använda en Jupyter-miljö från webbläsaren på din egen dator. Både klassisk Jupyter och JupyterHub erbjuder en bekväm utvecklingsmiljö med automatiskt slutförande, kodmarkering med mera. +Du kan också använda en Jupyter-miljö från webbläsaren på din egen dator. Både klassisk Jupyter och JupyterHub erbjuder en bekväm utvecklingsmiljö med automatisk komplettering, kodmarkering etc. För att starta Jupyter lokalt, gå till kurskatalogen och kör: ```bash jupyter notebook ``` - eller +eller ```bash jupyterhub ``` -Du kan därefter navigera till vilken `.ipynb`-fil som helst, öppna dem och börja arbeta. +Du kan sedan navigera till valfri `.ipynb`-fil, öppna den och börja arbeta. ### Köra i container -Ett alternativ till Python-installation är att köra koden i en container. Eftersom vårt repo tillhandahåller en speciell `.devcontainer`-mapp som visar hur man bygger en container för detta repo, erbjuder VS Code möjligheten att öppna koden i en container. Detta kräver att Docker är installerat och är också mer komplext, så vi rekommenderar detta för mer erfarna användare. +Ett alternativ till Python-installation är att köra koden i en container. Eftersom vårt repository innehåller en speciell `.devcontainer`-mapp som instruerar hur man bygger en container för detta repo, erbjuder VS Code möjligheten att öppna koden i en container. Detta kräver Docker-installation och är mer komplext, så vi rekommenderar detta för mer erfarna användare. ## Köra i molnet Om du inte vill installera Python lokalt och har tillgång till molnresurser är ett bra alternativ att köra koden i molnet. Det finns flera sätt att göra detta: -* Använd **[GitHub Codespaces](https://github.com/features/codespaces)**, som är en virtuell miljö skapad för dig på GitHub, tillgänglig genom ett VS Code-webbinslag. Om du har tillgång till Codespaces kan du bara klicka på **Code**-knappen i repot, starta ett codespace och komma igång snabbt. -* Använd **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) erbjuder gratis datorresurser i molnet för personer som du att testa kod på GitHub. Det finns en knapp på startsidan för att öppna repot i Binder – detta tar dig snabbt till binder-sidan, som bygger en underliggande container och startar ett Jupyter-webbgränssnitt för dig sömlöst. +* Använd **[GitHub Codespaces](https://github.com/features/codespaces)**, vilket är en virtuell miljö skapad för dig på GitHub, tillgänglig via ett VS Code webbläsargränssnitt. Om du har tillgång till Codespaces kan du bara klicka på **Code**-knappen i repo, starta en codespace och komma igång på nolltid. +* Använd **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) erbjuder gratis datorkraft i molnet för personer som du att testa kod från GitHub. Det finns en knapp på framsidan för att öppna repositoryt i Binder – detta tar dig snabbt till binder-webbplatsen, som bygger en underliggande container och startar ett Jupyter webgränssnitt för dig sömlöst. -> **Notera**: För att förhindra missbruk har Binder blockerat tillgång till vissa webbresurser. Detta kan förhindra att viss kod, som hämtar modeller och/eller dataset från det offentliga internet, fungerar. Du kan behöva hitta lösningar. Dessutom är datorresurser som tillhandahålls av Binder ganska enkla, så träningen kan gå långsamt, särskilt i senare, mer komplexa lektioner. +> **Obs**: För att förhindra missbruk har Binder blockerat åtkomst till vissa webbresurser. Detta kan hindra vissa delar av koden från att fungera, särskilt de som hämtar modeller och/eller dataset från det offentliga Internet. Du kan behöva hitta några lösningar. Dessutom är de datorkraftresurser som Binder tillhandahåller ganska grundläggande, så träning kommer att vara långsam, särskilt i senare och mer komplexa lektioner. ## Köra i molnet med GPU -Några av de senare lektionerna i detta kursmaterial skulle ha stor nytta av GPU-stöd. Modellträning kan till exempel vara smärtsamt långsam annars. Det finns några alternativ du kan följa, särskilt om du har tillgång till molnet antingen via [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste) eller via din institution: +Vissa av de senare lektionerna i denna kursplan skulle ha stor nytta av GPU-stöd. Modellträning, till exempel, kan vara smärtsamt långsam annars. Det finns några alternativ du kan följa, särskilt om du har tillgång till molnet antingen via [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste) eller via din institution: -* Skapa [Data Science Virtual Machine](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) och anslut till den via Jupyter. Du kan sedan klona repot direkt på maskinen och börja lära dig. NC-seriens virtuella maskiner har GPU-stöd. +* Skapa [Data Science Virtual Machine](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) och anslut till den via Jupyter. Du kan då klona repo direkt på maskinen och börja lära dig. NC-seriens VM:er har GPU-stöd. -> **Notera**: Vissa prenumerationer, inklusive Azure for Students, ger inte GPU-stöd från början. Du kan behöva begära extra GPU-kärnor med ett tekniskt supportärende. +> **Obs**: Vissa prenumerationer, inklusive Azure for Students, erbjuder inte GPU-stöd direkt. Du kan behöva begära extra GPU-kärnor med en teknisk supportförfrågan. -* Skapa [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) och använd sedan Notebooks-funktionen där. [Den här videon](https://azure-for-academics.github.io/quickstart/azureml-papers/) visar hur man klonar ett repo till en Azure ML Notebook och börjar använda det. +* Skapa [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) och använd sedan Notebook-funktionen där. [Denna video](https://azure-for-academics.github.io/quickstart/azureml-papers/) visar hur man klonar ett repository till Azure ML-notebook och börjar använda det. -Du kan också använda Google Colab, som har visst gratis GPU-stöd, och ladda upp Jupyter Notebook-filer där för att exekvera dem en i taget. +Du kan också använda Google Colab, som har viss gratis GPU-stöd, och ladda upp Jupyter Notebooks där för att köra dem en efter en. --- **Ansvarsfriskrivning**: -Detta dokument har översatts med hjälp av AI-översättningstjänsten [Co-op Translator](https://github.com/Azure/co-op-translator). Även om vi strävar efter noggrannhet, vänligen var medveten om att automatiska översättningar kan innehålla fel eller brister. Det ursprungliga dokumentet på dess originalspråk bör betraktas som den auktoritativa källan. För kritisk information rekommenderas professionell mänsklig översättning. Vi ansvarar inte för eventuella missförstånd eller feltolkningar som uppstår från användningen av denna översättning. +Detta dokument har översatts med hjälp av AI-översättningstjänsten [Co-op Translator](https://github.com/Azure/co-op-translator). Även om vi strävar efter noggrannhet, var vänlig notera att automatiska översättningar kan innehålla fel eller brister. Det ursprungliga dokumentet på dess modersmål bör betraktas som den auktoritativa källan. För kritisk information rekommenderas professionell mänsklig översättning. Vi ansvarar inte för några missförstånd eller feltolkningar som uppstår till följd av användningen av denna översättning. \ No newline at end of file diff --git a/translations/sv/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb b/translations/sv/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb index cefdab02..c05e8e04 100644 --- a/translations/sv/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb +++ b/translations/sv/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb @@ -4,11 +4,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Förtränade modeller och transfer learning\n", + "# Förtränade modeller och överföringsinlärning\n", "\n", - "Att träna CNN:er kan ta mycket tid, och det krävs en stor mängd data för den uppgiften. Dock går mycket av tiden åt till att lära sig de bästa låg-nivåfiltren som ett nätverk använder för att extrahera mönster från bilder. En naturlig fråga uppstår - kan vi använda ett neuralt nätverk som tränats på en dataset och anpassa det för att klassificera andra bilder utan att genomgå hela träningsprocessen?\n", + "Att träna CNN:er kan ta mycket tid, och mycket data krävs för den uppgiften. Dock spenderas mycket tid på att lära sig de bästa låg-nivå filtren som ett nätverk använder för att extrahera mönster från bilder. En naturlig fråga uppstår – kan vi använda ett neuralt nätverk tränat på en datamängd och anpassa det till att klassificera olika bilder utan att behöva träna det från början?\n", "\n", - "Denna metod kallas **transfer learning**, eftersom vi överför viss kunskap från en modell av ett neuralt nätverk till ett annat. Vid transfer learning börjar vi vanligtvis med en förtränad modell, som har tränats på en stor bilddataset, såsom **ImageNet**. Dessa modeller är redan bra på att extrahera olika funktioner från generiska bilder, och i många fall kan det räcka att bygga en klassificerare ovanpå dessa extraherade funktioner för att uppnå ett bra resultat.\n" + "Detta tillvägagångssätt kallas **överföringsinlärning**, eftersom vi överför viss kunskap från en neural nätverksmodell till en annan. Vid överföringsinlärning börjar vi vanligtvis med en förtränad modell, som har tränats på någon stor bilddatamängd, såsom **ImageNet**. Dessa modeller kan redan göra ett bra jobb med att extrahera olika funktioner från generiska bilder, och i många fall kan man bara bygga en klassificerare ovanpå dessa extraherade funktioner för att få ett bra resultat.\n" ] }, { @@ -29,11 +29,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Datasetet Cats vs. Dogs\n", + "## Katter vs. Hundar Dataset\n", "\n", - "I denna enhet kommer vi att lösa ett verkligt problem med att klassificera bilder av katter och hundar. För detta ändamål kommer vi att använda [Kaggle Cats vs. Dogs Dataset](https://www.kaggle.com/c/dogs-vs-cats), som också kan laddas ner [från Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n", + "I denna enhet ska vi lösa ett verkligt problem med att klassificera bilder på katter och hundar. Av denna anledning kommer vi att använda [Kaggle Cats vs. Dogs Dataset](https://www.kaggle.com/c/dogs-vs-cats), som också kan laddas ner [från Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n", "\n", - "Låt oss ladda ner detta dataset och extrahera det till katalogen `data` (denna process kan ta lite tid!):\n" + "Låt oss ladda ner denna dataset och extrahera den till `data`-katalogen (denna process kan ta lite tid!):\n" ] }, { @@ -64,7 +64,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Tyvärr finns det några korrupta bildfiler i datasetet. Vi behöver göra en snabb rensning för att kontrollera korrupta filer. För att inte störa denna handledning har vi flyttat koden för att verifiera datasetet till en modul.\n" + "Tyvärr finns det några korrupta bildfiler i datasetet. Vi behöver göra en snabb rengöring för att kontrollera korrupta filer. För att inte förstöra denna handledning har vi flyttat koden för att verifiera datasetet till en modul.\n" ] }, { @@ -335,11 +335,11 @@ "source": [ "## Ladda datasetet\n", "\n", - "I tidigare exempel laddade vi dataset som är inbyggda i Keras. Nu ska vi arbeta med vårt eget dataset, som vi behöver ladda från en katalog med bilder.\n", + "I tidigare exempel laddade vi dataset som är inbyggda i Keras. Nu ska vi hantera vårt eget dataset, som vi behöver ladda från en katalog med bilder.\n", "\n", "I verkligheten kan storleken på bilddataset vara ganska stor, och man kan inte förlita sig på att all data får plats i minnet. Därför representeras dataset ofta som **generatorer** som kan returnera data i minibatcher som är lämpliga för träning.\n", "\n", - "För att hantera bildklassificering inkluderar Keras en speciell funktion `image_dataset_from_directory`, som kan ladda bilder från underkataloger som motsvarar olika klasser. Denna funktion tar också hand om att skala bilder, och den kan även dela upp datasetet i tränings- och testdelar:\n" + "För att hantera bildklassificering inkluderar Keras en speciell funktion `image_dataset_from_directory`, som kan ladda bilder från undermappar som motsvarar olika klasser. Denna funktion sköter även skalning av bilder, och kan dessutom dela upp datasetet i tränings- och testdelar:\n" ] }, { @@ -383,9 +383,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Det är viktigt att ange samma `seed`-värde för båda anropen, eftersom det påverkar uppdelningen av bilder mellan tränings- och testdataset.\n", + "Det är viktigt att sätta samma `seed`-värde för båda anropen, eftersom det påverkar hur bilderna delas upp mellan tränings- och testdataset.\n", "\n", - "Datasetet hämtar automatiskt klassnamn från kataloger, och du kan komma åt dem vid behov genom att anropa:\n" + "Dataset plockar automatiskt upp klassnamn från kataloger, och du kan komma åt dem om det behövs genom att anropa:\n" ] }, { @@ -412,7 +412,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Datasets som vi har erhållit kan direkt skickas till `fit`-funktionen för att träna modellen. De innehåller både motsvarande bilder och etiketter, som kan loopas över med följande konstruktion:\n" + "Dataset som vi har erhållit kan direkt skickas till funktionen `fit` för att träna modellen. De innehåller både motsvarande bilder och etiketter, vilka kan loopas igenom med följande konstruktion:\n" ] }, { @@ -453,7 +453,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "> **Observera**: Alla bilder i datasetet representeras som flyttalstensorer med intervallet 0-255. Innan vi skickar dem till neurala nätverket måste vi skala dessa värden till intervallet 0-1. När vi plottar bilder behöver vi antingen göra samma sak, eller konvertera värdena till typen `int` (vilket vi gör i koden ovan), för att visa `matplotlib` att vi vill plotta den ursprungliga oskalade bilden.\n" + "> **Obs**: Alla bilder i datasetet representeras som flyttalspunkt-tensorer med värden i intervallet 0-255. Innan vi skickar dem till neurala nätverket behöver vi skala dessa värden till intervallet 0-1. När vi plottrar bilder behöver vi antingen göra samma sak, eller konvertera värdena till typen `int` (vilket vi gör i koden ovan), för att visa `matplotlib` att vi vill plottra den ursprungliga oskalade bilden.\n" ] }, { @@ -462,7 +462,7 @@ "source": [ "## Förtränade modeller\n", "\n", - "För många bildklassificeringsuppgifter kan man hitta förtränade neurala nätverksmodeller. Många av dessa modeller finns tillgängliga inom `keras.applications`-namnrymden, och ännu fler modeller kan hittas på Internet. Låt oss se hur den enklaste VGG-16-modellen kan laddas och användas:\n" + "För många bildklassificeringsuppgifter kan man hitta förtränade neurala nätverksmodeller. Många av dessa modeller finns tillgängliga i `keras.applications`-namnrymden, och ännu fler modeller kan hittas på Internet. Låt oss se hur den enklaste VGG-16-modellen kan laddas och användas:\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,17 +520,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Det finns ett par viktiga saker här:\n", - "* Innan man skickar in en input till ett förtränat nätverk måste den förbehandlas på ett visst sätt. Detta görs genom att anropa motsvarande `preprocess_input`-funktion, som tar emot en batch av bilder och returnerar deras bearbetade form. I fallet med VGG-16 normaliseras bilderna, och ett fördefinierat medelvärde för varje kanal subtraheras. Detta beror på att VGG-16 ursprungligen tränades med denna förbehandling.\n", - "* Det neurala nätverket appliceras på input-batchen, och som resultat får vi en batch av 1000-elementstensorer som visar sannolikheten för varje klass. Vi kan hitta det mest sannolika klassnumret genom att anropa `argmax` på denna tensor.\n", - "* Det erhållna resultatet är ett [nummer för en `ImageNet`-klass](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). För att förstå detta resultat kan vi också använda funktionen `decode_predictions`, som returnerar de n främsta klasserna tillsammans med deras namn.\n" + "Det finns några viktiga saker här:\n", + "* Innan man skickar in en input till något förtränat nätverk måste den förbehandlas på ett visst sätt. Detta görs genom att kalla på motsvarande `preprocess_input`-funktion, som tar emot ett batch av bilder och returnerar deras bearbetade form. I fallet med VGG-16 normaliseras bilderna, och ett fördefinierat medelvärde för varje kanal subtraheras. Detta beror på att VGG-16 ursprungligen tränades med denna förbehandling.\n", + "* Det neurala nätverket appliceras på input-batchen, och vi får som resultat ett batch av 1000-elementstensorer som visar sannolikheten för varje klass. Vi kan hitta det mest sannolika klassnumret genom att kalla `argmax` på denna tensor.\n", + "* Det erhållna resultatet är ett [nummer för en `ImageNet`-klass](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). För att tolka resultatet kan vi även använda funktionen `decode_predictions` som returnerar de top n klasserna tillsammans med deras namn.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Låt oss också se arkitekturen för VGG-16-nätverket:\n" + "Låt oss också titta på arkitekturen för VGG-16-nätverket:\n" ] }, { @@ -599,7 +609,7 @@ "source": [ "## GPU-beräkningar\n", "\n", - "Djupa neurala nätverk, såsom VGG-16 och andra mer moderna arkitekturer, kräver ganska mycket beräkningskraft för att köras. Det är logiskt att använda GPU-acceleration om det är tillgängligt. Som tur är snabbar Keras automatiskt upp beräkningarna på GPU:n om den är tillgänglig. Vi kan kontrollera om Tensorflow kan använda GPU med följande kod:\n" + "Djupa neurala nätverk, såsom VGG-16 och andra mer moderna arkitekturer, kräver ganska mycket beräkningskraft för att köras. Det är rimligt att använda GPU-acceleration om det är tillgängligt. Lyckligtvis snabbar Keras automatiskt upp beräkningarna på GPU om det finns tillgängligt. Vi kan kontrollera om Tensorflow kan använda GPU med följande kod:\n" ] }, { @@ -626,9 +636,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "\n", "## Extrahera VGG-funktioner\n", "\n", - "Om vi vill använda VGG-16 för att extrahera funktioner från våra bilder behöver vi modellen utan de sista klassificeringslagren. Vi kan skapa en VGG-16-modell utan toppskikt med följande kod:\n" + "Om vi vill använda VGG-16 för att extrahera funktioner från våra bilder behöver vi modellen utan de slutliga klassificeringslagren. Vi kan skapa en VGG-16-modell utan de översta lagren med den här koden:\n" ] }, { @@ -680,9 +691,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Dimensionen av funktions-tensorn är 7x7x512, men för att kunna visualisera den var vi tvungna att omforma den till 2D-format.\n", + "Dimensionen på feature-tensorn är 7x7x512, men för att visualisera den var vi tvungna att omforma den till 2D-form.\n", "\n", - "Nu ska vi försöka se om dessa funktioner kan användas för att klassificera bilder. Låt oss manuellt ta en del av bilderna (50 minibatcher, i vårt fall) och förberäkna deras funktionsvektorer. Vi kan använda Tensorflow **dataset** API för att göra detta. `map`-funktionen tar ett dataset och applicerar en given lambda-funktion för att transformera det. Vi använder denna mekanism för att skapa nya dataset, `ds_features_train` och `ds_features_test`, som innehåller VGG-extraherade funktioner istället för de ursprungliga bilderna.\n" + "Nu ska vi försöka se om dessa features kan användas för att klassificera bilder. Vi tar manuellt en del av bilderna (50 minibatcher, i vårt fall) och förberäknar deras feature-vektorer. Vi kan använda Tensorflow **dataset** API för att göra det. `map`-funktionen tar en dataset och tillämpar en given lambda-funktion för att transformera den. Vi använder denna mekanism för att konstruera nya datasets, `ds_features_train` och `ds_features_test`, som innehåller VGG-extraherade features istället för ursprungliga bilder.\n" ] }, { @@ -714,7 +725,7 @@ "source": [ "Vi använde konstruktionen `.take(50)` för att begränsa datasetets storlek, för att snabba upp vår demonstration. Du kan naturligtvis utföra detta experiment på hela datasetet.\n", "\n", - "Nu när vi har ett dataset med extraherade funktioner kan vi träna en enkel tät klassificerare för att skilja mellan katter och hundar. Detta nätverk kommer att ta en funktionsvektor med formen (7,7,512) och producera ett output som motsvarar antingen en hund eller en katt. Eftersom det är en binär klassificering använder vi aktiveringsfunktionen `sigmoid` och förlustfunktionen `binary_crossentropy`.\n" + "Nu när vi har ett dataset med extraherade funktioner kan vi träna en enkel tät klassificerare för att skilja mellan katter och hundar. Detta nätverk kommer att ta en funktionsvektor med formen (7,7,512) och producera en utgång som motsvarar antingen en hund eller en katt. Eftersom det är en binär klassificering använder vi `sigmoid` aktiveringsfunktion och `binary_crossentropy` förlust.\n" ] }, { @@ -743,13 +754,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Resultatet är fantastiskt, vi kan skilja mellan en katt och en hund med nästan 95% sannolikhet! Dock har vi bara testat detta tillvägagångssätt på en delmängd av alla bilder, eftersom manuell funktionsextraktion verkar ta mycket tid.\n", + "Resultatet är fantastiskt, vi kan skilja mellan en katt och en hund med nästan 95% sannolikhet! Dock har vi bara testat detta tillvägagångssätt på en undergrupp av alla bilder, eftersom manuell features-extraktion verkar ta mycket tid.\n", "\n", - "## Transfer learning med en VGG-nätverk\n", + "## Transferinlärning med ett VGG-nätverk\n", "\n", - "Vi kan också undvika att manuellt förberäkna funktionerna genom att använda det ursprungliga VGG-16-nätverket i sin helhet under träningen, genom att lägga till en funktionsextraktor som första lager i vårt nätverk.\n", + "Vi kan också undvika att manuellt förberäkna egenskaperna genom att använda det ursprungliga VGG-16-nätverket som helhet under träning, genom att lägga till feature extractor till vårt nätverk som ett första lager.\n", "\n", - "Det fina med Keras-arkitekturen är att VGG-16-modellen som vi har definierat ovan också kan användas som ett lager i ett annat neuralt nätverk! Vi behöver bara konstruera ett nätverk med en tät klassificerare ovanpå det, och sedan träna hela nätverket med hjälp av backpropagation.\n" + "Det fina med Keras arkitektur är att VGG-16-modellen som vi definierat ovan också kan användas som ett lager i ett annat neuralt nätverk! Vi behöver bara konstruera ett nätverk med en tät klassificerare ovanpå det, och sedan träna hela nätverket med backpropagation.\n" ] }, { @@ -793,13 +804,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Den här modellen ser ut som ett end-to-end klassificeringsnätverk, som tar en bild och returnerar klassen. Det knepiga är dock att vi vill att VGG16 ska fungera som en funktionsutdragare och inte tränas om. Därför behöver vi **frysa vikterna för det konvolutionella funktionsutdraget**. Vi kan komma åt det första lagret i nätverket genom att anropa `model.layers[0]`, och vi behöver bara ställa in egenskapen `trainable` till `False`.\n", + "Denna modell ser ut som ett end-to-end klassificeringsnätverk, som tar en bild och returnerar klassen. Det knepiga är dock att vi vill att VGG16 ska agera som en feature-extraktor, och inte tränas om. Därför behöver vi **frysa vikterna i den konvolutionella feature-extraktorn**. Vi kan komma åt det första lagret i nätverket genom att anropa `model.layers[0]`, och vi behöver bara sätta egenskapen `trainable` till `False`.\n", "\n", - "> **Note**: Att frysa vikterna för funktionsutdraget är nödvändigt, eftersom ett otränat klassificeringslager annars kan förstöra de ursprungliga förtränade vikterna i det konvolutionella utdraget.\n", + "> **Notera**: Frysning av vikter för feature-extraktorn är nödvändig, eftersom ett otränat klassificeringslager annars kan förstöra de ursprungliga förtränade vikterna i den konvolutionella extraktorn.\n", "\n", - "Du kan märka att även om det totala antalet parametrar i vårt nätverk är runt 15 miljoner, tränar vi bara 25 000 parametrar. Alla andra parametrar i de översta konvolutionella filtren är förtränade. Det är bra, eftersom vi kan finjustera ett mindre antal parametrar med ett mindre antal exempel.\n", + "Du kan märka att medan det totala antalet parametrar i vårt nätverk är runt 15 miljoner, tränar vi endast 25k parametrar. Alla andra parametrar i de översta konvolutionella filtren är förtränade. Det är bra, eftersom vi kan finjustera ett mindre antal parametrar med ett mindre antal exempel.\n", "\n", - "Vi ska nu träna vårt nätverk och se hur bra vi kan bli. Förvänta dig ganska lång körtid, och oroa dig inte om det verkar som att körningen har frusit en stund.\n" + "Vi kommer nu att träna vårt nätverk och se hur bra det kan bli. Räkna med ganska lång körtid, och oroa dig inte om exekveringen verkar frusen under en tid.\n" ] }, { @@ -824,11 +835,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Det verkar som att vi har fått en ganska träffsäker klassificerare för katter och hundar!\n", + "Det ser ut som att vi har fått fram en ganska exakt klassificerare för katter vs. hundar! \n", "\n", "## Spara och ladda modellen\n", "\n", - "När vi har tränat modellen kan vi spara modellens arkitektur och tränade vikter i en fil för framtida användning:\n" + "När vi har tränat modellen kan vi spara modellens arkitektur och tränade vikter till en fil för framtida användning:\n" ] }, { @@ -852,7 +863,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Vi kan sedan ladda modellen från filen när som helst. Du kan tycka att det är användbart om nästa experiment förstör modellen - du skulle inte behöva börja om från början.\n" + "Vi kan sedan ladda modellen från fil när som helst. Du kan tycka att det är användbart om nästa experiment förstör modellen – du behöver då inte börja om från början.\n" ] }, { @@ -868,15 +879,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Finjustering av transfer learning\n", + "## Finjustering av överföringsinlärning\n", "\n", - "I föregående avsnitt tränade vi det sista klassificeringslagret för att klassificera bilder i vårt eget dataset. Däremot tränade vi inte om funktionsutvinnaren, och vår modell förlitade sig på de funktioner som modellen hade lärt sig från ImageNet-data. Om dina objekt visuellt skiljer sig från vanliga ImageNet-bilder kanske denna kombination av funktioner inte fungerar optimalt. Därför är det logiskt att börja träna konvolutionella lager också.\n", + "I föregående avsnitt tränade vi det slutgiltiga klassificeringslagret för att klassificera bilder i vår egen datamängd. Vi tränade dock inte om funktionsutdragaren, och vår modell förlitade sig på de funktioner som modellen har lärt sig från ImageNet-data. Om dina objekt visuellt skiljer sig från vanliga ImageNet-bilder, kanske denna kombination av funktioner inte fungerar bäst. Det är därför vettigt att börja träna de konvolutionella lagren också.\n", "\n", - "För att göra detta kan vi låsa upp parametrarna för de konvolutionella filtren som vi tidigare låste.\n", + "För att göra det kan vi tina upp parametrarna för konvolutionsfiltren som vi tidigare fryst.\n", "\n", - "> **Note:** Det är viktigt att du först låser parametrarna och genomför flera träningsomgångar för att stabilisera vikterna i klassificeringslagret. Om du omedelbart börjar träna ett nätverk från början till slut med upplåsta parametrar är det stor risk att stora fel förstör de förtränade vikterna i de konvolutionella lagren.\n", + "> **Obs:** Det är viktigt att du fryser parametrarna först och utför flera tränings-epoker för att stabilisera vikterna i klassificeringslagret. Om du omedelbart börjar träna hela nätverket med ofrysta parametrar är det stor risk att stora fel förstör de förtränade vikterna i de konvolutionella lagren.\n", "\n", - "Vår konvolutionella VGG-16-modell finns i det första lagret och består i sig av många lager. Vi kan titta på dess struktur:\n" + "Vår konvolutionella VGG-16-modell finns inuti det första lagret, och den består själv av många lager. Vi kan titta på dess struktur:\n" ] }, { @@ -945,7 +956,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Vi kan avfrosta alla lager av konvolutionell bas:\n" + "Vi kan låsa upp alla lager i konvolutionsbasen:\n" ] }, { @@ -961,7 +972,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Men att tina upp alla på en gång är inte den bästa idén. Vi kan först tina upp bara några få slutlager av konvolutioner, eftersom de innehåller högre nivåmönster som är relevanta för våra bilder. Till exempel kan vi börja med att frysa alla lager utom de sista 4:\n" + "Men att tina upp alla på en gång är inte den bästa idén. Vi kan först tina upp bara några få slutgiltiga lager av konvolutioner, eftersom de innehåller högre nivåers mönster som är relevanta för våra bilder. Till exempel kan vi börja med att frysa alla lager utom de sista 4: \n" ] }, { @@ -1000,11 +1011,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Observera att antalet tränbara parametrar ökade avsevärt, men det är fortfarande runt 50 % av alla parametrar.\n", + "Observera att antalet träningsbara parametrar ökade betydligt, men det är fortfarande runt 50 % av alla parametrar.\n", "\n", - "Efter att ha låst upp parametrarna kan vi köra några fler tränings-epoker (i vårt exempel kommer vi bara att köra en). Du kan också välja en lägre inlärningshastighet för att minimera påverkan på de förtränade vikterna. Men även med låg inlärningshastighet kan du förvänta dig att noggrannheten sjunker i början av träningen, innan den slutligen når en något högre nivå än i fallet med fasta vikter.\n", + "Efter att ha låst upp kan vi göra några fler träningscykler (i vårt exempel gör vi bara en). Du kan också välja en lägre inlärningshastighet för att minimera påverkan på de förtränade vikterna. Men även med låg inlärningshastighet kan du förvänta dig att noggrannheten sjunker i början av träningen, tills den slutligen når en något högre nivå än i fallet med fasta vikter.\n", "\n", - "> **Note:** Den här träningen går mycket långsammare eftersom vi behöver sprida gradienter tillbaka genom många lager i nätverket!\n" + "> **Obs:** Den här träningen sker mycket långsammare eftersom vi måste propagera gradienterna bakåt genom många lager i nätverket!\n" ] }, { @@ -1028,9 +1039,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Vi kommer sannolikt att uppnå högre träningsnoggrannhet eftersom vi använder ett kraftfullare nätverk med fler parametrar, men valideringsnoggrannheten kommer inte att öka lika mycket.\n", + "Vi kommer sannolikt att uppnå högre träningsnoggrannhet, eftersom vi använder ett kraftfullare nätverk med fler parametrar, men valideringsnoggrannheten skulle inte öka lika mycket.\n", "\n", - "Känn dig fri att låsa upp några fler lager i nätverket och träna vidare för att se om du kan uppnå högre noggrannhet!\n" + "Känn dig fri att låsa upp några fler lager i nätverket och träna mer, för att se om du kan uppnå högre noggrannhet!\n" ] }, { @@ -1039,7 +1050,7 @@ "source": [ "## Andra datorvisionsmodeller\n", "\n", - "VGG-16 är en av de enklaste datorvisionsarkitekturerna. Keras erbjuder många fler förtränade nätverk. De mest använda bland dessa är **ResNet**-arkitekturer, utvecklade av Microsoft, och **Inception** av Google. Till exempel, låt oss utforska arkitekturen för den enklaste ResNet-50-modellen (ResNet är en familj av modeller med olika djup, du kan prova att experimentera med ResNet-152 om du vill se hur en riktigt djup modell ser ut):\n" + "VGG-16 är en av de enklaste datorvisionsarkitekturerna. Keras tillhandahåller många fler förtränade nätverk. De mest använda bland dessa är **ResNet**-arkitekturer, utvecklade av Microsoft, och **Inception** av Google. Till exempel, låt oss utforska arkitekturen för den enklaste ResNet-50-modellen (ResNet är en familj av modeller med olika djup, du kan prova att experimentera med ResNet-152 om du vill se hur en riktigt djup modell ser ut):\n" ] }, { @@ -1441,11 +1452,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Som du kan se innehåller modellen samma välbekanta byggstenar: konvolutionslager, poolinglager och en slutlig tät klassificerare. Vi kan använda denna modell på exakt samma sätt som vi har använt VGG-16 för transfer learning. Du kan prova att experimentera med koden ovan, använda olika ResNet-modeller som basmodell och se hur noggrannheten förändras.\n", + "Som du kan se innehåller modellen samma välbekanta byggstenar: konvolutionella lager, poolningslager och slutligen en tät (dense) klassificerare. Vi kan använda denna modell på exakt samma sätt som vi har använt VGG-16 för transferinlärning. Du kan prova att experimentera med koden ovan, använda olika ResNet-modeller som basmodell, och se hur noggrannheten förändras.\n", "\n", - "## Batchnormalisering\n", + "## Batch Normalization\n", "\n", - "Detta nätverk innehåller ytterligare en typ av lager: **Batchnormalisering**. Idén med batchnormalisering är att föra värden som flödar genom det neurala nätverket till rätt intervall. Vanligtvis fungerar neurala nätverk bäst när alla värden ligger inom intervallet [-1,1] eller [0,1], och det är därför vi skalar/normaliserar våra indata därefter. Under träning av ett djupt nätverk kan det dock hända att värden hamnar betydligt utanför detta intervall, vilket gör träningen problematisk. Batchnormaliseringslagret beräknar medelvärde och standardavvikelse för alla värden i den aktuella minibatchen och använder dem för att normalisera signalen innan den skickas genom ett neuralt nätverkslager. Detta förbättrar stabiliteten hos djupa nätverk avsevärt.\n" + "Detta nätverk innehåller en ytterligare typ av lager: **Batch Normalization**. Idén med batchnormalisering är att föra värdena som flyter genom det neurala nätverket till rätt intervall. Vanligtvis fungerar neurala nätverk bäst när alla värden är inom intervallet [-1,1] eller [0,1], och det är anledningen till att vi skalar/normaliserar vår indata därefter. Under träningen av ett djupt nätverk kan det dock hända att värdena hamnar avsevärt utanför detta intervall, vilket gör träningen problematisk. Batchnormaliseringslagret beräknar medelvärde och standardavvikelse för alla värden i den aktuella minibatchen, och använder dem för att normalisera signalen innan den passerar genom ett lager i det neurala nätverket. Detta förbättrar stabiliteten i djupa nätverk avsevärt.\n" ] }, { @@ -1454,16 +1465,16 @@ "source": [ "## Slutsats\n", "\n", - "Genom att använda transfer learning kunde vi snabbt sätta ihop en klassificerare för vår anpassade objektklassificeringsuppgift och uppnå hög noggrannhet. Dock var detta exempel inte helt rättvist, eftersom det ursprungliga VGG-16-nätverket var förtränat för att känna igen katter och hundar, och vi återanvände därför de flesta mönster som redan fanns i nätverket. Du kan förvänta dig lägre noggrannhet för mer exotiska, domänspecifika objekt, såsom detaljer på produktionslinjen i en fabrik eller olika trädblad.\n", + "Genom att använda transfer learning kunde vi snabbt sätta ihop en klassificerare för vår anpassade objektklassificeringsuppgift och uppnå hög noggrannhet. Dock var detta exempel inte helt rättvist, eftersom det ursprungliga VGG-16-nätverket var förtränat för att känna igen katter och hundar, och därför återanvände vi mestadels mönster som redan fanns i nätverket. Du kan förvänta dig lägre noggrannhet på mer exotiska domänspecifika objekt, såsom detaljer på en produktionslinje i en fabrik eller olika trädblad.\n", "\n", - "Du kan se att mer komplexa uppgifter som vi löser nu kräver högre beräkningskraft och inte enkelt kan lösas på en CPU. I nästa enhet kommer vi att försöka använda en mer lättviktig implementation för att träna samma modell med lägre beräkningsresurser, vilket resulterar i endast något lägre noggrannhet.\n" + "Du kan se att mer komplexa uppgifter som vi löser nu kräver högre beräkningskraft och inte enkelt kan lösas på CPU. I nästa enhet kommer vi att försöka använda en mer lättviktig implementation för att träna samma modell med lägre beräkningsresurser, vilket resulterar i bara något lägre noggrannhet.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "\n---\n\n**Ansvarsfriskrivning**: \nDetta dokument har översatts med hjälp av AI-översättningstjänsten [Co-op Translator](https://github.com/Azure/co-op-translator). Även om vi strävar efter noggrannhet, bör det noteras att automatiska översättningar kan innehålla fel eller brister. Det ursprungliga dokumentet på dess originalspråk bör betraktas som den auktoritativa källan. För kritisk information rekommenderas professionell mänsklig översättning. Vi ansvarar inte för eventuella missförstånd eller feltolkningar som kan uppstå vid användning av denna översättning.\n" + "---\n\n\n**Ansvarsfriskrivning**:\nDetta dokument har översatts med hjälp av AI-översättningstjänsten [Co-op Translator](https://github.com/Azure/co-op-translator). Även om vi strävar efter noggrannhet, var vänlig notera att automatiska översättningar kan innehålla fel eller brister. Det ursprungliga dokumentet på dess modersmål bör betraktas som den auktoritativa källan. För kritisk information rekommenderas professionell mänsklig översättning. Vi ansvarar inte för några missförstånd eller feltolkningar som uppstår till följd av användningen av denna översättning.\n\n" ] } ], @@ -1484,12 +1495,6 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.10" - }, - "coopTranslator": { - "original_hash": "c189abc107848f96051085cc30945129", - "translation_date": "2025-08-28T16:28:22+00:00", - "source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb", - "language_code": "sv" } }, "nbformat": 4, diff --git a/translations/sv/lessons/5-NLP/README.md b/translations/sv/lessons/5-NLP/README.md index 93758bcd..7ff54463 100644 --- a/translations/sv/lessons/5-NLP/README.md +++ b/translations/sv/lessons/5-NLP/README.md @@ -1,34 +1,34 @@ # Naturlig Språkbearbetning -![Sammanfattning av NLP-uppgifter i en skiss](../../../../translated_images/sv/ai-nlp.b22dcb8ca4707cea.webp) +![Sammanfattning av NLP-uppgifter i en kladd](../../../../translated_images/sv/ai-nlp.b22dcb8ca4707cea.webp) -I den här delen kommer vi att fokusera på att använda neurala nätverk för att hantera uppgifter relaterade till **naturlig språkbearbetning (NLP)**. Det finns många NLP-problem som vi vill att datorer ska kunna lösa: +I detta avsnitt kommer vi att fokusera på att använda neurala nätverk för att hantera uppgifter relaterade till **Naturlig Språkbearbetning (NLP)**. Det finns många NLP-problem som vi vill att datorer ska kunna lösa: -* **Textklassificering** är ett typiskt klassificeringsproblem som rör textsekvenser. Exempel inkluderar att klassificera e-postmeddelanden som skräppost eller inte, eller att kategorisera artiklar som sport, ekonomi, politik, etc. När vi utvecklar chattbotar behöver vi ofta förstå vad en användare vill säga – i detta fall handlar det om **avsiktsklassificering**. Ofta måste vi hantera många kategorier i avsiktsklassificering. -* **Sentimentanalys** är ett typiskt regressionsproblem där vi behöver tilldela ett värde (ett sentiment) som motsvarar hur positivt/negativt innebörden av en mening är. En mer avancerad version av sentimentanalys är **aspektbaserad sentimentanalys** (ABSA), där vi tilldelar sentiment inte till hela meningen, utan till olika delar av den (aspekter), t.ex. *På den här restaurangen gillade jag maten, men atmosfären var hemsk*. -* **Named Entity Recognition** (NER) handlar om att extrahera vissa enheter från text. Till exempel kan vi behöva förstå att i frasen *Jag behöver flyga till Paris imorgon* hänvisar ordet *imorgon* till DATUM, och *Paris* är en PLATS. -* **Nyckelordsutvinning** liknar NER, men här behöver vi automatiskt extrahera ord som är viktiga för meningen, utan att förträna för specifika enhetstyper. -* **Textklustring** kan vara användbart när vi vill gruppera liknande meningar, till exempel liknande förfrågningar i tekniska supportkonversationer. -* **Frågehantering** handlar om en modells förmåga att svara på en specifik fråga. Modellen får en textpassage och en fråga som indata, och den behöver ange en plats i texten där svaret på frågan finns (eller ibland generera själva svarstexten). -* **Textgenerering** är en modells förmåga att skapa ny text. Det kan ses som en klassificeringsuppgift där nästa bokstav/ord förutsägs baserat på en *textprompt*. Avancerade textgenereringsmodeller, som GPT-3, kan lösa andra NLP-uppgifter som klassificering med hjälp av en teknik som kallas [prompt-programmering](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) eller [prompt-engineering](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29). -* **Textsammanfattning** är en teknik där vi vill att en dator ska "läsa" lång text och sammanfatta den i några meningar. +* **Textklassificering** är ett typiskt klassificeringsproblem som rör textsekvenser. Exempel inkluderar att klassificera e-postmeddelanden som skräppost vs. inte skräppost, eller att kategorisera artiklar som sport, affärer, politik, osv. Också när vi utvecklar chattbotar behöver vi ofta förstå vad en användare ville säga – i detta fall handlar det om **avsiktsklassificering**. Ofta, vid avsiktsklassificering, behöver vi hantera många kategorier. +* **Sentimentanalys** är ett typiskt regressionsproblem, där vi behöver tilldela ett nummer (en känsla) som motsvarar hur positiv/negativ meningen i en mening är. En mer avancerad version av sentimentanalys är **aspektbaserad sentimentanalys** (ABSA), där vi tilldelar sentiment inte till hela meningen, utan till olika delar av den (aspekter), t.ex. *I denna restaurang gillade jag maten, men atmosfären var hemsk*. +* **Named Entity Recognition** (NER) syftar på problemet att extrahera vissa entiteter från text. Till exempel kan vi behöva förstå att i frasen *Jag behöver flyga till Paris imorgon* refererar ordet *imorgon* till DATUM, och *Paris* är en PLATS. +* **Nyckelordsutvinning** liknar NER, men vi behöver automatiskt extrahera ord som är viktiga för meningen i meningen, utan förträning för specifika entitetstyper. +* **Textklustring** kan vara användbart när vi vill gruppera liknande meningar, till exempel liknande förfrågningar i teknisk support. +* **Frågesvar** syftar på förmågan hos en modell att svara på en specifik fråga. Modellen får en textavsnitt och en fråga som indata, och den behöver ange en plats i texten där svaret på frågan finns (eller ibland generera svaret i textform). +* **Textgenerering** är en modells förmåga att generera ny text. Det kan ses som en klassificeringsuppgift där nästa bokstav/ord förutsägs baserat på någon *textprompt*. Avancerade textgenereringsmodeller, såsom GPT-3, kan lösa andra NLP-uppgifter som klassificering med en teknik som kallas [prompt programming](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) eller [prompt engineering](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29) +* **Textsammanfattning** är en teknik där vi vill att en dator "läser" lång text och sammanfattar den i några meningar. * **Maskinöversättning** kan ses som en kombination av textförståelse på ett språk och textgenerering på ett annat. -Från början löstes de flesta NLP-uppgifter med traditionella metoder som grammatik. Till exempel användes parsers i maskinöversättning för att omvandla en ursprunglig mening till ett syntaxträd, sedan extraherades högre semantiska strukturer för att representera meningen av meningen, och baserat på denna mening och grammatiken i målspråket genererades resultatet. Idag löses många NLP-uppgifter mer effektivt med hjälp av neurala nätverk. +Inledningsvis löstes de flesta NLP-uppgifter med traditionella metoder såsom grammatiker. Till exempel användes parsers i maskinöversättning för att omvandla den ursprungliga meningen till ett syntaxträd, sedan extraherades högre nivåers semantiska strukturer för att representera meningen av meningen, och baserat på denna mening och grammatiken i målspråket genererades resultatet. Numera löses många NLP-uppgifter mer effektivt med neurala nätverk. -> Många klassiska NLP-metoder är implementerade i Python-biblioteket [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org). Det finns en fantastisk [NLTK-bok](https://www.nltk.org/book/) tillgänglig online som täcker hur olika NLP-uppgifter kan lösas med NLTK. +> Många klassiska NLP-metoder är implementerade i Python-biblioteket [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org). Det finns en utmärkt [NLTK Book](https://www.nltk.org/book/) tillgänglig online som täcker hur olika NLP-uppgifter kan lösas med NLTK. -I vår kurs kommer vi främst att fokusera på att använda neurala nätverk för NLP, och vi kommer att använda NLTK där det behövs. +I vår kurs kommer vi mestadels att fokusera på att använda neurala nätverk för NLP, och vi kommer att använda NLTK där det behövs. -Vi har redan lärt oss att använda neurala nätverk för att hantera tabulära data och bilder. Den största skillnaden mellan dessa typer av data och text är att text är en sekvens med variabel längd, medan indata i fallet med bilder är känd i förväg. Även om konvolutionella nätverk kan extrahera mönster från indata, är mönster i text mer komplexa. Till exempel kan negation vara separerad från subjektet med ett godtyckligt antal ord (t.ex. *Jag gillar inte apelsiner* vs. *Jag gillar inte de där stora färgglada goda apelsinerna*), och det bör fortfarande tolkas som ett mönster. Därför behöver vi introducera nya typer av neurala nätverk, såsom *rekurrenta nätverk* och *transformers*, för att hantera språk. +Vi har redan lärt oss om att använda neurala nätverk för att hantera tabulär data och bilder. Den huvudsakliga skillnaden mellan dessa typer av data och text är att text är en sekvens med variabel längd, medan indatastorleken vid bilder är känd i förväg. Medan konvolutionsnätverk kan extrahera mönster från indata, är mönster i text mer komplexa. T.ex., kan negation vara separerad från subjektet med godtyckligt många ord (t.ex. *Jag gillar inte apelsiner*, vs. *Jag gillar inte de där stora färgglada goda apelsinerna*), och det bör ändå tolkas som ett mönster. Därför behöver vi nya typer av neurala nätverk för att hantera språk, såsom *rekurrenta nätverk* och *transformers*. -## Installera bibliotek +## Installera Bibliotek -Om du använder en lokal Python-installation för att köra den här kursen kan du behöva installera alla nödvändiga bibliotek för NLP med följande kommandon: +Om du använder en lokal Python-installation för att köra denna kurs, kan du behöva installera alla nödvändiga bibliotek för NLP med följande kommandon: **För PyTorch** ```bash -pip install -r requirements-torch.txt +pip install -r requirements-pytorch.txt ``` **För TensorFlow** ```bash @@ -39,13 +39,13 @@ pip install -r requirements-tf.txt ## GPU-varning -I den här delen kommer vi i vissa exempel att träna ganska stora modeller. -* **Använd en dator med GPU-stöd**: Det är lämpligt att köra dina anteckningsböcker på en dator med GPU-stöd för att minska väntetiderna när du arbetar med stora modeller. -* **Begränsningar för GPU-minne**: Att köra på en GPU kan leda till situationer där GPU-minnet tar slut, särskilt när du tränar stora modeller. -* **GPU-minnesförbrukning**: Mängden GPU-minne som används under träning beror på olika faktorer, inklusive minibatch-storleken. -* **Minimera minibatch-storlek**: Om du stöter på problem med GPU-minne, överväg att minska minibatch-storleken i din kod som en möjlig lösning. -* **TensorFlow GPU-minneshantering**: Äldre versioner av TensorFlow kanske inte frigör GPU-minne korrekt när flera modeller tränas inom en Python-kärna. För att hantera GPU-minnesanvändning effektivt kan du konfigurera TensorFlow att endast allokera GPU-minne vid behov. -* **Kod för inkludering**: För att ställa in TensorFlow att växa GPU-minnesallokering endast när det behövs, inkludera följande kod i dina anteckningsböcker: +I detta avsnitt kommer vi i några av exemplen träna ganska stora modeller. +* **Använd en dator med GPU-stöd**: Det är rekommenderat att köra dina anteckningsböcker på en dator med GPU-stöd för att minska väntetider när du arbetar med stora modeller. +* **Begränsningar i GPU-minne**: Att köra på GPU kan leda till situationer där du får slut på GPU-minne, särskilt när du tränar stora modeller. +* **GPU-minnesförbrukning**: Mängden GPU-minne som förbrukas under träning beror på olika faktorer, bland annat minibatch-storleken. +* **Minimera minibatch-storleken**: Om du stöter på problem med GPU-minnet, överväg att minska minibatch-storleken i din kod som en möjlig lösning. +* **TensorFlow GPU-minnesfrigöring**: Äldre versioner av TensorFlow kan ha problem med att frigöra GPU-minnet korrekt när man tränar flera modeller i en och samma Python-kärna. För att effektivt hantera GPU-minnesanvändning kan du konfigurera TensorFlow att bara allokera GPU-minne vid behov. +* **Kod inkludering**: För att ställa in TensorFlow så att GPU-minnesallokeringen växer endast när det behövs, inkludera följande kod i dina anteckningsböcker: ```python physical_devices = tf.config.list_physical_devices('GPU') @@ -53,13 +53,13 @@ if len(physical_devices)>0: tf.config.experimental.set_memory_growth(physical_devices[0], True) ``` -Om du är intresserad av att lära dig om NLP ur ett klassiskt ML-perspektiv, besök [denna serie lektioner](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP) +Om du är intresserad av att lära dig om NLP från ett klassiskt ML-perspektiv, besök [denna serie lektioner](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP) -## I den här delen -I den här delen kommer vi att lära oss om: +## I detta avsnitt +I detta avsnitt kommer vi att lära oss om: * [Att representera text som tensorer](13-TextRep/README.md) -* [Ordinbäddningar](14-Emdeddings/README.md) +* [Ordbäddningar](14-Emdeddings/README.md) * [Språkmodellering](15-LanguageModeling/README.md) * [Rekurrenta neurala nätverk](16-RNN/README.md) * [Generativa nätverk](17-GenerativeNetworks/README.md) @@ -67,5 +67,7 @@ I den här delen kommer vi att lära oss om: --- -**Ansvarsfriskrivning**: -Detta dokument har översatts med hjälp av AI-översättningstjänsten [Co-op Translator](https://github.com/Azure/co-op-translator). Även om vi strävar efter noggrannhet, bör du vara medveten om att automatiserade översättningar kan innehålla fel eller inexaktheter. Det ursprungliga dokumentet på dess originalspråk bör betraktas som den auktoritativa källan. För kritisk information rekommenderas professionell mänsklig översättning. Vi ansvarar inte för eventuella missförstånd eller feltolkningar som uppstår vid användning av denna översättning. \ No newline at end of file + +**Ansvarsfriskrivning**: +Detta dokument har översatts med hjälp av AI-översättningstjänsten [Co-op Translator](https://github.com/Azure/co-op-translator). Även om vi strävar efter noggrannhet, var vänlig notera att automatiska översättningar kan innehålla fel eller brister. Det ursprungliga dokumentet på dess modersmål bör betraktas som den auktoritativa källan. För kritisk information rekommenderas professionell mänsklig översättning. Vi ansvarar inte för några missförstånd eller feltolkningar som uppstår till följd av användningen av denna översättning. + \ No newline at end of file diff --git a/translations/th/.co-op-translator.json b/translations/th/.co-op-translator.json index 2a69e14b..fa3d8af8 100644 --- a/translations/th/.co-op-translator.json +++ b/translations/th/.co-op-translator.json @@ -5,6 +5,12 @@ "source_file": "AGENTS.md", "language_code": "th" }, + "CONTRIBUTING.md": { + "original_hash": "c6fd7e781b67111a90abd166d0ce4aa0", + "translation_date": "2026-07-08T18:03:52+00:00", + "source_file": "CONTRIBUTING.md", + "language_code": "th" + }, "README.md": { "original_hash": "12c8eb6bf0867d2f1c32daf613ac5b8b", "translation_date": "2026-04-06T16:20:53+00:00", @@ -17,6 +23,19 @@ "source_file": "SECURITY.md", "language_code": "th" }, + "__translation_failures__": { + "lessons/sketchnotes/LICENSE.md": { + "original_hash": "45ab63a2cd8f5faef6c9b150618837a4", + "source_file": "lessons/sketchnotes/LICENSE.md", + "language_code": "th", + "failure_date": "2026-07-08T17:52:14+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-29T09:31:47+00:00", @@ -54,8 +73,8 @@ "language_code": "th" }, "examples/README.md": { - "original_hash": "0d1babfdcbeb46525f2db3fbaaa54cd7", - "translation_date": "2025-10-03T11:30:59+00:00", + "original_hash": "7883d52c2e2a221e0b07a7b112a149b9", + "translation_date": "2026-07-08T17:46:30+00:00", "source_file": "examples/README.md", "language_code": "th" }, @@ -66,8 +85,8 @@ "language_code": "th" }, "lessons/0-course-setup/how-to-run.md": { - "original_hash": "a4717bd9103b9f6cd84d534b83534689", - "translation_date": "2026-01-16T02:18:09+00:00", + "original_hash": "7ad8c7d8604c53649b3d4d1e2f3a6fa1", + "translation_date": "2026-07-08T17:46:53+00:00", "source_file": "lessons/0-course-setup/how-to-run.md", "language_code": "th" }, @@ -191,6 +210,12 @@ "source_file": "lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md", "language_code": "th" }, + "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb": { + "original_hash": "99b816b6a4957ef4100cee4c4221dff9", + "translation_date": "2026-07-08T17:42:52+00:00", + "source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb", + "language_code": "th" + }, "lessons/4-ComputerVision/08-TransferLearning/lab/README.md": { "original_hash": "7765935c35fcee69b9fe2d0cfd6963e2", "translation_date": "2025-08-29T08:50:50+00:00", @@ -330,8 +355,8 @@ "language_code": "th" }, "lessons/5-NLP/README.md": { - "original_hash": "8ef02a9318257ea140ed3ed74442096d", - "translation_date": "2025-08-29T09:16:38+00:00", + "original_hash": "038df6f1a73e49f6430740da083bfd6d", + "translation_date": "2026-07-08T17:47:26+00:00", "source_file": "lessons/5-NLP/README.md", "language_code": "th" }, diff --git a/translations/th/CONTRIBUTING.md b/translations/th/CONTRIBUTING.md new file mode 100644 index 00000000..866c968d --- /dev/null +++ b/translations/th/CONTRIBUTING.md @@ -0,0 +1,29 @@ +# การมีส่วนร่วมกับ AI-For-Beginners + +ขอบคุณที่คุณสนใจมีส่วนร่วมกับ AI-For-Beginners! เราต้อนรับการแปล การแก้ไขบทเรียน และการแก้ไขรูปแบบ + +## สัญญาอนุญาตผู้ร่วมพัฒนา (CLA) ของ Microsoft + +โครงการนี้เปิดรับการมีส่วนร่วมและข้อเสนอแนะ การมีส่วนร่วมส่วนใหญ่ต้องการให้คุณยอมรับสัญญาอนุญาตผู้ร่วมพัฒนา (CLA) ที่ระบุว่าคุณมีสิทธิ์และได้มอบสิทธิ์แก่เราสำหรับการใช้เนื้อหาที่คุณมีส่วนร่วม สำหรับรายละเอียดเพิ่มเติม โปรดเยี่ยมชม [https://cla.microsoft.com](https://cla.microsoft.com) + +เมื่อคุณส่งคำขอดึงข้อมูล (pull request) CLA-bot จะตรวจสอบโดยอัตโนมัติว่าคุณจำเป็นต้องจัดเตรียม CLA หรือไม่ และจะประดับ PR ตามที่เหมาะสม (เช่น ป้ายชื่อ ความคิดเห็น) เพียงทำตามคำแนะนำที่บอทให้มา คุณจะต้องทำครั้งเดียวเท่านั้นสำหรับทุกที่เก็บข้อมูลที่ใช้ CLA ของเรา + +## วิธีมีส่วนร่วม + +### 1. การแก้ไขตัวสะกด / ข้อผิดพลาดของโค้ด +หากคุณพบตัวสะกดผิดหรือบั๊กในสมุดบันทึก Jupyter หรือไฟล์บทเรียน markdown ใด ๆ: +1. ทำการแยก (fork) ที่เก็บข้อมูล +2. แก้ไขตัวสะกดผิดหรือลิงก์เสีย +3. ส่งคำขอดึงข้อมูล (Pull Request) พร้อมคำอธิบายที่ชัดเจนเกี่ยวกับการแก้ไข + +### 2. การส่งการแปล +เราต้อนรับการแปลบทเรียนเป็นภาษาต่าง ๆ กรุณาวางไฟล์แปลไว้ในไดเรกทอรี `translations/` โดยใช้ชื่อโฟลเดอร์ที่มีอยู่ (ตัวอย่างเช่น `translations/es/`, `translations/pt-BR/`, `translations/zh-CN/`) + +สำหรับรายละเอียดเพิ่มเติม ดูได้ที่ [etc/CONTRIBUTING.md](etc/CONTRIBUTING.md) + +--- + + +**ปฏิเสธความรับผิดชอบ**: +เอกสารนี้ได้รับการแปลโดยใช้บริการแปลภาษา AI [Co-op Translator](https://github.com/Azure/co-op-translator) ขณะที่เราพยายามให้ความถูกต้อง โปรดทราบว่าการแปลโดยอัตโนมัติอาจมีข้อผิดพลาดหรือความไม่ถูกต้อง เอกสารต้นฉบับในภาษาต้นทางควรถูกพิจารณาเป็นแหล่งข้อมูลที่เชื่อถือได้ สำหรับข้อมูลที่สำคัญ แนะนำให้ใช้การแปลโดยมนุษย์มืออาชีพ เราไม่รับผิดชอบต่อความเข้าใจผิดหรือการตีความที่ผิดพลาดที่เกิดขึ้นจากการใช้การแปลนี้ + \ No newline at end of file diff --git a/translations/th/examples/README.md b/translations/th/examples/README.md index d6046b10..08251e96 100644 --- a/translations/th/examples/README.md +++ b/translations/th/examples/README.md @@ -1,27 +1,27 @@ -# ตัวอย่าง AI สำหรับผู้เริ่มต้น +# ตัวอย่าง AI ที่เหมาะสำหรับผู้เริ่มต้น -ยินดีต้อนรับ! ไดเรกทอรีนี้มีตัวอย่างง่ายๆ ที่แยกออกมาเพื่อช่วยให้คุณเริ่มต้นกับ 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 | +| Example | Description | Difficulty | Prerequisites | +|---------|-------------|------------|---------------| +| [Hello AI World](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/01-hello-ai-world.py) | โปรแกรม AI แรกของคุณ - การจดจำรูปแบบง่ายๆ | ⭐ Beginner | พื้นฐาน Python | +| [Simple Neural Network](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/02-simple-neural-network.py) | สร้างโครงข่ายประสาทเทียมจากศูนย์ | ⭐⭐ Beginner+ | Python, คณิตศาสตร์พื้นฐาน | +| [Image Classifier](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/03-image-classifier.ipynb) | จัดหมวดหมู่ภาพด้วยโมเดลที่ผ่านการฝึกมาแล้ว | ⭐⭐ Beginner+ | Python, numpy | +| [Text Sentiment](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/04-text-sentiment.py) | วิเคราะห์อารมณ์ข้อความ (บวก/ลบ) | ⭐⭐ Beginner+ | Python | ## 🚀 เริ่มต้นใช้งาน ### สิ่งที่ต้องเตรียม -ตรวจสอบให้แน่ใจว่าคุณติดตั้ง Python แล้ว (แนะนำเวอร์ชัน 3.8 หรือสูงกว่า) และติดตั้งแพ็กเกจที่จำเป็น: +ตรวจสอบให้แน่ใจว่าคุณได้ติดตั้ง Python แล้ว (แนะนำเวอร์ชัน 3.8 หรือสูงกว่า) ติดตั้งแพ็กเกจที่จำเป็น: ```bash -# For Python scripts +# สำหรับสคริปต์ Python pip install numpy -# For Jupyter notebooks (image classifier) +# สำหรับโน้ตบุ๊ก Jupyter (ตัวจำแนกรูปภาพ) pip install jupyter numpy pillow tensorflow ``` @@ -34,12 +34,12 @@ conda activate ai4beg ### การรันตัวอย่าง -**สำหรับไฟล์ Python (.py):** +**สำหรับสคริปต์ Python (.py files):** ```bash python 01-hello-ai-world.py ``` -**สำหรับ Jupyter notebooks (.ipynb):** +**สำหรับโน้ตบุ๊ก Jupyter (.ipynb files):** ```bash jupyter notebook 03-image-classifier.ipynb ``` @@ -48,38 +48,40 @@ jupyter notebook 03-image-classifier.ipynb เราแนะนำให้ทำตามตัวอย่างตามลำดับ: -1. **เริ่มต้นด้วย "Hello AI World"** - เรียนรู้พื้นฐานของการจดจำรูปแบบ -2. **สร้างเครือข่ายประสาทเทียมแบบง่าย** - เข้าใจการทำงานของเครือข่ายประสาทเทียม -3. **ลองใช้ Image Classifier** - ดูการทำงานของ AI กับภาพจริง -4. **วิเคราะห์ความรู้สึกในข้อความ** - สำรวจการประมวลผลภาษาธรรมชาติ +1. **เริ่มต้นด้วย "Hello AI World"** - เรียนรู้พื้นฐานการจดจำรูปแบบ +2. **สร้างโครงข่ายประสาทเทียมง่ายๆ** - เข้าใจว่าโครงข่ายประสาททำงานอย่างไร +3. **ลองใช้ Image Classifier** - ดู AI ทำงานกับภาพจริง +4. **วิเคราะห์อารมณ์ข้อความ** - สำรวจการประมวลผลภาษาธรรมชาติ ## 💡 เคล็ดลับสำหรับผู้เริ่มต้น -- **อ่านคำอธิบายในโค้ดอย่างละเอียด** - มันอธิบายว่าทุกบรรทัดทำอะไร -- **ทดลอง!** - ลองเปลี่ยนค่าและดูผลลัพธ์ -- **อย่ากังวลหากยังไม่เข้าใจทุกอย่าง** - การเรียนรู้ต้องใช้เวลา +- **อ่านคำอธิบายโค้ดอย่างละเอียด** - เพื่ออธิบายแต่ละบรรทัดว่าทำอะไร +- **ทดลอง!** - ลองเปลี่ยนค่าแล้วดูผลลัพธ์ +- **อย่ากังวลถ้าไม่เข้าใจทุกอย่าง** - การเรียนรู้ต้องใช้เวลา - **ถามคำถาม** - ใช้ [กระดานสนทนา](https://github.com/microsoft/AI-For-Beginners/discussions) ## 🔗 ขั้นตอนถัดไป -หลังจากทำตัวอย่างเหล่านี้เสร็จแล้ว ลองสำรวจหลักสูตรเต็ม: +หลังจากทำตัวอย่างเหล่านี้เสร็จแล้ว ให้สำรวจหลักสูตรเต็ม: - [แนะนำ AI](../lessons/1-Intro/README.md) -- [เครือข่ายประสาทเทียม](../lessons/3-NeuralNetworks/README.md) -- [การมองเห็นด้วยคอมพิวเตอร์](../lessons/4-ComputerVision/README.md) +- [โครงข่ายประสาทเทียม](../lessons/3-NeuralNetworks/README.md) +- [วิสัยทัศน์คอมพิวเตอร์](../lessons/4-ComputerVision/README.md) - [การประมวลผลภาษาธรรมชาติ](../lessons/5-NLP/README.md) ## 🤝 การมีส่วนร่วม พบว่าตัวอย่างเหล่านี้มีประโยชน์? ช่วยเราปรับปรุง: -- รายงานปัญหาหรือเสนอแนะการปรับปรุง +- รายงานปัญหาหรือแนะนำการปรับปรุง - เพิ่มตัวอย่างเพิ่มเติมสำหรับผู้เริ่มต้น - ปรับปรุงเอกสารและคำอธิบาย --- -*จำไว้ว่า: ผู้เชี่ยวชาญทุกคนเคยเป็นผู้เริ่มต้นมาก่อน ขอให้สนุกกับการเรียนรู้! 🎓* +*จำไว้ว่า: ผู้เชี่ยวชาญทุกคนเคยเป็นผู้เริ่มต้นมาก่อน ขอให้เรียนรู้อย่างมีความสุข! 🎓* --- -**ข้อจำกัดความรับผิดชอบ**: -เอกสารนี้ได้รับการแปลโดยใช้บริการแปลภาษา AI [Co-op Translator](https://github.com/Azure/co-op-translator) แม้ว่าเราจะพยายามให้การแปลมีความถูกต้อง แต่โปรดทราบว่าการแปลอัตโนมัติอาจมีข้อผิดพลาดหรือความไม่ถูกต้อง เอกสารต้นฉบับในภาษาต้นทางควรถือเป็นแหล่งข้อมูลที่เชื่อถือได้ สำหรับข้อมูลที่สำคัญ แนะนำให้ใช้บริการแปลภาษามนุษย์ที่เป็นมืออาชีพ เราไม่รับผิดชอบต่อความเข้าใจผิดหรือการตีความผิดที่เกิดจากการใช้การแปลนี้ \ No newline at end of file + +**ปฏิเสธความรับผิดชอบ**: +เอกสารนี้ได้รับการแปลโดยใช้บริการแปลภาษา AI [Co-op Translator](https://github.com/Azure/co-op-translator) ขณะที่เราพยายามให้ความถูกต้อง โปรดทราบว่าการแปลโดยอัตโนมัติอาจมีข้อผิดพลาดหรือความไม่ถูกต้อง เอกสารต้นฉบับในภาษาต้นทางควรถูกพิจารณาเป็นแหล่งข้อมูลที่เชื่อถือได้ สำหรับข้อมูลที่สำคัญ แนะนำให้ใช้การแปลโดยมนุษย์มืออาชีพ เราไม่รับผิดชอบต่อความเข้าใจผิดหรือการตีความที่ผิดพลาดที่เกิดขึ้นจากการใช้การแปลนี้ + \ No newline at end of file diff --git a/translations/th/lessons/0-course-setup/how-to-run.md b/translations/th/lessons/0-course-setup/how-to-run.md index 991fc0e2..a07050ab 100644 --- a/translations/th/lessons/0-course-setup/how-to-run.md +++ b/translations/th/lessons/0-course-setup/how-to-run.md @@ -1,12 +1,12 @@ # วิธีการรันโค้ด -หลักสูตรนี้ประกอบด้วยตัวอย่างที่สามารถรันได้และแลปมากมายที่คุณต้องการรัน ในการที่จะทำเช่นนี้ คุณจะต้องมีความสามารถในการรันโค้ด Python ใน Jupyter Notebooks ซึ่งจัดเตรียมไว้เป็นส่วนหนึ่งของหลักสูตรนี้ คุณมีตัวเลือกหลายอย่างสำหรับการรันโค้ด: +หลักสูตรนี้ประกอบด้วยตัวอย่างและห้องปฏิบัติการที่สามารถรันได้ซึ่งคุณต้องการใช้งาน เพื่อที่จะทำเช่นนี้ คุณต้องมีความสามารถในการรันโค้ด Python ใน Jupyter Notebooks ที่จัดเตรียมไว้เป็นส่วนหนึ่งของหลักสูตรนี้ คุณมีตัวเลือกหลายวิธีในการรันโค้ด: -## รันในเครื่องคอมพิวเตอร์ของคุณ +## รันบนเครื่องของคุณเอง -ในการรันโค้ดในเครื่องคอมพิวเตอร์ของคุณ จำเป็นต้องติดตั้ง Python หนึ่งในคำแนะนำคือการติดตั้ง **[miniconda](https://conda.io/en/latest/miniconda.html)** - เป็นการติดตั้งที่มีขนาดเล็กและรองรับตัวจัดการแพ็คเกจ `conda` สำหรับ **สภาพแวดล้อมจำลอง** Python ที่หลากหลาย +เพื่อรันโค้ดบนเครื่องของคุณเอง จำเป็นต้องติดตั้ง Python แนะนำให้ติดตั้ง **[miniconda](https://conda.io/en/latest/miniconda.html)** ซึ่งเป็นการติดตั้งที่มีขนาดเล็กกว่า และสนับสนุนตัวจัดการแพ็กเกจ `conda` สำหรับสร้าง **สภาพแวดล้อมเสมือน Python** ที่แตกต่างกัน -หลังจากติดตั้ง miniconda แล้ว ให้โคลนรีโพสและสร้างสภาพแวดล้อมจำลองที่จะใช้สำหรับคอร์สนี้: +หลังจากติดตั้ง miniconda แล้ว ให้โคลนรีโพสิตอรีและสร้างสภาพแวดล้อมเสมือนเพื่อใช้ในหลักสูตรนี้: ```bash git clone http://github.com/microsoft/ai-for-beginners @@ -15,19 +15,19 @@ conda env create --name ai4beg --file .devcontainer/environment.yml conda activate ai4beg ``` -### การใช้ Visual Studio Code พร้อม Python Extension +### การใช้ Visual Studio Code กับ Python Extension -หลักสูตรนี้เหมาะสมที่สุดเมื่อเปิดด้วย [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) พร้อม [Python Extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste) +หลักสูตรนี้เหมาะสมที่สุดเมื่อเปิดด้วย [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) พร้อมกับ [Python Extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste) -> **หมายเหตุ**: เมื่อคุณโคลนและเปิดไดเรกทอรีใน VS Code มันจะแนะนำให้คุณติดตั้งส่วนขยาย Python โดยอัตโนมัติ คุณยังต้องติดตั้ง miniconda ตามที่อธิบายข้างต้นด้วย +> **หมายเหตุ**: เมื่อคุณโคลนและเปิดโฟลเดอร์ใน VS Code มันจะเสนอให้ติดตั้งส่วนขยายของ Python โดยอัตโนมัติ คุณต้องติดตั้ง miniconda ตามที่ได้กล่าวไว้ข้างต้นด้วย -> **หมายเหตุ**: หาก VS Code แนะนำให้เปิดรีโพสในคอนเทนเนอร์ใหม่ คุณควรปฏิเสธเพื่อใช้การติดตั้ง Python ในเครื่องของคุณ +> **หมายเหตุ**: หาก VS Code เสนอให้เปิดรีโพสิตอรีใน container คุณควรปฏิเสธเพื่อใช้การติดตั้ง Python บนเครื่องของคุณเอง -### การใช้ Jupyter ในเบราว์เซอร์ +### การใช้ Jupyter ผ่านเบราว์เซอร์ -คุณสามารถใช้สภาพแวดล้อม Jupyter ผ่านเบราว์เซอร์ในเครื่องคอมพิวเตอร์ของคุณเองได้ ทั้ง Jupyter แบบคลาสสิกและ JupyterHub ให้สภาพแวดล้อมการพัฒนาที่สะดวกสบายพร้อมการเติมข้อความอัตโนมัติ การเน้นโค้ด ฯลฯ +คุณสามารถใช้สภาพแวดล้อม Jupyter ผ่านเบราว์เซอร์บนเครื่องของคุณเองได้ Jupyter แบบคลาสสิกและ JupyterHub ต่างก็ให้สภาพแวดล้อมการพัฒนาที่สะดวกพร้อมฟีเจอร์ช่วยเติมโค้ดและไฮไลต์โค้ด -เพื่อเริ่มต้น Jupyter ในเครื่อง ให้ไปที่ไดเรกทอรีของคอร์ส และรันคำสั่ง: +ในการเริ่ม Jupyter บนเครื่องของคุณ ให้ไปที่ไดเรกทอรีของหลักสูตร และรันคำสั่ง: ```bash jupyter notebook @@ -36,37 +36,36 @@ jupyter notebook ```bash jupyterhub ``` -จากนั้นคุณสามารถไปที่ไฟล์ `.ipynb` ใดๆ เปิดและเริ่มทำงานได้เลย +คุณก็สามารถไปยังไฟล์ `.ipynb` ใดก็ได้ เปิดไฟล์และเริ่มทำงานได้ทันที -### การรันในคอนเทนเนอร์ +### การรันใน container -ทางเลือกหนึ่งแทนการติดตั้ง Python คือการรันโค้ดในคอนเทนเนอร์ เนื่องจากรีโพสของเรามีโฟลเดอร์ `.devcontainer` พิเศษที่แนะนำวิธีการสร้างคอนเทนเนอร์สำหรับรีโพสนี้ VS Code จึงมีตัวเลือกให้เปิดโค้ดใหม่ในคอนเทนเนอร์ การนี้จำเป็นต้องติดตั้ง Docker และมีความซับซ้อนมากขึ้น เราจึงแนะนำสำหรับผู้ใช้ที่มีประสบการณ์มากกว่า +ทางเลือกหนึ่งแทนการติดตั้ง Python คือการรันโค้ดใน container เนื่องจากรีโพสิตอรีของเรามีโฟลเดอร์ `.devcontainer` พิเศษที่แนะนำวิธีสร้าง container สำหรับรีโปนี้ VS Code จึงมีโอกาสให้เปิดโค้ดใน container ได้ทันที ซึ่งต้องติดตั้ง Docker และเป็นขั้นตอนที่ซับซ้อนกว่า ดังนั้นจึงแนะนำสำหรับผู้ใช้ที่มีประสบการณ์มากกว่า -## การรันในคลาวด์ +## การรันบนคลาวด์ -หากคุณไม่ต้องการติดตั้ง Python ในเครื่อง และมีการเข้าถึงทรัพยากรคลาวด์ บางทางเลือกที่ดีคือการรันโค้ดในคลาวด์ คุณมีหลายวิธีในการทำเช่นนี้: +หากคุณไม่ต้องการติดตั้ง Python บนเครื่องและเข้าถึงทรัพยากรคลาวด์ได้ ทางเลือกที่ดีคือรันโค้ดบนคลาวด์ มีหลายวิธีที่คุณสามารถทำได้: -* ใช้ **[GitHub Codespaces](https://github.com/features/codespaces)** ซึ่งเป็นสภาพแวดล้อมจำลองที่สร้างขึ้นให้คุณบน GitHub สามารถเข้าถึงผ่านอินเทอร์เฟซ VS Code บนเบราว์เซอร์ หากคุณเข้าถึง Codespaces ได้ คุณสามารถคลิกปุ่ม **Code** ในรีโพส เริ่มต้น codespace และเริ่มรันได้ทันที +* ใช้ **[GitHub Codespaces](https://github.com/features/codespaces)** ซึ่งเป็นสภาพแวดล้อมเสมือนที่สร้างสำหรับคุณบน GitHub ซึ่งเข้าถึงผ่านอินเทอร์เฟซเบราว์เซอร์ VS Code หากคุณมีสิทธิ์ใช้งาน Codespaces คุณเพียงคลิกที่ปุ่ม **Code** ในรีโป รัน Codespace และเริ่มใช้งานได้ทันที +* ใช้ **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) ให้บริการทรัพยากรคอมพิวเตอร์ฟรีบนคลาวด์สำหรับผู้ใช้งานอย่างคุณให้ทดสอบโค้ดบน GitHub โดยมีปุ่มที่หน้าหลักเปิดรีโพสิตอรีใน Binder ซึ่งจะสร้าง container เบื้องหลังและเริ่มเว็บอินเทอร์เฟซ Jupyter ให้คุณอย่างราบรื่น -* ใช้ **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)** [Binder](https://mybinder.org) มีทรัพยากรคอมพิวเตอร์ฟรีบนคลาวด์สำหรับผู้ใช้ทั่วไปทดสอบโค้ดบน GitHub มีปุ่มที่หน้าแรกเพื่อเปิดรีโพสใน Binder - ซึ่งจะนำคุณไปที่เว็บไซต์ binder แบบรวดเร็ว จะสร้างคอนเทนเนอร์พื้นฐานแล้วเปิดอินเทอร์เฟซ Jupyter ให้คุณใช้งานได้อย่างราบรื่น +> **หมายเหตุ**: เพื่อป้องกันการใช้งานผิด Binder จำกัดการเข้าถึงทรัพยากรเว็บบางส่วน ซึ่งอาจทำให้โค้ดบางส่วนที่ดึงโมเดลและ/หรือชุดข้อมูลจากอินเทอร์เน็ตสาธารณะใช้งานไม่ได้ คุณอาจต้องหาวิธีแก้ไข นอกจากนี้ทรัพยากรที่ Binder ให้มานั้นพื้นฐานมาก การฝึกโมเดลจะช้า โดยเฉพาะบทเรียนที่ซับซ้อนในภายหลัง -> **หมายเหตุ**: เพื่อป้องกันการใช้ในทางผิด Binder จำกัดการเข้าถึงบางทรัพยากรเว็บไซต์ อาจทำให้โค้ดบางส่วนทำงานไม่ได้ หากโค้ดดึงโมเดลและ/หรือชุดข้อมูลจากอินเทอร์เน็ตสาธารณะ คุณอาจต้องหาทางแก้ไข นอกจากนี้ ทรัพยากรที่ Binder ให้มานั้นพื้นฐานมาก ดังนั้นการเทรนจะช้า โดยเฉพาะบทเรียนที่ซับซ้อนในช่วงหลัง +## การรันบนคลาวด์พร้อม GPU -## การรันในคลาวด์ด้วย GPU +บทเรียนบางบทในหลักสูตรนี้จะได้ประโยชน์มากจากการสนับสนุน GPU เช่น การฝึกโมเดลอาจช้ามากถ้าไม่มี GPU คุณสามารถทำตามตัวเลือกต่อไปนี้ได้ โดยเฉพาะอย่างยิ่งหากคุณมีสิทธิ์ใช้งานคลาวด์ผ่าน [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste) หรือผ่านสถาบันของคุณ: -บทเรียนบางบทในหลักสูตรนี้จะได้ประโยชน์อย่างมากจากการรองรับ GPU ตัวอย่างเช่นการเทรนโมเดลที่อาจช้ามากถ้าไม่มี GPU คุณมีตัวเลือกบางอย่าง โดยเฉพาะถ้าคุณเข้าถึงคลาวด์ผ่าน [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste) หรือผ่านสถาบันของคุณ: +* สร้าง [Data Science Virtual Machine](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) และเชื่อมต่อกับมันผ่าน Jupyter คุณสามารถโคลนรีโปลงไปในเครื่องนี้และเริ่มเรียนรู้ได้ NC-series VMs สนับสนุน GPU -* สร้าง [Data Science Virtual Machine](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) และเชื่อมต่อผ่าน Jupyter จากนั้นคุณสามารถโคลนรีโพสบนเครื่องนั้นและเริ่มเรียนรู้ VM สาย NC-series มีการรองรับ GPU +> **หมายเหตุ**: บางการสมัครสมาชิก รวมถึง Azure for Students ไม่ได้เปิดใช้งาน GPU โดยตรง คุณอาจต้องขอเพิ่มคอร์ GPU ผ่านคำขอสนับสนุนทางเทคนิค -> **หมายเหตุ**: บัญชีบางประเภท เช่น Azure for Students ไม่ได้รองรับ GPU โดยตรง คุณอาจต้องยื่นคำขอขอทรัพยากร GPU เพิ่มเติมผ่านฝ่ายสนับสนุนทางเทคนิค +* สร้าง [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) แล้วใช้ฟีเจอร์ Notebook ที่นั่น [วิดีโอนี้](https://azure-for-academics.github.io/quickstart/azureml-papers/) แสดงวิธีโคลนรีโพสิตอรีเข้าโน้ตบุ๊ก Azure ML และเริ่มใช้งาน -* สร้าง [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) แล้วใช้ฟีเจอร์ Notebook ที่นั่น [วิดีโอนี้](https://azure-for-academics.github.io/quickstart/azureml-papers/) แสดงวิธีโคลนรีโพสเข้า Azure ML notebook และเริ่มใช้งาน - -คุณยังสามารถใช้ Google Colab ซึ่งมาพร้อม GPU ฟรีบางส่วน และอัปโหลด Jupyter Notebooks ไปรันทีละไฟล์ได้อีกด้วย +คุณยังสามารถใช้ Google Colab ซึ่งมี GPU ฟรีให้ใช้งานบ้าง และอัปโหลด Jupyter Notebooks ไปที่นั่นเพื่อรันทีละไฟล์ได้ --- -**ข้อจำกัดความรับผิดชอบ**: -เอกสารนี้ได้รับการแปลโดยใช้บริการแปลภาษาอัตโนมัติ [Co-op Translator](https://github.com/Azure/co-op-translator) แม้ว่าเราจะพยายามให้ความถูกต้องสูงสุด แต่โปรดทราบว่าการแปลอัตโนมัติอาจมีข้อผิดพลาดหรือความไม่แม่นยำ เอกสารต้นฉบับในภาษาต้นฉบับจะถือเป็นแหล่งข้อมูลที่เชื่อถือได้ สำหรับข้อมูลที่สำคัญ การแปลโดยมนุษย์มืออาชีพจึงเป็นที่แนะนำ เราไม่รับผิดชอบต่อความเข้าใจผิดหรือการตีความที่ผิดพลาดใด ๆ ที่เกิดจากการใช้การแปลนี้ +**ปฏิเสธความรับผิดชอบ**: +เอกสารนี้ได้รับการแปลโดยใช้บริการแปลภาษา AI [Co-op Translator](https://github.com/Azure/co-op-translator) ขณะที่เราพยายามให้ความถูกต้อง โปรดทราบว่าการแปลโดยอัตโนมัติอาจมีข้อผิดพลาดหรือความไม่ถูกต้อง เอกสารต้นฉบับในภาษาต้นทางควรถูกพิจารณาเป็นแหล่งข้อมูลที่เชื่อถือได้ สำหรับข้อมูลที่สำคัญ แนะนำให้ใช้การแปลโดยมนุษย์มืออาชีพ เราไม่รับผิดชอบต่อความเข้าใจผิดหรือการตีความที่ผิดพลาดที่เกิดขึ้นจากการใช้การแปลนี้ \ No newline at end of file diff --git a/translations/th/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb b/translations/th/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb index 8c999603..adea9ad9 100644 --- a/translations/th/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb +++ b/translations/th/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb @@ -4,11 +4,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# โมเดลที่ผ่านการฝึกฝนล่วงหน้าและการเรียนรู้แบบถ่ายโอน\n", + "# โมเดลที่ผ่านการฝึกมาแล้วและการเรียนรู้แบบถ่ายโอน\n", "\n", - "การฝึกฝน CNNs อาจใช้เวลานานมาก และต้องการข้อมูลจำนวนมากสำหรับงานนี้ อย่างไรก็ตาม เวลาส่วนใหญ่ถูกใช้ไปกับการเรียนรู้ตัวกรองระดับต่ำที่ดีที่สุดที่เครือข่ายใช้ในการดึงรูปแบบจากภาพ คำถามที่เกิดขึ้นตามธรรมชาติคือ - เราสามารถใช้เครือข่ายประสาทที่ฝึกฝนบนชุดข้อมูลหนึ่งและปรับให้เข้ากับการจำแนกภาพที่แตกต่างกันโดยไม่ต้องผ่านกระบวนการฝึกฝนทั้งหมดได้หรือไม่?\n", + "การฝึก CNN อาจใช้เวลานาน และต้องการข้อมูลจำนวนมากสำหรับงานนั้น อย่างไรก็ตาม ส่วนใหญ่ของเวลาจะถูกใช้ไปกับการเรียนรู้ฟิลเตอร์ระดับต่ำที่ดีที่สุดซึ่งเครือข่ายใช้ในการดึงรูปแบบจากภาพ คำถามที่เกิดขึ้นตามธรรมชาติคือ – เราสามารถใช้เครือข่ายประสาทที่ผ่านการฝึกในชุดข้อมูลหนึ่งแล้วนำมาปรับใช้เพื่อจัดประเภทภาพต่าง ๆ โดยไม่ต้องผ่านกระบวนการฝึกเต็มรูปแบบได้หรือไม่?\n", "\n", - "วิธีการนี้เรียกว่า **การเรียนรู้แบบถ่ายโอน** เพราะเราโอนความรู้บางส่วนจากโมเดลเครือข่ายประสาทหนึ่งไปยังอีกโมเดลหนึ่ง ในการเรียนรู้แบบถ่ายโอน เรามักจะเริ่มต้นด้วยโมเดลที่ผ่านการฝึกฝนล่วงหน้า ซึ่งได้รับการฝึกฝนบนชุดข้อมูลภาพขนาดใหญ่ เช่น **ImageNet** โมเดลเหล่านี้สามารถดึงคุณลักษณะต่าง ๆ จากภาพทั่วไปได้ดีอยู่แล้ว และในหลายกรณี เพียงแค่สร้างตัวจำแนกบนคุณลักษณะที่ดึงออกมาเหล่านั้นก็สามารถให้ผลลัพธ์ที่ดีได้\n" + "วิธีการนี้เรียกว่า **การเรียนรู้แบบถ่ายโอน** เพราะเราถ่ายโอนความรู้บางส่วนจากโมเดลเครือข่ายประสาทหนึ่งไปยังอีกโมเดลหนึ่ง ในการเรียนรู้แบบถ่ายโอน เรามักจะเริ่มต้นด้วยโมเดลที่ผ่านการฝึกมาแล้ว ซึ่งได้รับการฝึกบนชุดข้อมูลภาพขนาดใหญ่ เช่น **ImageNet** โมเดลเหล่านั้นสามารถทำงานได้ดีในการดึงคุณลักษณะที่แตกต่างกันจากภาพทั่วไป และในหลายกรณี การสร้างตัวจำแนกชั้นบนคุณลักษณะที่ดึงออกมาเหล่านั้นเพียงอย่างเดียวก็สามารถให้ผลลัพธ์ที่ดีได้\n" ] }, { @@ -29,11 +29,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## ชุดข้อมูลแมวและสุนัข\n", + "## ชุดข้อมูล แมว vs สุนัข\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 Cats vs. Dogs Dataset](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", "\n", - "มาดาวน์โหลดชุดข้อมูลนี้และแตกไฟล์ไปยังไดเรกทอรี `data` (กระบวนการนี้อาจใช้เวลาสักครู่!):\n" + "มาดาวน์โหลดชุดข้อมูลนี้และแตกไฟล์เก็บไว้ในไดเรกทอรี `data` กัน (กระบวนการนี้อาจใช้เวลาสักระยะ!):\n" ] }, { @@ -64,7 +64,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "น่าเสียดายที่มีไฟล์ภาพที่เสียหายในชุดข้อมูล เราจำเป็นต้องทำความสะอาดอย่างรวดเร็วเพื่อตรวจสอบไฟล์ที่เสีย เพื่อไม่ให้รบกวนบทเรียนนี้ เราได้ย้ายโค้ดสำหรับตรวจสอบชุดข้อมูลไปไว้ในโมดูล\n" + "น่าเสียดายที่มีไฟล์รูปภาพบางไฟล์ในชุดข้อมูลที่เสียหาย เราจำเป็นต้องทำความสะอาดอย่างรวดเร็วเพื่อตรวจสอบไฟล์ที่เสียหาย เพื่อไม่ให้กระทบกับบทเรียนนี้ เราจึงย้ายโค้ดตรวจสอบชุดข้อมูลไปไว้ในโมดูล\n" ] }, { @@ -335,11 +335,11 @@ "source": [ "## การโหลดชุดข้อมูล\n", "\n", - "ในตัวอย่างก่อนหน้านี้ เราได้โหลดชุดข้อมูลที่มีอยู่ใน Keras อยู่แล้ว ตอนนี้เรากำลังจะจัดการกับชุดข้อมูลของเราเอง ซึ่งเราจำเป็นต้องโหลดจากไดเรกทอรีที่มีภาพอยู่\n", + "ในตัวอย่างก่อนหน้านี้ เราได้โหลดชุดข้อมูลที่ฝังอยู่ใน Keras แล้ว ตอนนี้เรากำลังจะจัดการกับชุดข้อมูลของเราเอง ซึ่งเราต้องโหลดจากไดเรกทอรีของรูปภาพ\n", "\n", - "ในชีวิตจริง ขนาดของชุดข้อมูลภาพอาจมีขนาดใหญ่มาก และเราไม่สามารถพึ่งพาการโหลดข้อมูลทั้งหมดเข้าไปในหน่วยความจำได้ ดังนั้น ชุดข้อมูลมักจะถูกแสดงผลในรูปแบบของ **generators** ที่สามารถคืนค่าข้อมูลเป็นชุดย่อย (minibatches) ที่เหมาะสมสำหรับการฝึกโมเดล\n", + "ในชีวิตจริง ขนาดของชุดข้อมูลภาพอาจมีขนาดใหญ่ และเราไม่สามารถมั่นใจได้ว่าข้อมูลทั้งหมดจะพอดีกับหน่วยความจำ ดังนั้น ชุดข้อมูลจึงมักจะแสดงเป็น **ตัวสร้างข้อมูล (generators)** ที่สามารถส่งคืนข้อมูลเป็นมินิบัทช์ที่เหมาะกับการฝึกสอนได้\n", "\n", - "สำหรับการจัดการกับการจำแนกประเภทของภาพ Keras มีฟังก์ชันพิเศษชื่อ `image_dataset_from_directory` ซึ่งสามารถโหลดภาพจากไดเรกทอรีย่อยที่สอดคล้องกับคลาสต่าง ๆ ฟังก์ชันนี้ยังช่วยจัดการการปรับขนาดของภาพ และยังสามารถแบ่งชุดข้อมูลออกเป็นชุดฝึก (train) และชุดทดสอบ (test) ได้อีกด้วย:\n" + "ในการจัดการกับการจำแนกประเภทภาพ Keras มีฟังก์ชันพิเศษชื่อ `image_dataset_from_directory` ซึ่งสามารถโหลดภาพจากไดเรกทอรีย่อยที่สอดคล้องกับคลาสต่างๆ ฟังก์ชันนี้ยังดูแลการปรับขนาดภาพ และยังสามารถแบ่งชุดข้อมูลเป็นชุดฝึกและชุดทดสอบได้อีกด้วย:\n" ] }, { @@ -383,9 +383,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "สิ่งสำคัญคือต้องตั้งค่า `seed` ให้เหมือนกันสำหรับการเรียกใช้งานทั้งสองครั้ง เพราะมันมีผลต่อการแบ่งภาพระหว่างชุดข้อมูลการฝึก (train) และชุดข้อมูลการทดสอบ (test)\n", + "เป็นเรื่องสำคัญที่จะต้องตั้งค่า `seed` เดียวกันสำหรับทั้งสองการเรียกใช้ เพราะมันมีผลต่อการแบ่งภาพระหว่างชุดข้อมูลฝึกและทดสอบ\n", "\n", - "ชุดข้อมูลจะดึงชื่อคลาสจากไดเรกทอรีโดยอัตโนมัติ และคุณสามารถเข้าถึงชื่อเหล่านั้นได้หากจำเป็นโดยการเรียก:\n" + "ชุดข้อมูลจะเลือกชื่อชั้นเรียนจากไดเรกทอรีโดยอัตโนมัติ และคุณสามารถเข้าถึงได้หากต้องการโดยการเรียก:\n" ] }, { @@ -412,7 +412,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "ชุดข้อมูลที่เราได้รับสามารถส่งตรงไปยังฟังก์ชัน `fit` เพื่อฝึกอบรมโมเดลได้ โดยชุดข้อมูลเหล่านี้ประกอบด้วยภาพและป้ายกำกับที่สอดคล้องกัน ซึ่งสามารถวนซ้ำได้โดยใช้โครงสร้างดังต่อไปนี้:\n" + "ชุดข้อมูลที่เราได้รับสามารถส่งตรงไปยังฟังก์ชัน `fit` เพื่อฝึกโมเดลได้ พวกมันประกอบด้วยทั้งภาพที่เกี่ยวข้องและป้ายกำกับ ซึ่งสามารถวนซ้ำได้โดยใช้โครงสร้างดังต่อไปนี้:\n" ] }, { @@ -453,16 +453,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "> **หมายเหตุ**: รูปภาพทั้งหมดในชุดข้อมูลแสดงเป็นเทนเซอร์แบบจุดลอยตัวที่มีช่วงค่า 0-255 ก่อนที่จะส่งผ่านไปยังโครงข่ายประสาทเทียม เราจำเป็นต้องปรับค่าสเกลให้อยู่ในช่วง 0-1 เมื่อทำการพล็อตรูปภาพ เราจำเป็นต้องทำเช่นเดียวกัน หรือแปลงค่าเป็นประเภท `int` (ซึ่งเราได้ทำในโค้ดด้านบน) เพื่อแสดงให้ `matplotlib` ทราบว่าเราต้องการพล็อตรูปภาพต้นฉบับที่ไม่ได้ปรับสเกล\n" + "> **หมายเหตุ**: รูปภาพทั้งหมดในชุดข้อมูลจะแสดงเป็นเทนเซอร์แบบจุดทศนิยมที่มีช่วงค่า 0-255 ก่อนที่จะส่งผ่านเข้าเครือข่ายประสาทเทียม เราจำเป็นต้องปรับขนาดค่าพวกนั้นให้อยู่ในช่วง 0-1 เมื่อทำการพล็อตรูปภาพ เราจำเป็นต้องทำเช่นเดียวกัน หรือแปลงค่าเป็นชนิด `int` (ซึ่งเราได้ทำในโค้ดด้านบน) เพื่อแสดงให้ `matplotlib` เห็นว่าเราต้องการพล็อตภาพต้นฉบับที่ยังไม่ถูกปรับขนาด\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## โมเดลที่ผ่านการฝึกมาแล้ว\n", + "## แบบจำลองที่ผ่านการฝึกฝนล่วงหน้า\n", "\n", - "สำหรับงานจำแนกภาพหลายๆ งาน คุณสามารถหาโมเดลเครือข่ายประสาทที่ผ่านการฝึกมาแล้วได้ โมเดลเหล่านี้จำนวนมากสามารถใช้งานได้ใน `keras.applications` และยังมีโมเดลอีกมากมายที่สามารถหาได้บนอินเทอร์เน็ต ลองมาดูวิธีการโหลดและใช้งานโมเดล VGG-16 ที่ง่ายที่สุด:\n" + "สำหรับงานจำแนกรูปภาพหลาย ๆ งาน เราสามารถค้นหาแบบจำลองเครือข่ายประสาทที่ผ่านการฝึกฝนล่วงหน้าได้ แบบจำลองหลายแบบเหล่านั้นมีให้ใช้งานภายใน namespace `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", @@ -510,17 +520,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "มีสิ่งสำคัญบางอย่างที่ควรทราบดังนี้:\n", - "* ก่อนที่จะส่งข้อมูลเข้าไปยังเครือข่ายที่ถูกฝึกมาแล้ว จะต้องมีการประมวลผลล่วงหน้าในรูปแบบที่กำหนดไว้ก่อน โดยสามารถทำได้ผ่านการเรียกใช้ฟังก์ชัน `preprocess_input` ซึ่งรับข้อมูลเป็นชุดของภาพ และส่งคืนภาพที่ผ่านการประมวลผลแล้ว ในกรณีของ VGG-16 ภาพจะถูกปรับให้เป็นค่ามาตรฐาน และมีการลบค่ามาตรฐานเฉลี่ยที่กำหนดไว้ล่วงหน้าสำหรับแต่ละช่องสัญญาณออกไป นั่นเป็นเพราะว่า VGG-16 ได้รับการฝึกฝนมาโดยใช้การประมวลผลล่วงหน้าในลักษณะนี้\n", - "* เครือข่ายประสาทจะถูกนำไปใช้กับชุดข้อมูลที่ป้อนเข้า และผลลัพธ์ที่ได้จะเป็นชุดของเทนเซอร์ที่มี 1000 องค์ประกอบ ซึ่งแสดงถึงความน่าจะเป็นของแต่ละคลาส เราสามารถหาหมายเลขคลาสที่มีความน่าจะเป็นสูงสุดได้โดยการเรียกใช้ `argmax` บนเทนเซอร์นี้\n", - "* ผลลัพธ์ที่ได้คือ [หมายเลขของคลาส `ImageNet`](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a) เพื่อให้เข้าใจผลลัพธ์นี้ เราสามารถใช้ฟังก์ชัน `decode_predictions` ซึ่งจะส่งคืนคลาสที่มีความน่าจะเป็นสูงสุด n อันดับ พร้อมกับชื่อของคลาสเหล่านั้น\n" + "มีบางสิ่งที่สำคัญอยู่ที่นี่:\n", + "* ก่อนที่จะส่งอินพุตไปยังเครือข่ายที่ผ่านการฝึกมาแล้ว ต้องมีการเตรียมข้อมูลล่วงหน้าในรูปแบบที่กำหนดไว้ โดยจะเรียกฟังก์ชัน `preprocess_input` ที่รับชุดรูปภาพแล้วคืนค่ารูปแบบที่ผ่านการประมวลผล ในกรณีของ VGG-16 รูปภาพจะถูกทำให้เป็นค่าปกติ และจะถูกลบค่าค่าเฉลี่ยที่กำหนดไว้ล่วงหน้าสำหรับแต่ละช่องสี นั่นเป็นเพราะว่า VGG-16 ถูกฝึกด้วยการเตรียมข้อมูลล่วงหน้านี้ตั้งแต่แรก\n", + "* เครือข่ายประสาทเทียมจะถูกใช้กับชุดอินพุต และเราจะได้รับผลลัพธ์เป็นชุดของเทนเซอร์ที่มี 1000 องค์ประกอบ แสดงความน่าจะเป็นของแต่ละคลาส เราสามารถหาจำนวนคลาสที่น่าจะเป็นไปได้มากที่สุดโดยการเรียกใช้ `argmax` บนเทนเซอร์นี้\n", + "* ผลลัพธ์ที่ได้คือ [หมายเลขของคลาส `ImageNet`](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a) เพื่อทำความเข้าใจผลลัพธ์นี้ เราสามารถใช้ฟังก์ชัน `decode_predictions` ที่จะคืนค่าคลาสที่มีอันดับต้น ๆ พร้อมกับชื่อของพวกมัน\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "มาดูสถาปัตยกรรมของเครือข่าย VGG-16 กันด้วย:\n" + "มาดูสถาปัตยกรรมของเครือข่าย VGG-16 กันด้วย: \n" ] }, { @@ -599,7 +609,7 @@ "source": [ "## การคำนวณด้วย GPU\n", "\n", - "เครือข่ายประสาทเทียมเชิงลึก เช่น VGG-16 และสถาปัตยกรรมที่ทันสมัยอื่น ๆ ต้องการพลังการประมวลผลค่อนข้างมากในการทำงาน การใช้การเร่งความเร็วด้วย GPU จึงเป็นทางเลือกที่สมเหตุสมผลหากมีให้ใช้งาน โชคดีที่ Keras จะเพิ่มความเร็วในการคำนวณบน GPU โดยอัตโนมัติหากมี GPU ให้ใช้งาน เราสามารถตรวจสอบได้ว่า Tensorflow สามารถใช้ GPU ได้หรือไม่โดยใช้โค้ดต่อไปนี้:\n" + "เครือข่ายประสาทลึก เช่น VGG-16 และสถาปัตยกรรมที่ทันสมัยอื่น ๆ ต้องการกำลังการคำนวณมากพอสมควรในการทำงาน จึงสมเหตุสมผลที่จะใช้การเร่งด้วย GPU หากมีให้ใช้งาน โชคดีที่ Keras จะเร่งความเร็วการคำนวณบน GPU ให้อัตโนมัติถ้ามีให้ใช้งาน เราสามารถตรวจสอบว่า Tensorflow สามารถใช้ GPU ได้หรือไม่โดยใช้โค้ดดังนี้:\n" ] }, { @@ -626,9 +636,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## การดึงคุณลักษณะจาก VGG\n", "\n", - "หากเราต้องการใช้ VGG-16 เพื่อดึงคุณลักษณะจากภาพของเรา เราจำเป็นต้องใช้โมเดลที่ไม่มีเลเยอร์การจัดประเภทขั้นสุดท้าย เราสามารถสร้างโมเดล VGG-16 โดยไม่มีเลเยอร์ด้านบนได้ด้วยโค้ดนี้:\n" + "## การสกัดคุณลักษณะของ VGG\n", + "\n", + "ถ้าเราต้องการใช้ VGG-16 เพื่อสกัดคุณลักษณะจากภาพของเรา เราจำเป็นต้องใช้โมเดลโดยไม่มีชั้นการจำแนกประเภทสุดท้าย เราสามารถสร้างโมเดล VGG-16 โดยไม่มีชั้นบนสุดได้ด้วยโค้ดนี้:\n" ] }, { @@ -680,9 +691,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "ขนาดของเทนเซอร์คุณลักษณะคือ 7x7x512 แต่เพื่อให้สามารถมองเห็นได้ เราจำเป็นต้องปรับรูปแบบให้เป็น 2D\n", + "มิติของเทนเซอร์ฟีเจอร์คือ 7x7x512 แต่เพื่อให้เห็นภาพ เราต้องปรับรูปร่างให้เป็นรูปแบบ 2 มิติ\n", "\n", - "ตอนนี้ลองมาดูกันว่าคุณลักษณะเหล่านี้สามารถนำมาใช้ในการจำแนกภาพได้หรือไม่ เราจะเลือกภาพบางส่วนด้วยตนเอง (50 minibatches ในกรณีนี้) และคำนวณเวกเตอร์คุณลักษณะล่วงหน้า เราสามารถใช้ API **dataset** ของ Tensorflow เพื่อทำสิ่งนี้ ฟังก์ชัน `map` จะรับ dataset และใช้ lambda-function ที่กำหนดเพื่อแปลงข้อมูล เราใช้กลไกนี้เพื่อสร้าง dataset ใหม่ `ds_features_train` และ `ds_features_test` ซึ่งมีคุณลักษณะที่สกัดจาก VGG แทนที่จะเป็นภาพต้นฉบับ\n" + "ตอนนี้ลองดูว่าฟีเจอร์เหล่านั้นสามารถใช้จัดประเภทภาพได้หรือไม่ เรามาดึงส่วนหนึ่งของภาพ (50 มินิแบตช์ ในกรณีของเรา) และคำนวณเวกเตอร์ฟีเจอร์ของพวกมันล่วงหน้า เราสามารถใช้ Tensorflow **dataset** API เพื่อทำเช่นนั้น ฟังก์ชัน `map` จะรับ dataset และใช้ฟังก์ชันแลมบ์ดาที่กำหนดเพื่อแปลงมัน เราใช้กลไกนี้เพื่อสร้าง datasets ใหม่ คือ `ds_features_train` และ `ds_features_test` ที่ประกอบด้วยฟีเจอร์ที่สกัดโดย VGG แทนภาพต้นฉบับ\n" ] }, { @@ -712,9 +723,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "เราใช้คำสั่ง `.take(50)` เพื่อจำกัดขนาดของชุดข้อมูล เพื่อเพิ่มความเร็วในการสาธิต แน่นอนว่าคุณสามารถทดลองทำการทดลองนี้กับชุดข้อมูลทั้งหมดได้\n", + "เราใช้การก่อสร้าง `.take(50)` เพื่อจำกัดขนาดชุดข้อมูล เพื่อเร่งความเร็วในการสาธิตของเรา แน่นอนว่าคุณสามารถทดลองนี้กับชุดข้อมูลทั้งหมดได้\n", "\n", - "ตอนนี้เรามีชุดข้อมูลที่มีคุณลักษณะที่ถูกดึงออกมาแล้ว เราสามารถฝึกตัวจำแนกแบบ dense อย่างง่ายเพื่อแยกแยะระหว่างแมวและสุนัขได้ เครือข่ายนี้จะรับเวกเตอร์คุณลักษณะที่มีรูปร่าง (7,7,512) และสร้างผลลัพธ์หนึ่งค่า ซึ่งสอดคล้องกับแมวหรือสุนัข เนื่องจากเป็นการจำแนกประเภทแบบสองกลุ่ม เราจึงใช้ฟังก์ชันการกระตุ้น `sigmoid` และการสูญเสีย `binary_crossentropy`\n" + "ตอนนี้เรามีชุดข้อมูลที่มีคุณลักษณะที่ดึงมาแล้ว เราสามารถฝึกตัวจำแนกแบบหนาแน่นง่าย ๆ เพื่อแยกระหว่างแมวกับสุนัข เครือข่ายนี้จะรับเวกเตอร์คุณลักษณะรูปร่าง (7,7,512) และสร้างผลลัพธ์หนึ่งค่า ซึ่งสอดคล้องกับสุนัขหรือแมว เนื่องจากเป็นการจำแนกแบบสองคลาส เราจึงใช้ฟังก์ชันกระตุ้น `sigmoid` และการสูญเสีย `binary_crossentropy`\n" ] }, { @@ -743,13 +754,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "ผลลัพธ์ยอดเยี่ยมมาก เราสามารถแยกความแตกต่างระหว่างแมวและสุนัขได้ด้วยความแม่นยำเกือบ 95%! อย่างไรก็ตาม เราได้ทดสอบวิธีนี้กับเพียงแค่บางส่วนของภาพทั้งหมดเท่านั้น เนื่องจากการสกัดคุณสมบัติด้วยมือดูเหมือนจะใช้เวลามาก\n", + "ผลลัพธ์ดีมาก เราสามารถแยกความแตกต่างระหว่างแมวกับสุนัขได้ด้วยความน่าจะเป็นเกือบ 95%! อย่างไรก็ตาม เราได้ทดสอบวิธีนี้เพียงส่วนย่อยของภาพทั้งหมดเท่านั้น เพราะการสกัดคุณลักษณะด้วยตนเองดูเหมือนว่าจะใช้เวลามาก\n", "\n", - "## การใช้ Transfer Learning ด้วยเครือข่าย VGG หนึ่งตัว\n", + "## การเรียนรู้แบบถ่ายโอนโดยใช้เครือข่าย VGG หนึ่งชุด\n", "\n", - "เรายังสามารถหลีกเลี่ยงการคำนวณคุณสมบัติด้วยมือได้ โดยใช้เครือข่าย VGG-16 ดั้งเดิมทั้งตัวในระหว่างการฝึก โดยเพิ่มตัวสกัดคุณสมบัติเป็นเลเยอร์แรกในเครือข่ายของเรา\n", + "เรายังสามารถหลีกเลี่ยงการคำนวณคุณลักษณะล่วงหน้าแบบแมนนวลโดยใช้เครือข่าย VGG-16 ดั้งเดิมเป็นองค์รวมในระหว่างการฝึก โดยการเพิ่มตัวสกัดคุณลักษณะให้กับเครือข่ายของเราเป็นเลเยอร์แรก\n", "\n", - "ความพิเศษของสถาปัตยกรรม Keras คือโมเดล VGG-16 ที่เราได้กำหนดไว้ข้างต้นสามารถนำมาใช้เป็นเลเยอร์ในเครือข่ายประสาทเทียมอื่นได้ด้วย! เราเพียงแค่สร้างเครือข่ายที่มีตัวจัดประเภทแบบ dense อยู่ด้านบน และฝึกเครือข่ายทั้งหมดโดยใช้ back propagation\n" + "ความงดงามของสถาปัตยกรรม Keras คือ โมเดล VGG-16 ที่เราได้กำหนดไว้ข้างต้นสามารถใช้เป็นเลเยอร์ในเครือข่ายประสาทอื่นได้! เราเพียงแค่ต้องสร้างเครือข่ายโดยมีตัวจำแนกแบบหนาแน่นอยู่ด้านบนเท่านั้น จากนั้นฝึกเครือข่ายทั้งระบบโดยใช้การถ่ายทอดกลับ\n" ] }, { @@ -793,13 +804,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "โมเดลนี้ดูเหมือนเครือข่ายการจำแนกประเภทแบบ end-to-end ซึ่งรับภาพและส่งคืนคลาส อย่างไรก็ตาม สิ่งที่ซับซ้อนคือเราต้องการให้ VGG16 ทำหน้าที่เป็นตัวดึงคุณลักษณะ และไม่ต้องการให้มีการฝึกใหม่ ดังนั้นเราจำเป็นต้อง **ล็อกน้ำหนักของตัวดึงคุณลักษณะคอนโวลูชัน** เราสามารถเข้าถึงเลเยอร์แรกของเครือข่ายได้โดยเรียก `model.layers[0]` และเพียงแค่ตั้งค่าคุณสมบัติ `trainable` เป็น `False`\n", + "โมเดลนี้ดูเหมือนเครือข่ายการจำแนกประเภทแบบครบวงจร ซึ่งรับภาพเข้าไปแล้วส่งกลับคลาส อย่างไรก็ตาม สิ่งที่ยุ่งยากคือเราต้องการให้ VGG16 ทำหน้าที่เป็นตัวสกัดคุณลักษณะ ไม่ใช่ถูกฝึกซ้ำ ดังนั้นเราจำเป็นต้อง **แช่น้ำหนักของตัวสกัดคุณลักษณะ convolutional** เราสามารถเข้าถึงเลเยอร์แรกของเครือข่ายโดยเรียก `model.layers[0]` และเราจำเป็นเพียงตั้งค่าคุณสมบัติ `trainable` เป็น `False`\n", "\n", - "> **Note**: การล็อกน้ำหนักของตัวดึงคุณลักษณะเป็นสิ่งจำเป็น เพราะหากไม่ทำเช่นนั้น เลเยอร์ตัวจำแนกที่ยังไม่ได้รับการฝึกอาจทำลายน้ำหนักที่ได้รับการฝึกไว้ล่วงหน้าของตัวดึงคุณลักษณะคอนโวลูชันได้\n", + "> **หมายเหตุ**: การแช่น้ำหนักของตัวสกัดคุณลักษณะเป็นสิ่งจำเป็น เพราะถ้าไม่ทำ เลเยอร์ตัวจำแนกที่ยังไม่ได้ฝึกอาจทำลายน้ำหนักต้นฉบับที่ถูกฝึกล่วงหน้าของตัวสกัด convolutional\n", "\n", - "คุณจะสังเกตได้ว่าในขณะที่จำนวนพารามิเตอร์ทั้งหมดในเครือข่ายของเรามีประมาณ 15 ล้าน แต่เราฝึกเพียง 25,000 พารามิเตอร์เท่านั้น พารามิเตอร์อื่น ๆ ทั้งหมดของตัวกรองคอนโวลูชันระดับบนสุดได้รับการฝึกไว้ล่วงหน้าแล้ว ซึ่งเป็นเรื่องดี เพราะเราสามารถปรับแต่งพารามิเตอร์จำนวนน้อยลงได้ด้วยตัวอย่างที่น้อยลง\n", + "คุณจะสังเกตได้ว่าในขณะที่จำนวนพารามิเตอร์ทั้งหมดในเครือข่ายของเราประมาณ 15 ล้าน เรากำลังฝึกเพียง 25k พารามิเตอร์เท่านั้น พารามิเตอร์อื่นๆ ของตัวกรอง convolutional ชั้นบนสุดถูกฝึกล่วงหน้าไว้แล้ว นั่นเป็นผลดี เพราะเราสามารถปรับแต่งพารามิเตอร์จำนวนน้อยลงด้วยตัวอย่างจำนวนน้อยลง\n", "\n", - "ตอนนี้เราจะฝึกเครือข่ายของเราและดูว่าเราจะได้ผลลัพธ์ดีแค่ไหน คาดว่าจะใช้เวลารันนานพอสมควร และอย่ากังวลหากดูเหมือนว่าการประมวลผลหยุดนิ่งไปชั่วขณะ\n" + "ตอนนี้เราจะฝึกเครือข่ายของเราและดูว่าจะดีแค่ไหน คาดว่าจะใช้เวลานาน และอย่ากังวลหากการทำงานดูเหมือนหยุดชั่วคราวเป็นบางเวลา\n" ] }, { @@ -824,11 +835,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "ดูเหมือนว่าเราจะได้ตัวจำแนกแมวกับสุนัขที่แม่นยำพอสมควรแล้ว!\n", + "ดูเหมือนว่าเราจะได้ตัวจำแนกแมวกับสุนัขที่ค่อนข้างแม่นยำแล้ว!\n", "\n", "## การบันทึกและโหลดโมเดล\n", "\n", - "เมื่อเราได้ทำการฝึกโมเดลเสร็จแล้ว เราสามารถบันทึกโครงสร้างของโมเดลและน้ำหนักที่ผ่านการฝึกแล้วลงในไฟล์เพื่อใช้งานในอนาคต:\n" + "เมื่อเราฝึกโมเดลเสร็จแล้ว เราสามารถบันทึกสถาปัตยกรรมโมเดลและน้ำหนักที่ผ่านการฝึกไว้เป็นไฟล์สำหรับใช้งานในอนาคต:\n" ] }, { @@ -852,7 +863,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "เราสามารถโหลดโมเดลจากไฟล์ได้ทุกเมื่อ คุณอาจพบว่ามันมีประโยชน์ในกรณีที่การทดลองครั้งต่อไปทำลายโมเดล - คุณจะไม่ต้องเริ่มต้นใหม่ตั้งแต่ต้น\n" + "เราสามารถโหลดโมเดลจากไฟล์ได้ทุกเมื่อ คุณอาจจะพบว่าสิ่งนี้มีประโยชน์ในกรณีที่การทดลองครั้งถัดไปทำลายโมเดล — คุณจะไม่ต้องเริ่มต้นใหม่ตั้งแต่ต้น\n" ] }, { @@ -868,15 +879,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## การปรับแต่งการเรียนรู้แบบถ่ายโอน\n", + "## การปรับแต่งการถ่ายโอนการเรียนรู้\n", "\n", - "ในส่วนก่อนหน้า เราได้ฝึกฝนเลเยอร์ตัวจำแนกขั้นสุดท้ายเพื่อจำแนกรูปภาพในชุดข้อมูลของเราเอง อย่างไรก็ตาม เราไม่ได้ฝึกฝนตัวดึงคุณลักษณะใหม่ และโมเดลของเรายังคงพึ่งพาคุณลักษณะที่โมเดลได้เรียนรู้จากข้อมูล ImageNet หากวัตถุของคุณมีลักษณะทางสายตาที่แตกต่างจากภาพทั่วไปใน ImageNet การผสมผสานคุณลักษณะนี้อาจไม่ได้ผลดีที่สุด ดังนั้นจึงสมเหตุสมผลที่จะเริ่มฝึกฝนเลเยอร์คอนโวลูชันด้วยเช่นกัน\n", + "ในส่วนก่อนหน้า เราได้ฝึกเลเยอร์ตัวจำแนกสุดท้ายเพื่อจำแนกรูปภาพในชุดข้อมูลของเราเอง อย่างไรก็ตาม เราไม่ได้ฝึกซ้ำตัวแยกคุณลักษณะ และโมเดลของเราอาศัยคุณลักษณะที่โมเดลได้เรียนรู้จากข้อมูล ImageNet หากวัตถุของคุณแตกต่างจากภาพ ImageNet ธรรมดา การผสมผสานคุณลักษณะเหล่านี้อาจไม่ทำงานได้ดีที่สุด ดังนั้นจึงสมเหตุสมผลที่จะเริ่มฝึกเลเยอร์คอนโวลูชันด้วย\n", "\n", - "เพื่อทำเช่นนั้น เราสามารถปลดล็อกพารามิเตอร์ตัวกรองคอนโวลูชันที่เราได้ล็อกไว้ก่อนหน้านี้\n", + "ในการทำเช่นนั้น เราสามารถปลดล็อกพารามิเตอร์ตัวกรองคอนโวลูชันที่เราได้แช่แข็งไว้ก่อนหน้านี้ได้\n", "\n", - "> **Note:** สิ่งสำคัญคือคุณต้องล็อกพารามิเตอร์ก่อนและทำการฝึกฝนหลายรอบเพื่อทำให้น้ำหนักในเลเยอร์การจำแนกมีความเสถียร หากคุณเริ่มฝึกฝนเครือข่ายแบบ end-to-end โดยที่พารามิเตอร์ไม่ได้ถูกล็อกไว้ตั้งแต่แรก ข้อผิดพลาดขนาดใหญ่อาจทำลายน้ำหนักที่ได้รับการฝึกฝนไว้ในเลเยอร์คอนโวลูชันได้\n", + "> **หมายเหตุ:** สิ่งสำคัญคือต้องแช่แข็งพารามิเตอร์ก่อน และทำการฝึกหลายยุคเพื่อให้ค่าน้ำหนักในเลเยอร์จำแนกมีความเสถียร หากคุณเริ่มฝึกเครือข่ายแบบ end-to-end โดยไม่แช่แข็งพารามิเตอร์ทันที ข้อผิดพลาดขนาดใหญ่อาจทำลายน้ำหนักที่ฝึกไว้ล่วงหน้าในเลเยอร์คอนโวลูชันได้\n", "\n", - "โมเดล VGG-16 แบบคอนโวลูชันของเราอยู่ในเลเยอร์แรก และมันประกอบด้วยหลายเลเยอร์ในตัวเอง เราสามารถดูโครงสร้างของมันได้:\n" + "โมเดล VGG-16 แบบคอนโวลูชันของเราอยู่ภายในเลเยอร์แรก และประกอบด้วยเลเยอร์หลายเลเยอร์ด้วยตัวเอง เราสามารถดูโครงสร้างของมันได้:\n" ] }, { @@ -944,7 +955,9 @@ { "cell_type": "markdown", "metadata": {}, - "source": [] + "source": [ + "เราสามารถปลดล็อกทุกชั้นของฐานคอนโวลูชันได้:\n" + ] }, { "cell_type": "code", @@ -959,7 +972,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "อย่างไรก็ตาม การปลดล็อกทั้งหมดในครั้งเดียวไม่ใช่ความคิดที่ดีที่สุด เราสามารถเริ่มต้นด้วยการปลดล็อกเพียงไม่กี่ชั้นสุดท้ายของการคอนโวลูชันก่อน เพราะชั้นเหล่านี้มีรูปแบบระดับสูงที่เกี่ยวข้องกับภาพของเรา ตัวอย่างเช่น ในการเริ่มต้น เราสามารถล็อกชั้นทั้งหมดไว้ ยกเว้น 4 ชั้นสุดท้าย:\n" + "อย่างไรก็ตาม การปลดล็อกทั้งหมดในครั้งเดียวไม่ใช่ไอเดียที่ดีที่สุด เราสามารถเริ่มปลดล็อกเฉพาะเลเยอร์คอนโวลูชันสุดท้ายเพียงบางส่วนก่อน เพราะเลเยอร์เหล่านั้นมีรูปแบบในระดับสูงที่เกี่ยวข้องกับภาพของเราได้ เช่น เป็นจุดเริ่มต้น เราสามารถแช่แข็งเลเยอร์ทั้งหมด ยกเว้น 4 เลเยอร์สุดท้าย: \n" ] }, { @@ -998,11 +1011,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "สังเกตว่าจำนวนพารามิเตอร์ที่สามารถฝึกได้เพิ่มขึ้นอย่างมาก แต่ยังคงอยู่ที่ประมาณ 50% ของพารามิเตอร์ทั้งหมด\n", + "สังเกตว่าจำนวนพารามิเตอร์ที่สามารถฝึกได้เพิ่มขึ้นอย่างมาก แต่ก็ยังคงอยู่ที่ประมาณ 50% ของพารามิเตอร์ทั้งหมด\n", "\n", - "หลังจากปลดล็อกการแช่แข็ง เราสามารถฝึกเพิ่มอีกไม่กี่รอบ (ในตัวอย่างของเรา เราจะทำเพียงหนึ่งรอบ) คุณยังสามารถเลือกอัตราการเรียนรู้ที่ต่ำลงเพื่อช่วยลดผลกระทบต่อค่าถ่วงน้ำหนักที่ถูกฝึกมาก่อน อย่างไรก็ตาม แม้จะใช้อัตราการเรียนรู้ต่ำ คุณก็อาจคาดหวังได้ว่าความแม่นยำจะลดลงในช่วงเริ่มต้นของการฝึก จนกระทั่งในที่สุดจะเพิ่มขึ้นเล็กน้อยเมื่อเทียบกับกรณีที่ค่าถ่วงน้ำหนักถูกล็อกไว้\n", + "หลังจากปลดล็อก เราสามารถทำการฝึกเพิ่มอีกไม่กี่รอบ (ในตัวอย่างของเรา เราจะทำแค่หนึ่งรอบ) คุณยังสามารถเลือกระดับอัตราการเรียนรู้ที่ต่ำกว่า เพื่อช่วยลดผลกระทบต่อค่าน้ำหนักที่ถูกฝึกมาก่อนแล้ว อย่างไรก็ตาม แม้อัตราการเรียนรู้จะต่ำ คุณก็สามารถคาดหวังได้ว่า ความแม่นยำจะลดลงในช่วงเริ่มต้นของการฝึก จนในที่สุดจะถึงระดับที่สูงกว่าเล็กน้อยเมื่อเทียบกับกรณีที่ค่าน้ำหนักถูกตั้งค่าไว้คงที่\n", "\n", - "> **Note:** การฝึกในขั้นตอนนี้จะช้าลงมาก เพราะเราต้องส่งต่อค่ากราดิเอนต์กลับผ่านหลายชั้นของเครือข่าย!\n" + "> **หมายเหตุ:** การฝึกนี้จะช้ากว่ามาก เพราะเราจำเป็นต้องส่งต่อเกรเดียนต์ย้อนกลับผ่านชั้นของเครือข่ายหลายชั้น!\n" ] }, { @@ -1026,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** ที่พัฒนาโดย Microsoft และ **Inception** โดย Google ตัวอย่างเช่น เรามาสำรวจสถาปัตยกรรมของโมเดล ResNet-50 ที่ง่ายที่สุด (ResNet เป็นกลุ่มโมเดลที่มีความลึกต่างกัน คุณสามารถลองทดลองกับ ResNet-152 หากคุณต้องการดูว่าโมเดลที่ลึกจริงๆ มีลักษณะอย่างไร):\n" ] }, { @@ -1439,29 +1452,29 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "โมเดลนี้ประกอบด้วยองค์ประกอบที่คุ้นเคย เช่น ชั้นคอนโวลูชัน ชั้นพูลลิ่ง และตัวจำแนกแบบ Dense ในตอนท้าย เราสามารถใช้โมเดลนี้ในลักษณะเดียวกับที่เราใช้ VGG-16 สำหรับการเรียนรู้แบบถ่ายโอน คุณสามารถลองทดลองกับโค้ดด้านบนโดยใช้โมเดล ResNet ต่าง ๆ เป็นโมเดลฐาน และดูว่าอัตราความแม่นยำเปลี่ยนแปลงไปอย่างไร\n", + "อย่างที่คุณเห็น โมเดลประกอบไปด้วยบล็อกที่คุ้นเคยเหมือนเดิม: เลเยอร์คอนโวลูชัน, เลเยอร์พูลลิ่ง และตัวจำแนกแบบหนาแน่นสุดท้าย เราสามารถใช้โมเดลนี้ในลักษณะเดียวกับที่เราเคยใช้ VGG-16 สำหรับการเรียนรู้แบบถ่ายโอน คุณสามารถลองทดลองกับโค้ดด้านบนนี้ โดยใช้โมเดล ResNet ที่แตกต่างกันเป็นโมเดลฐาน และดูว่าแม่นยำเปลี่ยนแปลงอย่างไร\n", "\n", - "## การปรับค่าปกติของแบตช์\n", + "## การทำให้นอร์มัลแบบแบตช์ (Batch Normalization)\n", "\n", - "เครือข่ายนี้มีอีกหนึ่งประเภทของชั้น: **การปรับค่าปกติของแบตช์** แนวคิดของการปรับค่าปกติของแบตช์คือการปรับค่าให้เหมาะสมในช่วงที่เหมาะสมเมื่อผ่านเครือข่ายประสาท โดยปกติแล้วเครือข่ายประสาทจะทำงานได้ดีที่สุดเมื่อค่าทั้งหมดอยู่ในช่วง [-1,1] หรือ [0,1] และนี่คือเหตุผลที่เราปรับขนาด/ปรับค่าข้อมูลอินพุตให้เหมาะสม อย่างไรก็ตาม ในระหว่างการฝึกเครือข่ายลึก อาจเกิดกรณีที่ค่าหลุดออกจากช่วงนี้อย่างมาก ซึ่งทำให้การฝึกมีปัญหา ชั้นการปรับค่าปกติของแบตช์จะคำนวณค่าเฉลี่ยและค่าเบี่ยงเบนมาตรฐานสำหรับค่าทั้งหมดในมินิแบตช์ปัจจุบัน และใช้ค่าดังกล่าวในการปรับสัญญาณให้เหมาะสมก่อนที่จะส่งผ่านชั้นเครือข่ายประสาท สิ่งนี้ช่วยปรับปรุงความเสถียรของเครือข่ายลึกได้อย่างมาก\n" + "เครือข่ายนี้ประกอบด้วยเลเยอร์ประเภทใหม่อีกชนิดหนึ่ง: **การทำให้นอร์มัลแบบแบตช์ (Batch Normalization)** แนวคิดของการทำให้นอร์มัลแบบแบตช์คือการนำค่าต่าง ๆ ที่ไหลผ่านเครือข่ายประสาทกลับมาอยู่ในช่วงที่เหมาะสม โดยปกติเครือข่ายประสาททำงานได้ดีที่สุดเมื่อค่าทั้งหมดอยู่ในช่วง [-1,1] หรือ [0,1] และนั่นคือเหตุผลที่เราปรับขนาด/นอร์มัลข้อมูลนำเข้าของเราให้เหมาะสม อย่างไรก็ตาม ระหว่างการฝึกเครือข่ายเชิงลึก อาจเกิดเหตุการณ์ที่ค่าต่าง ๆ ออกนอกช่วงนี้อย่างมาก ซึ่งทำให้การฝึกฝนเป็นปัญหา เลเยอร์การทำให้นอร์มัลแบบแบตช์คำนวณค่าเฉลี่ยและส่วนเบี่ยงเบนมาตรฐานสำหรับค่าทั้งหมดในมินิแบตช์ปัจจุบัน แล้วใช้ค่านั้นเพื่อทำให้นอร์มัลสัญญาณก่อนส่งผ่านเลเยอร์เครือข่ายประสาท ซึ่งช่วยปรับปรุงความเสถียรของเครือข่ายเชิงลึกอย่างมีนัยสำคัญ\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## ข้อสรุป\n", + "## สรุป\n", "\n", - "ด้วยการใช้การเรียนรู้แบบถ่ายโอน (transfer learning) เราสามารถสร้างตัวจำแนกสำหรับงานการจำแนกวัตถุเฉพาะของเราได้อย่างรวดเร็ว และได้ผลลัพธ์ที่มีความแม่นยำสูง อย่างไรก็ตาม ตัวอย่างนี้ไม่ได้เป็นการเปรียบเทียบที่ยุติธรรมทั้งหมด เนื่องจากเครือข่าย VGG-16 ดั้งเดิมถูกฝึกมาเพื่อจดจำแมวและสุนัข ดังนั้นเราจึงเพียงแค่นำรูปแบบที่มีอยู่ในเครือข่ายมาใช้ใหม่ คุณสามารถคาดหวังความแม่นยำที่ต่ำลงเมื่อทำงานกับวัตถุที่เฉพาะเจาะจงมากขึ้น เช่น รายละเอียดในสายการผลิตในโรงงาน หรือใบไม้ของต้นไม้ที่แตกต่างกัน\n", + "ด้วยการใช้ transfer learning เราสามารถสร้างตัวจำแนกสำหรับงานจำแนกวัตถุที่กำหนดเองได้อย่างรวดเร็วและได้ความแม่นยำสูง อย่างไรก็ตาม ตัวอย่างนี้ไม่ยุติธรรมโดยสมบูรณ์ เพราะเครือข่าย VGG-16 เดิมถูกฝึกมาเพื่อจดจำแมวและสุนัขก่อน ดังนั้นเราจึงใช้รูปแบบส่วนใหญ่ที่มีอยู่ในเครือข่ายนั้นแล้ว คุณอาจคาดหวังความแม่นยำที่ต่ำกว่าสำหรับวัตถุเฉพาะทางที่ซับซ้อนมากขึ้น เช่น รายละเอียดสายการผลิตในโรงงาน หรือใบไม้ของต้นไม้ที่แตกต่างกัน\n", "\n", - "คุณจะเห็นได้ว่างานที่ซับซ้อนมากขึ้นที่เรากำลังแก้ไขในตอนนี้ต้องการพลังการประมวลผลที่สูงขึ้น และไม่สามารถแก้ไขได้ง่ายบน CPU ในหน่วยถัดไป เราจะลองใช้การดำเนินการที่เบากว่าเพื่อฝึกโมเดลเดียวกันโดยใช้ทรัพยากรการประมวลผลที่ต่ำลง ซึ่งจะส่งผลให้ความแม่นยำลดลงเพียงเล็กน้อยเท่านั้น\n" + "คุณจะเห็นว่างานที่ซับซ้อนกว่าที่เรากำลังแก้ไขตอนนี้ต้องการพลังการประมวลผลที่สูงขึ้น และไม่สามารถแก้ได้ง่ายด้วย CPU ในบทต่อไป เราจะลองใช้การนำไปใช้งานที่เบากว่าเพื่อฝึกโมเดลเดียวกันโดยใช้ทรัพยากรคอมพิวเตอร์ที่ต่ำกว่า ซึ่งส่งผลให้ความแม่นยำน้อยลงเล็กน้อย\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "\n---\n\n**ข้อจำกัดความรับผิดชอบ**: \nเอกสารนี้ได้รับการแปลโดยใช้บริการแปลภาษา AI [Co-op Translator](https://github.com/Azure/co-op-translator) แม้ว่าเราจะพยายามให้การแปลมีความถูกต้อง แต่โปรดทราบว่าการแปลอัตโนมัติอาจมีข้อผิดพลาดหรือความไม่แม่นยำ เอกสารต้นฉบับในภาษาต้นทางควรถือเป็นแหล่งข้อมูลที่เชื่อถือได้ สำหรับข้อมูลที่สำคัญ ขอแนะนำให้ใช้บริการแปลภาษามนุษย์มืออาชีพ เราจะไม่รับผิดชอบต่อความเข้าใจผิดหรือการตีความที่ผิดพลาดซึ่งเกิดจากการใช้การแปลนี้\n" + "---\n\n\n**ปฏิเสธความรับผิดชอบ**:\nเอกสารนี้ได้รับการแปลโดยใช้บริการแปลภาษา AI [Co-op Translator](https://github.com/Azure/co-op-translator) ขณะที่เราพยายามให้ความถูกต้อง โปรดทราบว่าการแปลโดยอัตโนมัติอาจมีข้อผิดพลาดหรือความไม่ถูกต้อง เอกสารต้นฉบับในภาษาต้นทางควรถูกพิจารณาเป็นแหล่งข้อมูลที่เชื่อถือได้ สำหรับข้อมูลที่สำคัญ แนะนำให้ใช้การแปลโดยมนุษย์มืออาชีพ เราไม่รับผิดชอบต่อความเข้าใจผิดหรือการตีความที่ผิดพลาดที่เกิดขึ้นจากการใช้การแปลนี้\n\n" ] } ], @@ -1482,12 +1495,6 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.10" - }, - "coopTranslator": { - "original_hash": "c189abc107848f96051085cc30945129", - "translation_date": "2025-08-29T09:51:53+00:00", - "source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb", - "language_code": "th" } }, "nbformat": 4, diff --git a/translations/th/lessons/5-NLP/README.md b/translations/th/lessons/5-NLP/README.md index c2d4b0b8..b23f93d0 100644 --- a/translations/th/lessons/5-NLP/README.md +++ b/translations/th/lessons/5-NLP/README.md @@ -1,51 +1,51 @@ # การประมวลผลภาษาธรรมชาติ -![ภาพสรุปงาน NLP ในรูปวาด](../../../../translated_images/th/ai-nlp.b22dcb8ca4707cea.webp) +![สรุปงานของ NLP ในสเก็ตช์](../../../../translated_images/th/ai-nlp.b22dcb8ca4707cea.webp) -ในส่วนนี้ เราจะมุ่งเน้นการใช้เครือข่ายประสาทเทียม (Neural Networks) เพื่อจัดการกับงานที่เกี่ยวข้องกับ **การประมวลผลภาษาธรรมชาติ (Natural Language Processing - NLP)** มีปัญหาหลายประเภทใน NLP ที่เราต้องการให้คอมพิวเตอร์สามารถแก้ไขได้: +ในส่วนนี้ เราจะเน้นการใช้โครงข่ายประสาทเทียมเพื่อจัดการกับงานที่เกี่ยวข้องกับ **การประมวลผลภาษาธรรมชาติ (NLP)** มีปัญหา NLP มากมายที่เราต้องการให้คอมพิวเตอร์สามารถแก้ไขได้: -* **การจัดประเภทข้อความ** เป็นปัญหาการจัดประเภททั่วไปที่เกี่ยวข้องกับลำดับข้อความ ตัวอย่างเช่น การจัดประเภทอีเมลว่าเป็นสแปมหรือไม่ใช่สแปม หรือการจัดหมวดหมู่บทความเป็นกีฬา ธุรกิจ การเมือง เป็นต้น นอกจากนี้ ในการพัฒนาช่องสนทนา (chat bots) เรามักต้องเข้าใจสิ่งที่ผู้ใช้ต้องการจะพูด -- ในกรณีนี้เรากำลังจัดการกับ **การจัดประเภทเจตนา (intent classification)** ซึ่งมักต้องจัดการกับหมวดหมู่จำนวนมาก -* **การวิเคราะห์ความรู้สึก (Sentiment analysis)** เป็นปัญหาการถดถอยทั่วไป ที่เราต้องกำหนดตัวเลข (ความรู้สึก) ที่สอดคล้องกับความหมายที่เป็นบวก/ลบของประโยค เวอร์ชันที่ซับซ้อนกว่าของการวิเคราะห์ความรู้สึกคือ **การวิเคราะห์ความรู้สึกตามแง่มุม (Aspect-Based Sentiment Analysis - ABSA)** ซึ่งเรากำหนดความรู้สึกไม่ใช่กับทั้งประโยค แต่กับส่วนต่าง ๆ ของมัน (แง่มุม) เช่น *ในร้านอาหารนี้ ฉันชอบอาหาร แต่บรรยากาศแย่มาก* -* **การจดจำชื่อหน่วยงาน (Named Entity Recognition - NER)** หมายถึงปัญหาในการดึงข้อมูลหน่วยงานบางอย่างจากข้อความ ตัวอย่างเช่น เราอาจต้องเข้าใจว่าในวลี *ฉันต้องบินไปปารีสพรุ่งนี้* คำว่า *พรุ่งนี้* หมายถึงวันที่ และ *ปารีส* เป็นสถานที่ -* **การดึงคำสำคัญ (Keyword extraction)** คล้ายกับ NER แต่เราต้องดึงคำที่สำคัญต่อความหมายของประโยคโดยอัตโนมัติ โดยไม่ต้องฝึกฝนล่วงหน้าสำหรับประเภทหน่วยงานเฉพาะ -* **การจัดกลุ่มข้อความ (Text clustering)** มีประโยชน์เมื่อเราต้องการจัดกลุ่มประโยคที่คล้ายกันเข้าด้วยกัน เช่น คำขอที่คล้ายกันในบทสนทนาการสนับสนุนทางเทคนิค -* **การตอบคำถาม (Question answering)** หมายถึงความสามารถของโมเดลในการตอบคำถามเฉพาะ โมเดลจะได้รับข้อความและคำถามเป็นข้อมูลนำเข้า และต้องระบุตำแหน่งในข้อความที่มีคำตอบของคำถาม (หรือบางครั้งสร้างข้อความคำตอบ) -* **การสร้างข้อความ (Text Generation)** คือความสามารถของโมเดลในการสร้างข้อความใหม่ สามารถพิจารณาเป็นงานการจัดประเภทที่ทำนายตัวอักษร/คำถัดไปตาม *ข้อความนำ* โมเดลการสร้างข้อความขั้นสูง เช่น GPT-3 สามารถแก้ไขงาน NLP อื่น ๆ เช่น การจัดประเภท โดยใช้เทคนิคที่เรียกว่า [การเขียนโปรแกรมด้วยคำสั่ง (prompt programming)](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) หรือ [วิศวกรรมคำสั่ง (prompt engineering)](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29) -* **การสรุปข้อความ (Text summarization)** เป็นเทคนิคที่เราต้องการให้คอมพิวเตอร์ "อ่าน" ข้อความยาว ๆ และสรุปในไม่กี่ประโยค -* **การแปลภาษา (Machine translation)** สามารถมองว่าเป็นการรวมกันของการเข้าใจข้อความในภาษาหนึ่ง และการสร้างข้อความในอีกภาษาหนึ่ง +* **การจัดหมวดหมู่ข้อความ** เป็นปัญหาการจัดหมวดหมู่ทั่วไปที่เกี่ยวข้องกับลำดับข้อความ ตัวอย่างเช่น การจัดอีเมลเป็นสแปมหรือไม่ใช่สแปม หรือจัดหมวดหมู่บทความเป็นกีฬา ธุรกิจ การเมือง ฯลฯ นอกจากนี้ เมื่อพัฒนาแชทบอท เรามักจะต้องเข้าใจว่าสิ่งที่ผู้ใช้ต้องการจะสื่อคืออะไร — ในกรณีนี้เรากำลังจัดการกับ **การจัดหมวดหมู่เจตนา** บ่อยครั้งในการจัดหมวดหมู่เจตนา เราต้องจัดการกับหลายหมวดหมู่ +* **การวิเคราะห์ความรู้สึก** เป็นปัญหาการถดถอยทั่วไป ที่เราต้องกำหนดตัวเลข (ความรู้สึก) ที่สอดคล้องกับว่าประโยคนั้นมีความหมายเชิงบวกหรือลบมากน้อยเพียงใด เวอร์ชันขั้นสูงของการวิเคราะห์ความรู้สึกคือ **การวิเคราะห์ความรู้สึกตามแง่มุม** (ABSA) ที่เรากำหนดความรู้สึกไม่ใช่กับทั้งประโยค แต่ให้กับส่วนต่าง ๆ ของประโยค (แง่มุม) เช่น *ในร้านอาหารแห่งนี้ ฉันชอบอาหาร แต่บรรยากาศแย่มาก* +* **การจดจำเอนทิตีเฉพาะ** (NER) หมายถึงปัญหาการดึงเอนทิตีบางอย่างออกจากข้อความ เช่น เราอาจต้องเข้าใจว่าในวลี *ฉันต้องการบินไปปารีสวันพรุ่งนี้* คำว่า *วันพรุ่งนี้* หมายถึง DATE และ *ปารีส* คือ LOCATION +* **การดึงคำสำคัญ** คล้ายกับ NER แต่เราต้องดึงคำที่สำคัญต่อความหมายของประโยคโดยอัตโนมัติโดยไม่ต้องผ่านการฝึกล่วงหน้าสำหรับประเภทเอนทิตีเฉพาะ +* **การจัดกลุ่มข้อความ** สามารถใช้ได้เมื่อต้องการจัดกลุ่มประโยคที่คล้ายคลึงกัน เช่น คำร้องขอที่คล้ายกันในบทสนทนาการสนับสนุนทางเทคนิค +* **การตอบคำถาม** หมายถึงความสามารถของแบบจำลองในการตอบคำถามเฉพาะ แบบจำลองจะได้รับข้อความและคำถามเป็นอินพุต และต้องให้ตำแหน่งในข้อความที่มีคำตอบของคำถามอยู่ (หรือบางครั้งอาจสร้างข้อความคำตอบ) +* **การสร้างข้อความ** คือความสามารถของแบบจำลองในการสร้างข้อความใหม่ สามารถมองได้ว่าเป็นงานการจัดหมวดหมู่ที่ทำนายตัวอักษร/คำถัดไปโดยอิงตาม *ข้อความตัวอย่าง* แบบจำลองการสร้างข้อความขั้นสูง เช่น GPT-3 สามารถแก้งาน NLP อื่นๆ เช่น การจัดหมวดหมู่โดยใช้เทคนิคที่เรียกว่า [prompt programming](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) หรือ [prompt engineering](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29) +* **การสรุปข้อความ** เป็นเทคนิคที่ต้องการให้คอมพิวเตอร์ "อ่าน" ข้อความยาวและสรุปให้อยู่ในไม่กี่ประโยค +* **การแปลภาษาเครื่อง** สามารถมองว่าเป็นการรวมการเข้าใจข้อความในภาษาหนึ่ง และการสร้างข้อความในอีกภาษาหนึ่งเข้าด้วยกัน -ในช่วงแรก งาน NLP ส่วนใหญ่ถูกแก้ไขด้วยวิธีการแบบดั้งเดิม เช่น ไวยากรณ์ ตัวอย่างเช่น ในการแปลภาษา เครื่องมือวิเคราะห์ (parsers) ถูกใช้เพื่อแปลงประโยคเริ่มต้นเป็นต้นไม้ไวยากรณ์ จากนั้นโครงสร้างเชิงความหมายระดับสูงจะถูกดึงออกมาเพื่อแสดงความหมายของประโยค และจากความหมายนี้และไวยากรณ์ของภาษาปลายทาง ผลลัพธ์จะถูกสร้างขึ้น ปัจจุบัน งาน NLP หลายงานถูกแก้ไขได้อย่างมีประสิทธิภาพมากขึ้นด้วยเครือข่ายประสาทเทียม +ในตอนแรก งาน NLP ส่วนใหญ่ถูกแก้โดยใช้วิธีดั้งเดิม เช่น ไวยากรณ์ ตัวอย่างเช่น ในการแปลภาษาใช้การวิเคราะห์ประโยคเพื่อแปลงประโยคเริ่มต้นเป็นต้นไม้ไวยากรณ์ จากนั้นดึงโครงสร้างความหมายระดับสูงเพื่อแทนความหมายของประโยค และอิงจากความหมายนั้นและไวยากรณ์ของภาษาเป้าหมายก็จะสร้างผลลัพธ์ ในปัจจุบัน งาน NLP จำนวนมากได้รับการแก้ไขอย่างมีประสิทธิภาพมากขึ้นด้วยโครงข่ายประสาทเทียม -> วิธีการ NLP แบบดั้งเดิมหลายวิธีถูกนำไปใช้ใน [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org) ซึ่งเป็นไลบรารี Python มี [หนังสือ NLTK](https://www.nltk.org/book/) ที่ยอดเยี่ยมซึ่งครอบคลุมวิธีการแก้ไขงาน NLP ต่าง ๆ โดยใช้ NLTK +> วิธี NLP แบบดั้งเดิมมากมายถูกใช้ในไลบรารี Python [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org) มีหนังสือ [NLTK Book](https://www.nltk.org/book/) ที่ยอดเยี่ยมให้เรียนออนไลน์ซึ่งครอบคลุมวิธีแก้ปัญหา NLP ต่างๆ ด้วย NLTK -ในหลักสูตรของเรา เราจะมุ่งเน้นการใช้เครือข่ายประสาทเทียมสำหรับ NLP และจะใช้ NLTK เมื่อจำเป็น +ในหลักสูตรนี้ เราจะมุ่งเน้นการใช้โครงข่ายประสาทเทียมสำหรับ NLP เป็นหลัก และจะใช้ NLTK เมื่อจำเป็น -เราได้เรียนรู้เกี่ยวกับการใช้เครือข่ายประสาทเทียมในการจัดการข้อมูลแบบตารางและภาพแล้ว ความแตกต่างหลักระหว่างประเภทข้อมูลเหล่านั้นกับข้อความคือ ข้อความเป็นลำดับที่มีความยาวแปรผัน ในขณะที่ขนาดข้อมูลนำเข้าในกรณีของภาพเป็นที่ทราบล่วงหน้า แม้ว่าเครือข่ายแบบคอนโวลูชันสามารถดึงรูปแบบจากข้อมูลนำเข้าได้ แต่รูปแบบในข้อความมีความซับซ้อนมากกว่า เช่น เราอาจมีการปฏิเสธที่แยกจากหัวเรื่องด้วยคำจำนวนมาก (เช่น *ฉันไม่ชอบส้ม* กับ *ฉันไม่ชอบส้มที่ใหญ่ สีสันสดใส และอร่อย*) และนั่นยังคงต้องตีความว่าเป็นรูปแบบเดียว ดังนั้น เพื่อจัดการกับภาษา เราจำเป็นต้องแนะนำประเภทเครือข่ายประสาทเทียมใหม่ เช่น *เครือข่ายแบบวนซ้ำ (recurrent networks)* และ *ตัวแปลง (transformers)* +เราได้เรียนรู้การใช้โครงข่ายประสาทเทียมสำหรับจัดการข้อมูลตารางและภาพแล้ว ความแตกต่างหลักระหว่างข้อมูลเหล่านั้นกับข้อความคือ ข้อความเป็นลำดับความยาวที่เปลี่ยนแปลงได้ ขณะที่ขนาดอินพุตของภาพเป็นค่าคงที่ล่วงหน้า ขณะที่โครงข่ายคอนโวลูชันสามารถดึงรูปแบบจากข้อมูลอินพุต รูปแบบในข้อความมีความซับซ้อนกว่า เช่น เราอาจมีการปฏิเสธซึ่งห่างจากประธานได้โดยไม่จำกัดจำนวนคำ (เช่น *ฉันไม่ชอบส้ม* เทียบกับ *ฉันไม่ชอบส้มใหญ่สีสันสดใสนั้น*) และควรถูกตีความเป็นรูปแบบเดียว ดังนั้น เพื่อจัดการกับภาษา เราต้องนำเสนอประเภทโครงข่ายประสาทเทียมใหม่ เช่น *เครือข่ายวนซ้ำ* และ *ทรานส์ฟอร์มเมอร์* -## ติดตั้งไลบรารี +## การติดตั้งไลบรารี -หากคุณใช้การติดตั้ง Python ในเครื่องเพื่อรันหลักสูตรนี้ คุณอาจต้องติดตั้งไลบรารีที่จำเป็นทั้งหมดสำหรับ NLP โดยใช้คำสั่งต่อไปนี้: +หากคุณใช้ Python ติดตั้งในเครื่องเพื่อรันหลักสูตรนี้ คุณอาจต้องติดตั้งไลบรารีที่จำเป็นทั้งหมดสำหรับ NLP โดยใช้คำสั่งต่อไปนี้: **สำหรับ PyTorch** ```bash -pip install -r requirements-torch.txt +pip install -r requirements-pytorch.txt ``` **สำหรับ TensorFlow** ```bash pip install -r requirements-tf.txt ``` -> คุณสามารถลองใช้ NLP กับ TensorFlow ได้ที่ [Microsoft Learn](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-tensorflow/?WT.mc_id=academic-77998-cacaste) +> คุณสามารถทดลองใช้ NLP กับ TensorFlow ได้ที่ [Microsoft Learn](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-tensorflow/?WT.mc_id=academic-77998-cacaste) ## คำเตือนเกี่ยวกับ GPU -ในส่วนนี้ ในตัวอย่างบางตัว เราจะฝึกโมเดลขนาดใหญ่ -* **ใช้คอมพิวเตอร์ที่รองรับ GPU**: ขอแนะนำให้รันโน้ตบุ๊กของคุณบนคอมพิวเตอร์ที่รองรับ GPU เพื่อลดเวลารอเมื่อทำงานกับโมเดลขนาดใหญ่ -* **ข้อจำกัดหน่วยความจำ GPU**: การรันบน GPU อาจนำไปสู่สถานการณ์ที่หน่วยความจำ GPU หมด โดยเฉพาะเมื่อฝึกโมเดลขนาดใหญ่ -* **การใช้หน่วยความจำ GPU**: ปริมาณหน่วยความจำ GPU ที่ใช้ระหว่างการฝึกขึ้นอยู่กับหลายปัจจัย รวมถึงขนาดของ minibatch -* **ลดขนาด Minibatch**: หากคุณพบปัญหาหน่วยความจำ GPU ให้พิจารณาลดขนาด minibatch ในโค้ดของคุณเป็นวิธีแก้ไขปัญหา -* **การปล่อยหน่วยความจำ GPU ใน TensorFlow**: เวอร์ชันเก่าของ TensorFlow อาจไม่ปล่อยหน่วยความจำ GPU อย่างถูกต้องเมื่อฝึกโมเดลหลายตัวในหนึ่งเคอร์เนล Python เพื่อจัดการการใช้หน่วยความจำ GPU อย่างมีประสิทธิภาพ คุณสามารถกำหนดค่า TensorFlow ให้จัดสรรหน่วยความจำ GPU เฉพาะเมื่อจำเป็น -* **การเพิ่มโค้ด**: เพื่อกำหนดให้ TensorFlow เพิ่มการจัดสรรหน่วยความจำ GPU เฉพาะเมื่อจำเป็น ให้เพิ่มโค้ดต่อไปนี้ในโน้ตบุ๊กของคุณ: +ในส่วนนี้ ในบางตัวอย่างเราจะฝึกฝนแบบจำลองขนาดใหญ่มาก +* **ใช้คอมพิวเตอร์ที่รองรับ GPU**: แนะนำให้รันโน้ตบุ๊กของคุณบนคอมพิวเตอร์ที่มี GPU เพื่อช่วยลดเวลารอเมื่อทำงานกับแบบจำลองขนาดใหญ่ +* **ข้อจำกัดหน่วยความจำ GPU**: การรันบน GPU อาจทำให้เกิดสถานการณ์ที่หน่วยความจำ GPU หมดโดยเฉพาะเมื่อฝึกแบบจำลองขนาดใหญ่ +* **การใช้หน่วยความจำ GPU**: ปริมาณหน่วยความจำ GPU ที่ใช้ during การฝึกขึ้นอยู่กับหลายปัจจัย รวมถึงขนาดมินิบแซต +* **ลดขนาดมินิบแซต**: หากพบปัญหาหน่วยความจำ GPU ให้ลดขนาดมินิบแซตในโค้ดของคุณเป็นแนวทางแก้ไขที่เป็นไปได้ +* **การปล่อยหน่วยความจำ GPU ของ TensorFlow**: เวอร์ชันเก่าของ TensorFlow อาจไม่ปล่อยหน่วยความจำ GPU อย่างถูกต้องเมื่อฝึกแบบจำลองหลายตัวในเคอร์เนล Python เดียว เพื่อจัดการการใช้หน่วยความจำ GPU อย่างมีประสิทธิภาพ คุณสามารถตั้งค่า TensorFlow ให้จัดสรรหน่วยความจำ GPU เมื่อจำเป็นเท่านั้น +* **การใส่โค้ด**: เพื่อกำหนดให้ TensorFlow เพิ่มการจัดสรรหน่วยความจำ GPU เมื่อจำเป็นเท่านั้น ให้ใส่โค้ดต่อไปนี้ในโน้ตบุ๊กของคุณ: ```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) ``` -หากคุณสนใจเรียนรู้เกี่ยวกับ NLP จากมุมมองของ ML แบบดั้งเดิม เยี่ยมชม [ชุดบทเรียนนี้](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP) +หากคุณสนใจเรียนรู้เกี่ยวกับ NLP จากมุมมองคลาสสิกของ ML ให้ไปที่ [ชุดบทเรียนนี้](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP) ## ในส่วนนี้ ในส่วนนี้เราจะเรียนรู้เกี่ยวกับ: * [การแทนข้อความเป็นเทนเซอร์](13-TextRep/README.md) -* [Word Embeddings](14-Emdeddings/README.md) -* [การสร้างแบบจำลองภาษา](15-LanguageModeling/README.md) -* [เครือข่ายประสาทเทียมแบบวนซ้ำ](16-RNN/README.md) -* [เครือข่ายการสร้าง](17-GenerativeNetworks/README.md) -* [Transformers](18-Transformers/README.md) +* [การฝังคำ](14-Emdeddings/README.md) +* [การทำแบบจำลองภาษา](15-LanguageModeling/README.md) +* [โครงข่ายประสาทเทียมวนซ้ำ](16-RNN/README.md) +* [โครงข่ายสร้างสรรค์](17-GenerativeNetworks/README.md) +* [ทรานส์ฟอร์มเมอร์](18-Transformers/README.md) --- -**ข้อจำกัดความรับผิดชอบ**: -เอกสารนี้ได้รับการแปลโดยใช้บริการแปลภาษา AI [Co-op Translator](https://github.com/Azure/co-op-translator) แม้ว่าเราจะพยายามให้การแปลมีความถูกต้อง แต่โปรดทราบว่าการแปลอัตโนมัติอาจมีข้อผิดพลาดหรือความไม่แม่นยำ เอกสารต้นฉบับในภาษาต้นทางควรถือเป็นแหล่งข้อมูลที่เชื่อถือได้ สำหรับข้อมูลที่สำคัญ ขอแนะนำให้ใช้บริการแปลภาษาจากผู้เชี่ยวชาญที่เป็นมนุษย์ เราจะไม่รับผิดชอบต่อความเข้าใจผิดหรือการตีความที่ผิดพลาดซึ่งเกิดจากการใช้การแปลนี้ \ No newline at end of file + +**ปฏิเสธความรับผิดชอบ**: +เอกสารนี้ได้รับการแปลโดยใช้บริการแปลภาษา AI [Co-op Translator](https://github.com/Azure/co-op-translator) ขณะที่เราพยายามให้ความถูกต้อง โปรดทราบว่าการแปลโดยอัตโนมัติอาจมีข้อผิดพลาดหรือความไม่ถูกต้อง เอกสารต้นฉบับในภาษาต้นทางควรถูกพิจารณาเป็นแหล่งข้อมูลที่เชื่อถือได้ สำหรับข้อมูลที่สำคัญ แนะนำให้ใช้การแปลโดยมนุษย์มืออาชีพ เราไม่รับผิดชอบต่อความเข้าใจผิดหรือการตีความที่ผิดพลาดที่เกิดขึ้นจากการใช้การแปลนี้ + \ No newline at end of file