RomanNum3ral
/
AI-For-Beginners
mirror of https://github.com/microsoft/AI-For-Beginners.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

chore(i18n): sync translations with latest source changes (chunk 1/1, 18 changes)

This commit is contained in:
localizeflow[bot] 2026-07-08 15:53:18 +00:00
parent 2af9ee06d7
commit 677e5e5ac6
18 changed files with 645 additions and 456 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
translations/fi/.co-op-translator.json
View File

@ -5,6 +5,12 @@
"source_file": "AGENTS.md",
"language_code": "fi"
},
"CONTRIBUTING.md": {
"original_hash": "c6fd7e781b67111a90abd166d0ce4aa0",
"translation_date": "2026-07-08T15:53:04+00:00",
"source_file": "CONTRIBUTING.md",
"language_code": "fi"
},
"README.md": {
"original_hash": "12c8eb6bf0867d2f1c32daf613ac5b8b",
"translation_date": "2026-04-06T20:58:25+00:00",
@ -17,6 +23,19 @@
"source_file": "SECURITY.md",
"language_code": "fi"
},
"__translation_failures__": {
"lessons/sketchnotes/LICENSE.md": {
"original_hash": "45ab63a2cd8f5faef6c9b150618837a4",
"source_file": "lessons/sketchnotes/LICENSE.md",
"language_code": "fi",
"failure_date": "2026-07-08T15:45:58+00:00",
"status": "failed",
"error_type": "TranslationIncompleteError",
"error_message": "Markdown translation remained incomplete for chunk 1.1.1 of 'LICENSE.md', and the chunk could not be split further.",
"translator_version": "0.20.0",
"failure_policy_version": 1
}
},
"etc/CODE_OF_CONDUCT.md": {
"original_hash": "c06b12caf3c901eb3156e3dd5b0aea56",
"translation_date": "2025-08-28T20:13:19+00:00",
@ -54,8 +73,8 @@
"language_code": "fi"
},
"examples/README.md": {
"original_hash": "0d1babfdcbeb46525f2db3fbaaa54cd7",
"translation_date": "2025-10-03T11:31:51+00:00",
"original_hash": "7883d52c2e2a221e0b07a7b112a149b9",
"translation_date": "2026-07-08T15:39:57+00:00",
"source_file": "examples/README.md",
"language_code": "fi"
},
@ -66,8 +85,8 @@
"language_code": "fi"
},
"lessons/0-course-setup/how-to-run.md": {
"original_hash": "a4717bd9103b9f6cd84d534b83534689",
"translation_date": "2026-01-16T02:59:25+00:00",
"original_hash": "7ad8c7d8604c53649b3d4d1e2f3a6fa1",
"translation_date": "2026-07-08T15:40:22+00:00",
"source_file": "lessons/0-course-setup/how-to-run.md",
"language_code": "fi"
},
@ -191,6 +210,12 @@
"source_file": "lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md",
"language_code": "fi"
},
"lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb": {
"original_hash": "99b816b6a4957ef4100cee4c4221dff9",
"translation_date": "2026-07-08T15:31:24+00:00",
"source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb",
"language_code": "fi"
},
"lessons/4-ComputerVision/08-TransferLearning/lab/README.md": {
"original_hash": "7765935c35fcee69b9fe2d0cfd6963e2",
"translation_date": "2025-08-28T19:29:15+00:00",
@ -330,8 +355,8 @@
"language_code": "fi"
},
"lessons/5-NLP/README.md": {
"original_hash": "8ef02a9318257ea140ed3ed74442096d",
"translation_date": "2025-08-28T19:56:47+00:00",
"original_hash": "038df6f1a73e49f6430740da083bfd6d",
"translation_date": "2026-07-08T15:41:00+00:00",
"source_file": "lessons/5-NLP/README.md",
"language_code": "fi"
},

29
translations/fi/CONTRIBUTING.md Normal file
View File

@ -0,0 +1,29 @@
# Osallistuminen AI-For-Beginners -projektiin
Kiitos kiinnostuksestasi osallistua AI-For-Beginners -projektiin! Otamme mielellämme vastaan käännöksiä, oppituntien korjauksia ja muotoiluvirheiden korjauksia.
## Microsoftin osallistujan lisenssisopimus (CLA)
Tämä projekti toivottaa tervetulleiksi panokset ja ehdotukset. Useimmat panokset vaativat, että hyväksyt osallistujan lisenssisopimuksen (CLA), jossa vahvistat, että sinulla on oikeus ja että myönnät meille oikeuden käyttää panostasi. Yksityiskohdat löytyvät osoitteesta [https://cla.microsoft.com](https://cla.microsoft.com).
Kun lähetät vetopyynnön, CLA-botti määrittää automaattisesti, tarvitseeko sinun toimittaa CLA ja merkitsee PR:n asianmukaisesti (esim. tunniste, kommentti). Noudata vain botin antamia ohjeita. Sinun tarvitsee tehdä tämä vain kerran kaikissa CLA:tamme käyttävissä arkistoissa.
## Kuinka osallistua
### 1. Kirjoitusvirheiden / koodivirheiden korjaaminen
Jos huomaat kirjoitusvirheen tai bugin missään Jupyter-muistikirjassa tai oppitunnin markdown-tiedostossa:
1. Haarauta arkisto.
2. Korjaa kirjoitusvirhe tai rikkinäinen linkki.
3. Lähetä vetopyyntö, jossa on selkeä korjauksen kuvaus.
### 2. Käännösten lähettäminen
Otamme mielellämme vastaan oppituntien käännöksiä muille kielille! Laita käännökset hakemistoon `translations/` käyttäen olemassa olevia kansioiden nimiä (esimerkiksi `translations/es/`, `translations/pt-BR/`, `translations/zh-CN/`).
Lisätietoja löytyy tiedostosta [etc/CONTRIBUTING.md](etc/CONTRIBUTING.md).
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Vastuuvapauslauseke**:
Tämä asiakirja on käännetty käyttämällä tekoälypohjaista käännöspalvelua [Co-op Translator](https://github.com/Azure/co-op-translator). Vaikka pyrimme tarkkuuteen, otathan huomioon, että automaattiset käännökset saattavat sisältää virheitä tai epätarkkuuksia. Alkuperäinen asiakirja sen alkuperäiskielellä on virallinen lähde. Tärkeissä asioissa suositellaan ammattimaista ihmiskäännöstä. Emme ole vastuussa tämän käännöksen käytöstä aiheutuvista väärinymmärryksistä tai tulkinnoista.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

62
translations/fi/examples/README.md
View File

@ -1,31 +1,31 @@
# Aloittelijaystävällisiä AI-esimerkkejä
# Aloittelijaystävällisiä tekoälyesimerkkejä
Tervetuloa! Tämä hakemisto sisältää yksinkertaisia, itsenäisiä esimerkkejä, jotka auttavat sinua pääsemään alkuun tekoälyn ja koneoppimisen parissa. Jokainen esimerkki on suunniteltu aloitteleville käyttäjille, ja niissä on yksityiskohtaiset kommentit sekä vaiheittaiset selitykset.
Tervetuloa! Tämä hakemisto sisältää yksinkertaisia, itsenäisiä esimerkkejä, jotka auttavat sinua pääsemään alkuun tekoälyn ja koneoppimisen kanssa. Jokainen esimerkki on suunniteltu aloittelijaystävälliseksi yksityiskohtaisten kommenttien ja vaiheittaisten selitysten kera.
## 📚 Esimerkkien yleiskatsaus
| Esimerkki | Kuvaus | Vaikeustaso | Esitiedot |
|-----------|--------|-------------|-----------|
| [Hello AI World](../../../examples/01-hello-ai-world.py) | Ensimmäinen AI-ohjelmasi - yksinkertainen kuvioiden tunnistus | ⭐ Aloittelija | Pythonin perusteet |
| [Simple Neural Network](../../../examples/02-simple-neural-network.py) | Rakenna neuroverkko alusta alkaen | ⭐⭐ Aloittelija+ | Python, perusmatematiikka |
| [Image Classifier](./03-image-classifier.ipynb) | Luokittele kuvia valmiiksi koulutetulla mallilla | ⭐⭐ Aloittelija+ | Python, numpy |
| [Text Sentiment](../../../examples/04-text-sentiment.py) | Analysoi tekstin sentimenttiä (positiivinen/negatiivinen) | ⭐⭐ Aloittelija+ | Python |
| Esimerkki | Kuvaus | Vaikeustaso | Esivaatimukset |
|---------|-------------|------------|---------------|
| [Hello AI World](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/01-hello-ai-world.py) | Ensimmäinen tekoälyohjelmasi – yksinkertainen kuvioiden tunnistus | ⭐ Aloittelija | Pythonin perusteet |
| [Simple Neural Network](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/02-simple-neural-network.py) | Rakennetaan neuroverkko alusta alkaen | ⭐⭐ Aloittelija+ | Python, perusmatematiikka |
| [Image Classifier](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/03-image-classifier.ipynb) | Luokittele kuvia valmiilla mallilla | ⭐⭐ Aloittelija+ | Python, numpy |
| [Text Sentiment](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/04-text-sentiment.py) | Analysoi tekstin tunne (positiivinen/negatiivinen) | ⭐⭐ Aloittelija+ | Python |
## 🚀 Aloittaminen
## 🚀 Aloitus
### Esitiedot
### Esivaatimukset
Varmista, että sinulla on Python asennettuna (suositeltu versio 3.8 tai uudempi). Asenna tarvittavat paketit:
Varmista, että sinulla on Python asennettuna (3.8 tai uudempi suositeltu). Asenna vaaditut paketit:
```bash
# For Python scripts
# Python-skripteille
pip install numpy
# For Jupyter notebooks (image classifier)
# Jupyter-muistikirjoille (kuvaluokitin)
pip install jupyter numpy pillow tensorflow
```
Tai käytä pääopetussuunnitelman conda-ympäristöä:
Tai käytä conda-ympäristöä pääopetussuunnitelmasta:
```bash
conda env create --name ai4beg --file ../environment.yml
@ -34,12 +34,12 @@ conda activate ai4beg
### Esimerkkien suorittaminen
**Python-skripteille (.py-tiedostot):**
**Python-skriptit (.py tiedostot):**
```bash
python 01-hello-ai-world.py
```
**Jupyter-notebookeille (.ipynb-tiedostot):**
**Jupyter-muistikirjat (.ipynb tiedostot):**
```bash
jupyter notebook 03-image-classifier.ipynb
```
@ -48,38 +48,40 @@ jupyter notebook 03-image-classifier.ipynb
Suosittelemme seuraamaan esimerkkejä järjestyksessä:
1. **Aloita "Hello AI World" -esimerkillä** - Opettele kuvioiden tunnistuksen perusteet
1. **Aloita "Hello AI World"** - Opettele kuvioiden tunnistuksen perusteet
2. **Rakenna yksinkertainen neuroverkko** - Ymmärrä, miten neuroverkot toimivat
3. **Kokeile kuvaluokittelijaa** - Näe tekoäly toiminnassa oikeiden kuvien kanssa
4. **Analysoi tekstin sentimenttiä** - Tutustu luonnollisen kielen käsittelyyn
3. **Kokeile kuvaluokitinta** - Näe tekoäly käytännössä oikeiden kuvien kanssa
4. **Analysoi tekstin tunne** - Tutustu luonnollisen kielen käsittelyyn
## 💡 Vinkkejä aloittelijoille
- **Lue koodikommentit huolellisesti** - Ne selittävät, mitä kukin rivi tekee
- **Kokeile!** - Muuta arvoja ja katso, mitä tapahtuu
- **Älä huolehdi, jos et ymmärrä kaikkea** - Oppiminen vie aikaa
- **Kysy kysymyksiä** - Käytä [Keskustelupalstaa](https://github.com/microsoft/AI-For-Beginners/discussions)
- **Lue koodikommentit huolellisesti** – Ne selittävät, mitä kukin rivi tekee
- **Kokeile eri asioita!** – Muuta arvoja ja katso, mitä tapahtuu
- **Älä huoli, jos et ymmärrä kaikkea heti** – Oppiminen vie aikaa
- **Esitä kysymyksiä** – Käytä [Keskustelualue](https://github.com/microsoft/AI-For-Beginners/discussions)
## 🔗 Seuraavat askeleet
Kun olet käynyt läpi nämä esimerkit, tutustu koko opetussuunnitelmaan:
- [Johdatus tekoälyyn](../lessons/1-Intro/README.md)
Kun olet suorittanut nämä esimerkit, tutustu koko opetussuunnitelmaan:
- [Johdanto tekoälyyn](../lessons/1-Intro/README.md)
- [Neuroverkot](../lessons/3-NeuralNetworks/README.md)
- [Tietokonenäkö](../lessons/4-ComputerVision/README.md)
- [Koneen näkö](../lessons/4-ComputerVision/README.md)
- [Luonnollisen kielen käsittely](../lessons/5-NLP/README.md)
## 🤝 Osallistuminen
Ovatko nämä esimerkit hyödyllisiä? Auta meitä parantamaan niitä:
Löysitkö näistä esimerkeistä apua? Auta meitä parantamaan niitä:
- Ilmoita ongelmista tai ehdota parannuksia
- Lisää lisää esimerkkejä aloittelijoille
- Paranna dokumentaatiota ja kommentteja
---
*Muista: Jokainen asiantuntija on joskus ollut aloittelija. Mukavia oppimishetkiä! 🎓*
*Muista: Jokainen asiantuntija on joskus ollut aloittelija. Iloista oppimista! 🎓*
---
**Vastuuvapauslauseke**:
Tämä asiakirja on käännetty käyttämällä tekoälypohjaista käännöspalvelua [Co-op Translator](https://github.com/Azure/co-op-translator). Vaikka pyrimme tarkkuuteen, huomioithan, että automaattiset käännökset voivat sisältää virheitä tai epätarkkuuksia. Alkuperäistä asiakirjaa sen alkuperäisellä kielellä tulisi pitää ensisijaisena lähteenä. Kriittisen tiedon osalta suositellaan ammattimaista ihmiskäännöstä. Emme ole vastuussa väärinkäsityksistä tai virhetulkinnoista, jotka johtuvat tämän käännöksen käytöstä.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Vastuuvapauslauseke**:
Tämä asiakirja on käännetty käyttämällä tekoälypohjaista käännöspalvelua [Co-op Translator](https://github.com/Azure/co-op-translator). Vaikka pyrimme tarkkuuteen, otathan huomioon, että automaattiset käännökset saattavat sisältää virheitä tai epätarkkuuksia. Alkuperäinen asiakirja sen alkuperäiskielellä on virallinen lähde. Tärkeissä asioissa suositellaan ammattimaista ihmiskäännöstä. Emme ole vastuussa tämän käännöksen käytöstä aiheutuvista väärinymmärryksistä tai tulkinnoista.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

54
translations/fi/lessons/0-course-setup/how-to-run.md
View File

@ -1,12 +1,12 @@
# Kuinka Suorittaa Koodi
# Kuinka ajaa koodi
Tämä opetussuunnitelma sisältää paljon suoritettavia esimerkkejä ja labroja, joita haluat todennäköisesti suorittaa. Tätä varten sinun on pystyttävä suorittamaan Python-koodia Jupyter-muistikirjoissa, jotka kuuluvat osana tätä opetussuunnitelmaa. Koodin suorittamiseen on useita vaihtoehtoja:
Tämä opetussuunnitelma sisältää paljon suoritettavia esimerkkejä ja labroja, joita haluat varmasti ajaa. Tätä varten sinun täytyy pystyä suorittamaan Python-koodia Jupyter-muistikirjoissa, joita tarjotaan osana tätä opetussuunnitelmaa. Sinulla on useita vaihtoehtoja koodin ajamiseen:
## Suorita paikallisesti tietokoneellasi
## Aja paikallisesti tietokoneellasi
Jotta voit suorittaa koodin paikallisesti tietokoneellasi, tarvitset Python-asennuksen. Yksi suositus on asentaa **[miniconda](https://conda.io/en/latest/miniconda.html)** – se on melko kevyt asennus, joka tukee `conda`-paketinhallintaa erilaisille Pythonin **virtuaaliympäristöille**.
Jotta voit ajaa koodin paikallisesti tietokoneellasi, tarvitset Python-asennuksen. Suosittelemme asentamaan **[minicondan](https://conda.io/en/latest/miniconda.html)** – se on melko kevyt asennus, joka tukee `conda`-paketinhallintaa eri Python **virtuaaliympäristöille**.
Kun olet asentanut minicondan, kloonaa varasto ja luo virtuaaliympäristö tätä kurssia varten:
Kun olet asentanut minicondan, kloonaa repositorio ja luo virtuaaliympäristö tätä kurssia varten:
```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 ja Python-laajennus
### Visual Studio Coden käyttäminen Python-laajennuksella
Tätä opetussuunnitelmaa on parasta käyttää avaamalla se [Visual Studio Codessa](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) yhdessä [Python-laajennuksen](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste) kanssa.
Tämä opetussuunnitelma on parhaiten käytettävissä avaamalla se [Visual Studio Codessa](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) yhdessä [Python-laajennuksen](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste) kanssa.
> **Huomautus**: Kun kloonaat ja avaat hakemiston VS Codessa, se ehdottaa automaattisesti Python-laajennusten asentamista. Sinun on myös asennettava miniconda kuten yllä on kuvattu.
> **Huom:** Kun kloonaat ja avaat kansion VS Codessa, se ehdottaa automaattisesti Python-laajennusten asentamista. Sinun täytyy myös asentaa miniconda yllä kuvatulla tavalla.
> **Huomautus**: Jos VS Code ehdottaa varaston uudelleenavaamista säiliössä, sinun tulisi kieltäytyä tästä käyttääksesi paikallista Python-asennusta.
> **Huom:** Jos VS Code ehdottaa kansion uudelleenavaamista kontissa, sinun kannattaa kieltäytyä tästä käyttääksesi paikallista Python-asennusta.
### Jupyterin käyttäminen selaimessa
### Jupyteriä selaimessa käyttäen
Voit käyttää Jupyter-ympäristöä myös selaimella omalla tietokoneellasi. Sekä perinteinen Jupyter että JupyterHub tarjoavat kätevän kehitysympäristön automaattisen täydennyksen, koodin korostuksen jne. kanssa.
Voit myös käyttää Jupyter-ympäristöä selaimessa omalla tietokoneellasi. Sekä klassinen Jupyter että JupyterHub tarjoavat kätevän kehitysympäristön automaattisen täydennyksen, koodin korostuksen yms. kanssa.
Käynnistääksesi Jupyterin paikallisesti, siirry kurssin hakemistoon ja suorita:
Aloittaaksesi Jupyteriä paikallisesti, siirry kurssin kansioon ja suorita:
```bash
jupyter notebook
@ -36,36 +36,36 @@ tai
```bash
jupyterhub
```
Sen jälkeen voit siirtyä mihin tahansa `.ipynb`-tiedostoon, avata ne ja aloittaa työskentelyn.
Sitten voit siirtyä mihin tahansa `.ipynb`-tiedostoista, avata ne ja aloittaa työn.
### Suorittaminen säiliössä
### Ajaminen kontissa
Yksi vaihtoehto Python-asennukselle on suorittaa koodi säiliössä. Koska varastomme sisältää erityisen `.devcontainer`-kansion, joka ohjeistaa, miten säiliö rakennetaan tälle repositoriolle, VS Code tarjoaa mahdollisuuden avata koodin uudelleen säiliössä. Tämä vaatii Dockerin asennuksen ja on myös monimutkaisempi, joten suosittelemme tätä kokeneemmille käyttäjille.
Vaihtoehtona Python-asennukselle voit ajaa koodin kontissa. Koska meidän repositoriomme sisältää erityisen `.devcontainer`-kansion, joka ohjeistaa konttien rakentamista tälle repositoriolle, VS Code tarjoaa mahdollisuuden avata koodin uudelleen kontissa. Tämä vaatii Dockeriin asennuksen ja on myös monimutkaisempi, joten suosittelemme tätä kokeneemmille käyttäjille.
## Suorittaminen pilvessä
## Ajaminen pilvessä
Jos et halua asentaa Pythonia paikallisesti, mutta sinulla on pääsy joihinkin pilviresursseihin, hyvä vaihtoehto on suorittaa koodi pilvessä. Tämä onnistuu monella tavalla:
Jos et halua asentaa Pythonia paikallisesti ja sinulla on pääsy joihinkin pilviresursseihin, hyvä vaihtoehto on ajaa koodi pilvessä. Tätä voit tehdä monella tavalla:
* Käyttämällä **[GitHub Codespaces](https://github.com/features/codespaces)** -ympäristöä, joka on sinulle luotu virtuaaliympäristö GitHubissa ja johon pääsee VS Code -selaimen kautta. Jos sinulla on pääsy Codespacesiin, voit vain klikata varastossa **Code**-painiketta, aloittaa codespacen ja päästä nopeasti alkuun.
* Käyttämällä **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) tarjoaa ilmaisia pilvilaskentaresursseja ihmisille, jotka haluavat kokeilla jotain koodia GitHubissa. Etusivulla on painike, jolla voi avata repositorion Binderissä – tämä vie sinut nopeasti Binder-sivustolle, joka rakentaa taustalla säiliön ja käynnistää sinulle Jupyter-verkko-rajapinnan saumattomasti.
* Käyttämällä **[GitHub Codespaces](https://github.com/features/codespaces)**, joka on sinulle GitHubissa luotu virtuaaliympäristö, jota pääset käyttämään VS Coden selainkäyttöliittymän kautta. Jos sinulla on pääsy Codespacesiin, voit vain klikata **Code**-painiketta repositoriossa, käynnistää codespacen ja päästä nopeasti töihin.
* Käyttämällä **[Binderia](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) tarjoaa ilmaisia pilvessä toimivia laskentaresursseja, jotta voit testata koodia GitHubissa. Alkusivulla on painike, jolla voit avata repositorion Binderissä – tämä vie sinut nopeasti binder-sivustolle, joka rakentaa taustalle konttialustan ja käynnistää sinulle sujuvasti Jupyter-verkkokäyttöliittymän.
> **Huomautus**: Väärinkäytösten estämiseksi Binderillä on estetty pääsy tiettyihin verkkoresursseihin. Tämä saattaa estää osaa koodista toimimasta, jos koodi hakee malleja ja/tai aineistoja julkisesta internetistä. Saatat tarvita kiertoteitä. Lisäksi Binderin tarjoamat laskentaresurssit ovat melko perustasoa, joten koulutus on hidasta, erityisesti myöhemmissä, vaativammissa leikkauksissa.
> **Huom:** väärinkäytösten estämiseksi Binderillä on estetty pääsy joihinkin verkkoresursseihin. Tämä saattaa estää joidenkin koodien toiminnan, jos ne hakevat malleja ja/tai aineistoja julkisesta internetistä. Sinun täytyy ehkä keksiä kiertotapoja. Lisäksi Binderin tarjoamat laskentaresurssit ovat varsin rajalliset, joten mallien koulutus on hidasta, varsinkin myöhemmissä ja monimutkaisemmissa tehtävissä.
## Suorittaminen pilvessä GPU:n kanssa
## Ajaminen pilvessä GPU:lla
Jotkut myöhemmistä tämän opetussuunnitelman oppitunneista hyötyvät suuresti GPU-tuesta. Mallin harjoittelu voi olla muuten tuskallisen hidasta. Vaihtoehtoja on muutamia, erityisesti jos sinulla on pääsy pilveen joko [Azure for Studentsin](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste) kautta tai oppilaitoksesi kautta:
Jotkin tämän opetussuunnitelman myöhemmistä tehtävistä hyötyvät suuresti GPU-tuesta. Esimerkiksi mallin koulutus voi olla muuten tuskallisen hidasta. Sinulla on muutama vaihtoehto, etenkin jos sinulla on pääsy pilveen joko [Azure for Studentsin](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste) kautta tai oppilaitoksesi kautta:
* Luo [Data Science Virtual Machine](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) ja yhdistä siihen Jupylerin kautta. Voit sitten kloonata repo suoraan koneelle ja aloittaa oppimisen. NC-sarjan virtuaalikoneissa on GPU-tuki.
* Luo [Data Science Virtual Machine](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) ja yhdistä siihen Jupyteriä käyttäen. Voit kloonata repositorion suorilta koneelle ja aloittaa opiskelun. NC-sarjan VM:issä on GPU-tuki.
> **Huomautus**: Joihinkin tilauksiin, mukaan lukien Azure for Students, ei kuulu GPU-tukea oletuksena. Saatat joutua pyytämään lisä-GPU-ytimiä teknisen tuen pyynnöllä.
> **Huom:** Jotkin tilaukset, mukaan lukien Azure for Students, eivät tarjoa GPU-tukea oletuksena. Saatat joutua pyytämään lisä-GPU-ytimiä teknisen tuen kautta.
* Luo [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) ja käytä siellä Notebook-ominaisuutta. [Tämä video](https://azure-for-academics.github.io/quickstart/azureml-papers/) näyttää, miten kloonataan repositorio Azure ML -muistikirjaan ja aloitetaan käyttö.
* Luo [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) ja käytä siellä Notebook-ominaisuutta. [Tämä video](https://azure-for-academics.github.io/quickstart/azureml-papers/) näyttää, miten kloonataan repositorio Azure ML Notebooksiin ja aletaan sitä käyttää.
Voit myös käyttää Google Colabia, joka sisältää jonkin verran ilmaista GPU-tukea, ja ladata Jupyter-muistikirjat sinne suorittaaksesi ne yksi kerrallaan.
Voit myös käyttää Google Colabia, joka tarjoaa jonkin verran ilmaista GPU-tukea, ja ladata sinne Jupyter-muistikirjat suoritettavaksi yksitellen.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Vastuuvapauslauseke**:
Tämä asiakirja on käännetty tekoälypohjaisella käännöspalvelulla [Co-op Translator](https://github.com/Azure/co-op-translator). Pyrimme tarkkuuteen, mutta ota huomioon, että automaattiset käännökset saattavat sisältää virheitä tai epätarkkuuksia. Alkuperäistä asiakirjaa sen alkuperäiskielellä tulee pitää virallisena lähteenä. Tärkeissä asioissa suositellaan ammattilaisen tekemää käännöstä. Emme ole vastuussa tämän käännöksen käytöstä aiheutuvista väärinymmärryksistä tai tulkinnoista.
Tämä asiakirja on käännetty käyttämällä tekoälypohjaista käännöspalvelua [Co-op Translator](https://github.com/Azure/co-op-translator). Vaikka pyrimme tarkkuuteen, otathan huomioon, että automaattiset käännökset saattavat sisältää virheitä tai epätarkkuuksia. Alkuperäinen asiakirja sen alkuperäiskielellä on virallinen lähde. Tärkeissä asioissa suositellaan ammattimaista ihmiskäännöstä. Emme ole vastuussa tämän käännöksen käytöstä aiheutuvista väärinymmärryksistä tai tulkinnoista.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

136
translations/fi/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb
View File

@ -6,9 +6,9 @@
"source": [
"# Esikoulutetut mallit ja siirto-oppiminen\n",
"\n",
"CNN-mallien kouluttaminen voi viedä paljon aikaa, ja siihen tarvitaan runsaasti dataa. Suuri osa ajasta kuluu parhaiten toimivien matalan tason suodattimien oppimiseen, joita verkko käyttää kuvioiden tunnistamiseen kuvista. Luonnollinen kysymys herää - voimmeko käyttää yhdellä datasetillä koulutettua neuroverkkoa ja mukauttaa sen luokittelemaan erilaisia kuvia ilman täydellistä koulutusprosessia?\n",
"CNN-mallien kouluttaminen voi viedä paljon aikaa, ja siihen tarvitaan paljon dataa. Suurin osa ajasta kuluu kuitenkin parhaiden matalan tason suodattimien oppimiseen, joita verkko käyttää kuvioiden erottamiseen kuvista. Nousee luonnollinen kysymys – voimmeko käyttää yhdellä aineistolla koulutettua neuroverkkoa ja sovittaa sen erilaisten kuvien luokitteluun ilman koko koulutusprosessia?\n",
"\n",
"Tätä lähestymistapaa kutsutaan **siirto-oppimiseksi**, koska siirrämme tietoa yhdestä neuroverkkon mallista toiseen. Siirto-oppimisessa aloitamme tyypillisesti esikoulutetulla mallilla, joka on koulutettu jollakin suurella kuvadatasetillä, kuten **ImageNet**. Nämä mallit osaavat jo hyvin tunnistaa erilaisia piirteitä yleisistä kuvista, ja monissa tapauksissa pelkkä luokittelijan rakentaminen näiden piirteiden päälle voi tuottaa hyviä tuloksia.\n"
"Tätä lähestymistapaa kutsutaan **siirto-oppimiseksi**, koska me siirrämme tietoa yhdestä neuroverkkomallista toiseen. Siirto-oppimisessa aloitetaan tyypillisesti esikoulutetulla mallilla, joka on koulutettu jollakin suurella kuvia sisältävällä aineistolla, kuten **ImageNet**-aineistolla. Nämä mallit pystyvät jo erinomaisesti erottamaan erilaisia piirteitä geneerisistä kuvista, ja monissa tapauksissa pelkkä luokittelijan rakentaminen näiden erottamien piirteiden päälle voi tuottaa hyviä tuloksia.\n"
]
},
{
@ -29,11 +29,11 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"## Kissat vs. Koirat -aineisto\n",
"## Kissat vastaan koirat -aineisto\n",
"\n",
"Tässä osiossa ratkaistaan käytännön ongelma, jossa luokitellaan kissojen ja koirien kuvia. Tätä varten käytämme [Kaggle Cats vs. Dogs Dataset](https://www.kaggle.com/c/dogs-vs-cats), joka on ladattavissa myös [Microsoftilta](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n",
"Tässä jaksossa ratkomme todellisen elämän ongelman, jossa luokittelemme kissan ja koiran kuvia. Tähän tarkoitukseen käytämme [Kaggle Kissat vastaan koirat -aineistoa](https://www.kaggle.com/c/dogs-vs-cats), jonka voi myös ladata [Microsoftin kautta](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n",
"\n",
"Ladataan tämä aineisto ja puretaan se `data`-hakemistoon (tämä prosessi voi kestää jonkin aikaa!):\n"
"Ladataan tämä aineisto ja puretaan se `data`-hakemistoon (tämä saattaa kestää jonkin aikaa!):\n"
]
},
{
@ -64,7 +64,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Valitettavasti aineistossa on joitakin vioittuneita kuvatiedostoja. Meidän täytyy tehdä nopea siivous tarkistaaksemme vioittuneet tiedostot. Jotta emme sotkisi tätä opasta, siirsimme koodin aineiston tarkistamiseen moduuliin.\n"
"Valitettavasti tietojoukossa on joitakin vioittuneita kuvafilejä. Meidän täytyy tehdä nopea siivous tarkistaaksemme vioittuneet tiedostot. Jotta emme sotkisi tätä opetusohjelmaa, siirsimme koodin tietojoukon tarkistamiseen moduuliin.\n"
]
},
{
@ -335,11 +335,11 @@
"source": [
"## Datan lataaminen\n",
"\n",
"Aiemmissa esimerkeissä latasimme Kerasin sisäänrakennettuja dataset-kokonaisuuksia. Nyt käsittelemme omaa datasettiämme, joka täytyy ladata kuvakansiosta.\n",
"Aiemmissa esimerkeissä lataimme Kerasin sisäisiä datasettejä. Nyt aiomme käsitellä omaa datasettiämme, joka pitää ladata kuvakansiosta.\n",
"\n",
"Todellisessa elämässä kuvadatasetit voivat olla melko suuria, eikä voi olettaa, että kaikki data mahtuisi muistiin. Siksi datasetit esitetään usein **generaattoreina**, jotka voivat palauttaa dataa pienissä erissä, jotka sopivat koulutukseen.\n",
"Todellisessa elämässä kuvadatasetit voivat olla melko suurikokoisia, eikä voi olettaa, että kaikki data mahtuu muistiin. Siksi datasetit esitetään usein **generaattoreina**, jotka voivat palauttaa dataa pieninä erinä, minibatcheina, sopivina koulutukseen.\n",
"\n",
"Kuvien luokittelua varten Keras sisältää erityisen funktion `image_dataset_from_directory`, joka voi ladata kuvia alikansioista, jotka vastaavat eri luokkia. Tämä funktio huolehtii myös kuvien skaalaamisesta, ja se voi jakaa datasetin myös koulutus- ja testiosiin:\n"
"Kuvaluokittelun käsittelemiseksi Keras sisältää erityisen funktion `image_dataset_from_directory`, joka voi ladata kuvia alikansioista, jotka vastaavat eri luokkia. Tämä funktio huolehtii myös kuvien skaalaamisesta ja se voi jakaa datasetin opetus- ja testiosiin:\n"
]
},
{
@ -383,9 +383,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"On tärkeää asettaa sama `seed`-arvo molemmille kutsuille, koska se vaikuttaa kuvien jakautumiseen harjoitus- ja testiaineistojen välillä.\n",
"On tärkeää asettaa sama `seed`-arvo molemmille kutsuille, koska se vaikuttaa kuvien jakautumiseen opetus- ja testiaineistojen välillä.\n",
"\n",
"Dataset poimii automaattisesti luokkien nimet hakemistoista, ja voit käyttää niitä tarvittaessa kutsumalla:\n"
"Dataset valitsee luokkien nimet automaattisesti hakemistoista, ja niihin voi halutessaan päästä käsiksi kutsumalla:\n"
]
},
{
@ -412,7 +412,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Datasetit, jotka olemme hankkineet, voidaan siirtää suoraan `fit`-funktiolle mallin kouluttamiseksi. Ne sisältävät sekä vastaavat kuvat että tunnisteet, joita voidaan käydä läpi seuraavalla rakenteella:\n"
"Kokoelmat, jotka olemme saaneet, voidaan välittömästi syöttää `fit`-funktioon mallin kouluttamiseksi. Ne sisältävät sekä vastaavat kuvat että tunnisteet, joita voidaan käydä läpi seuraavalla rakenteella:\n"
]
},
{
@ -453,16 +453,16 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"> **Huom**: Kaikki datasetin kuvat ovat esitettyinä liukulukuina, joiden arvojen vaihteluväli on 0-255. Ennen kuin ne syötetään neuroverkkoon, meidän täytyy skaalata nämä arvot 0-1 välille. Kuvia piirrettäessä meidän täytyy joko tehdä sama tai muuntaa arvot `int`-tyyppisiksi (kuten teemme yllä olevassa koodissa), jotta voimme näyttää `matplotlib`ille, että haluamme piirtää alkuperäisen skaalaamattoman kuvan.\n"
"> **Huom**: Kaikki datasetin kuvat on esitetty liukulukupiste-tensoreina arvoalueella 0-255. Ennen niiden syöttämistä neuroverkkoon, meidän täytyy skaalata nuo arvot alueelle 0-1. Kun piirrämme kuvia, meidän täytyy tehdä sama tai muuntaa arvot `int`-tyyppiin (kuten teemme yllä olevassa koodissa), jotta voimme näyttää `matplotlib`:lle, että haluamme piirtää alkuperäisen skaalaamattoman kuvan.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Esikoulutetut mallit\n",
"## Ennakkokoulutetut mallit\n",
"\n",
"Moniin kuvien luokittelutehtäviin löytyy esikoulutettuja neuroverkkomalleja. Monet näistä malleista ovat saatavilla `keras.applications`-nimialueen sisällä, ja vielä enemmän malleja löytyy Internetistä. Katsotaan, kuinka yksinkertaisin VGG-16-malli voidaan ladata ja käyttää:\n"
"Moniin kuvien luokittelutehtäviin löytyy ennakkokoulutettuja neuroverkkimalleja. Monet näistä malleista ovat saatavilla `keras.applications`-nimialueessa, ja vielä useampia malleja löytyy internetistä. Katsotaan, kuinka yksinkertaisin VGG-16-malli voidaan ladata ja ottaa käyttöön:\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,18 +520,17 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Tässä on muutamia tärkeitä asioita:\n",
"\n",
"* Ennen kuin syöte annetaan millekään valmiiksi koulutetulle verkolle, se täytyy esikäsitellä tietyllä tavalla. Tämä tehdään kutsumalla vastaavaa `preprocess_input`-funktiota, joka vastaanottaa joukon kuvia ja palauttaa niiden käsitellyn muodon. VGG-16:n tapauksessa kuvat normalisoidaan, ja jokaiselta kanavalta vähennetään ennalta määritelty keskiarvo. Tämä johtuu siitä, että VGG-16 on alun perin koulutettu käyttämällä tätä esikäsittelyä.\n",
"* Neuroverkko sovelletaan syötejoukkoon, ja tuloksena saadaan joukko 1000-alkioisia tensoreita, jotka osoittavat kunkin luokan todennäköisyyden. Voimme löytää todennäköisimmän luokan numeron kutsumalla `argmax`-funktiota tälle tensorille.\n",
"* Saatu tulos on [`ImageNet`-luokan numero](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). Jotta tulos olisi ymmärrettävämpi, voimme käyttää myös `decode_predictions`-funktiota, joka palauttaa n parasta luokkaa yhdessä niiden nimien kanssa.\n"
"Tässä on muutama tärkeä asia:\n",
"* Ennen syötteen antamista mille tahansa esikoulutetulle verkolle, se on käsiteltävä tietyllä tavalla. Tämä tehdään kutsumalla vastaavaa `preprocess_input`-funktiota, joka saa erän kuvia ja palauttaa niiden käsitellyn muodon. VGG-16:n tapauksessa kuvat normalisoidaan ja kanaville lasketut ennalta määritetyt keskiarvot vähennetään niistä. Tämä johtuu siitä, että VGG-16 oli alun perin koulutettu tällä esikäsittelyllä.\n",
"* Neuroverkkoa sovelletaan syöte-erään, ja tuloksena saadaan erä 1000-ulotteisia tensoreita, jotka näyttävät kunkin luokan todennäköisyyden. Todennäköisin luokka saadaan kutsumalla `argmax`-funktiota tälle tensorille.\n",
"* Saadun tuloksen arvo on [`ImageNet`-luokan numero](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). Jotta tästä tuloksesta saa merkityksen, voimme myös käyttää `decode_predictions`-funktiota, joka palauttaa parhaan n luokan nimet niiden kanssa.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Katsotaan myös VGG-16-verkon arkkitehtuuria:\n"
"Katsotaanpa myös VGG-16-verkon arkkitehtuuria:\n"
]
},
{
@ -598,9 +607,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"## GPU-laskenta\n",
"## GPU-laskennat\n",
"\n",
"Syvät neuroverkot, kuten VGG-16 ja muut modernimmat arkkitehtuurit, vaativat melko paljon laskentatehoa toimiakseen. On järkevää hyödyntää GPU-kiihdytystä, jos se on saatavilla. Onneksi Keras nopeuttaa automaattisesti laskentaa GPU:lla, jos sellainen on käytettävissä. Voimme tarkistaa, pystyykö Tensorflow käyttämään GPU:ta seuraavalla koodilla:\n"
"Syvät neuroverkot, kuten VGG-16 ja muut modernimmat arkkitehtuurit, vaativat melko paljon laskentatehoa toimiakseen. On järkevää käyttää GPU-kiihdytystä, jos se on saatavilla. Onneksi Keras nopeuttaa automaattisesti laskentoja GPU:lla, jos se on käytettävissä. Voimme tarkistaa, pystyykö Tensorflow käyttämään GPU:ta seuraavalla koodilla:\n"
]
},
{
@ -627,9 +636,10 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"## VGG-piirteiden erottaminen\n",
"\n",
"Jos haluamme käyttää VGG-16-mallia kuvien piirteiden erottamiseen, tarvitsemme mallin ilman lopullisia luokittelukerroksia. Voimme luoda VGG-16-mallin ilman yläkerroksia käyttämällä tätä koodia:\n"
"## VGG-ominaisuuksien poimiminen\n",
"\n",
"Jos haluamme käyttää VGG-16 -mallia piirteiden poimimiseen kuvistamme, tarvitsemme mallin ilman viimeisiä luokittelukerroksia. Voimme luoda VGG-16 -mallin ilman yläkerroksia seuraavalla koodilla:\n"
]
},
{
@ -681,9 +691,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Ominaisuustensorin ulottuvuus on 7x7x512, mutta jotta voisimme visualisoida sen, meidän täytyi muuttaa sen muoto 2D-muotoon.\n",
"Ominaisuustensorin ulottuvuus on 7x7x512, mutta jotta voisimme visualisoida sen, meidän piti muotoilla se uudelleen 2D-muotoon.\n",
"\n",
"Katsotaanpa nyt, voisiko näitä ominaisuuksia käyttää kuvien luokitteluun. Otetaan käsin jokin osa kuvista (tapauksessamme 50 minibatchia) ja esilasketaan niiden ominaisuusvektorit. Voimme käyttää Tensorflow'n **dataset**-rajapintaa tämän tekemiseen. `map`-funktio ottaa datasetin ja soveltaa siihen annettua lambda-funktiota muuntaakseen sen. Käytämme tätä mekanismia luodaksemme uudet datasetit, `ds_features_train` ja `ds_features_test`, jotka sisältävät VGG:n tuottamat ominaisuudet alkuperäisten kuvien sijaan.\n"
"Nyt kokeillaan, voidaanko näitä ominaisuuksia käyttää kuvien luokitteluun. Otetaan manuaalisesti osa kuvista (meidän tapauksessamme 50 minibatchia) ja esilasketaan niiden ominaisuusvektorit. Voimme käyttää Tensorflow'n **dataset**-API:a tätä varten. `map`-funktio ottaa datasetin ja soveltaa annettua lambda-funktiota muuntaakseen sen. Käytämme tätä mekanismia rakentaaksemme uudet datasetit, `ds_features_train` ja `ds_features_test`, jotka sisältävät VGG:n poimimat ominaisuudet alkuperäisten kuvien sijaan.\n"
]
},
{
@ -713,9 +723,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Käytimme konstruktiota `.take(50)` rajoittaaksemme aineiston kokoa, jotta demonstraatiomme olisi nopeampi. Voit tietenkin suorittaa tämän kokeen koko aineistolla.\n",
"Käytimme rakennetta `.take(50)` rajoittaaksemme aineiston kokoa, jotta esittelymme nopeutuisi. Voit tietenkin suorittaa tämän kokeen koko aineistolla.\n",
"\n",
"Nyt kun meillä on ominaisuudet sisältävä aineisto, voimme kouluttaa yksinkertaisen tiheän luokittelijan erottamaan kissat ja koirat. Tämä verkko ottaa syötteenä ominaisuusvektorin, jonka muoto on (7,7,512), ja tuottaa yhden ulostulon, joka vastaa joko koiraa tai kissaa. Koska kyseessä on binääriluokittelu, käytämme `sigmoid`-aktivointifunktiota ja `binary_crossentropy`-tappiota.\n"
"Nyt kun meillä on ominaisuudet eroteltu aineisto, voimme kouluttaa yksinkertaisen tiheän luokittelijan erottamaan kissat ja koirat. Tämä verkko ottaa syötteenä ominaisuusvektorin, jonka muoto on (7,7,512), ja tuottaa yhden ulostulon, joka vastaa joko koiraa tai kissaa. Koska kyseessä on binääriluokitus, käytämme `sigmoid` aktivointifunktiota ja `binary_crossentropy`-häviöfunktiota.\n"
]
},
{
@ -744,13 +754,13 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Tulokset ovat erinomaisia, pystymme erottamaan kissan ja koiran lähes 95 % todennäköisyydellä! Olemme kuitenkin testanneet tätä lähestymistapaa vain osajoukolla kaikista kuvista, koska manuaalinen piirteiden erottelu vaikuttaa vievän paljon aikaa.\n",
"Tulos on erinomainen, voimme erottaa kissan ja koiran lähes 95 % todennäköisyydellä! Olemme kuitenkin testanneet tätä lähestymistapaa vain osajoukolla kaikista kuvista, koska ominaisuuksien manuaalinen poiminta näyttää vievän paljon aikaa.\n",
"\n",
"## Siirto-oppiminen käyttäen yhtä VGG-verkkoa\n",
"## Siirto-oppiminen käyttämällä yhtä VGG-verkkoa\n",
"\n",
"Voimme myös välttää piirteiden manuaalisen esilaskennan käyttämällä alkuperäistä VGG-16-verkkoa kokonaisuudessaan koulutuksen aikana lisäämällä piirteiden erottelijan verkkomme ensimmäiseksi kerrokseksi.\n",
"Voimme myös välttää ominaisuuksien manuaalisen esilaskennan käyttämällä alkuperäistä VGG-16 -verkkoa kokonaisuudessaan koulutuksen aikana lisäämällä ominaisuuksien poimija verkkoomme ensimmäiseksi kerrokseksi.\n",
"\n",
"Keras-arkkitehtuurin hienous on siinä, että yllä määriteltyä VGG-16-mallia voidaan käyttää myös kerroksena toisessa neuroverkossa! Meidän tarvitsee vain rakentaa verkko, jossa on tiheä luokitin sen päällä, ja sitten kouluttaa koko verkko takaisinlevityksen avulla.\n"
"Keras-arkkitehtuurin kauneus on siinä, että yllä määrittelemäämme VGG-16 -mallia voidaan käyttää myös kerroksena toisessa neuroverkossa! Meidän tarvitsee vain rakentaa verkko, jonka päälle on lisätty tiheä luokittelija, ja sitten kouluttaa koko verkko takaisinsyötöllä.\n"
]
},
{
@ -794,13 +804,13 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Tämä malli näyttää olevan end-to-end-luokitusverkko, joka ottaa kuvan ja palauttaa luokan. Kuitenkin haastavaa tässä on se, että haluamme VGG16:n toimivan piirteenpoimijana eikä sitä tule uudelleenkouluttaa. Siksi meidän täytyy **lukita konvoluutiopiirteenpoimijan painot**. Voimme käyttää verkon ensimmäistä kerrosta kutsumalla `model.layers[0]`, ja meidän tarvitsee vain asettaa `trainable`-ominaisuus arvoon `False`.\n",
"Tämä malli näyttää päästä päähän luokittelukoneistolta, joka ottaa kuvan ja palauttaa luokan. Kuitenkin hankala asia on se, että haluamme VGG16:n toimivan ominaisuuksien erottimena, emmekä halua sen uudelleenkouluttamista. Siksi meidän täytyy **jäädyttää konvoluutio-ominaisuuksien erotinkerroksen painot**. Pääsemme verkon ensimmäiseen kerrokseen kutsumalla `model.layers[0]`, ja meidän tarvitsee vain asettaa `trainable` -ominaisuus arvoksi `False`.\n",
"\n",
"> **Huomio**: Piirteenpoimijan painojen lukitseminen on tarpeen, koska muuten kouluttamaton luokittelukerros voi tuhota konvoluutiopiirteenpoimijan alkuperäiset esikoulutetut painot.\n",
"> **Huom**: Ominaisuuksien erotinkerroksen painojen jäädyttäminen on tarpeen, koska muuten kouluttamaton luokittelukerros voi tuhota alkuperäiset, esikoulutetut konvoluutioerottimen painot.\n",
"\n",
"Voit huomata, että vaikka verkkomme kokonaisparametrien määrä on noin 15 miljoonaa, koulutamme vain 25 000 parametria. Kaikki muut huipputason konvoluutiosuodattimien parametrit ovat esikoulutettuja. Tämä on hyvä asia, koska pystymme hienosäätämään pienemmän määrän parametreja pienemmällä määrällä esimerkkejä.\n",
"Huomaat, että vaikka verkkomme kokonaisparametrien määrä on noin 15 miljoonaa, koulutamme vain 25 000 parametria. Kaikki muut ylin tason konvoluutiosuodatinten parametrit ovat esikoulutettuja. Se on hyvä, koska pystymme hienosäätämään pienempää määrää parametreja pienemmällä määrällä esimerkkejä.\n",
"\n",
"Seuraavaksi koulutamme verkkomme ja katsomme, kuinka hyväksi voimme päästä. Odota melko pitkää suoritusaikaa, eikä tarvitse huolestua, vaikka suoritus vaikuttaisi hetkellisesti pysähtyneeltä.\n"
"Koulutamme nyt verkkomme ja katsomme, kuinka hyväksi se voi tulla. Odota melko pitkä suoritusaika, äläkä huolestu, jos suoritus näyttää pysähtyneeltä hetkeksi.\n"
]
},
{
@ -825,11 +835,11 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Näyttää siltä, että olemme saaneet aikaan melko tarkan kissojen ja koirien luokittelijan!\n",
"Näyttää siltä, että olemme saaneet kohtuullisen tarkan kissat vs. koirat -luokittelijan! \n",
"\n",
"## Mallin tallentaminen ja lataaminen\n",
"\n",
"Kun olemme kouluttaneet mallin, voimme tallentaa mallin arkkitehtuurin ja koulutetut painot tiedostoon tulevaa käyttöä varten:\n"
"Kun olemme kouluttaneet mallin, voimme tallentaa mallin arkkitehtuurin ja koulutetut painot tiedostoon myöhempää käyttöä varten:\n"
]
},
{
@ -853,7 +863,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Voimme sitten ladata mallin tiedostosta milloin tahansa. Saatat pitää sitä hyödyllisenä, jos seuraava kokeilu tuhoaa mallin - sinun ei tarvitsisi aloittaa alusta.\n"
"Mallin voi sitten ladata tiedostosta milloin tahansa. Tämä voi olla hyödyllistä, jos seuraava koe tuhoaa mallin – sinun ei tarvitse aloittaa alusta.\n"
]
},
{
@ -869,15 +879,15 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"## Hienosäätö siirtoppimista\n",
"## Siirtokoulutuksen hienosäätö\n",
"\n",
"Edellisessä osiossa koulutimme lopullisen luokittelukerroksen luokittelemaan kuvia omassa aineistossamme. Emme kuitenkaan uudelleenkouluttaneet piirteenpoimijaa, ja mallimme perustui ImageNet-datasta opittuihin piirteisiin. Jos kohteesi eroavat visuaalisesti tavallisista ImageNet-kuvista, tämä piirteiden yhdistelmä ei välttämättä toimi parhaalla mahdollisella tavalla. Siksi on järkevää aloittaa myös konvoluutiokerrosten kouluttaminen.\n",
"Edellisessä osassa koulutimme lopullisen luokittelukerroksen luokittelemaan kuvat omassa datasetissämme. Emme kuitenkaan uudelleenkouluttaneet piirteiden erottajaa, ja mallimme luotti piirteisiin, joita malli oli oppinut ImageNet-datassa. Jos kohteesi eroavat visuaalisesti tavallisista ImageNet-kuvista, tämä piirteiden yhdistelmä ei ehkä toimi parhaiten. Siksi on järkevää aloittaa myös konvoluutio­kerrosten kouluttaminen.\n",
"\n",
"Tätä varten voimme avata aiemmin jäädytettyjen konvoluutiokerrosten suodatinparametrit.\n",
"Tehdäksemme tämän voimme avata aiemmin jäädytetyt konvoluutiosuodattimien parametrit uudelleen.\n",
"\n",
"> **Note:** On tärkeää, että jäädytät parametrit ensin ja suoritat useita koulutusepookkeja, jotta luokittelukerroksen painot vakautuvat. Jos aloitat heti koko verkon kouluttamisen avatuilla parametreilla, suuret virheet voivat tuhota konvoluutiokerrosten esikoulutetut painot.\n",
"> **Huom:** On tärkeää, että ensin jäädytät parametrit ja suoritat useita oppimiskierroksia vakauttaaksesi painot luokittelukerroksessa. Jos aloitat heti koko verkon loppupään koulutuksen jäädyttämättömillä parametreilla, suuret virheet voivat tuhota ennakkoon koulutetut painot konvoluutio­kerroksissa.\n",
"\n",
"Konvoluutio-VGG-16-mallimme sijaitsee ensimmäisessä kerroksessa, ja se koostuu monista kerroksista. Voimme tarkastella sen rakennetta:\n"
"Konvoluutio-VGG-16-mallimme sijaitsee ensimmäisessä kerroksessa, ja se koostuu itse useista kerroksista. Voimme tarkastella sen rakennetta:\n"
]
},
{
@ -946,7 +956,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Voimme poistaa jäädytyksen kaikista konvoluutiopohjan kerroksista:\n"
"Voimme vapauttaa kaikki kerrokset konvoluutioalustasta: \n"
]
},
{
@ -962,7 +972,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Kuitenkin, kaikkien kerrosten sulattaminen kerralla ei ole paras idea. Voimme ensin sulattaa vain muutaman viimeisen konvoluutiokerroksen, koska ne sisältävät korkeampia tason kuvioita, jotka ovat merkityksellisiä kuvillemme. Esimerkiksi aluksi voimme jäädyttää kaikki kerrokset paitsi viimeiset 4:\n"
"Kuitenkin kaikkien niiden sammuttaminen yhtä aikaa ei ole paras ajatus. Voimme ensin poistaa käytöstä vain muutamia viimeisiä konvoluutikerroksia, koska ne sisältävät korkeampia tasoja olevia kuvioita, jotka ovat tärkeitä kuvillemme. Esimerkiksi aluksi voimme jäädyttää kaikki kerrokset paitsi viimeiset 4: \n"
]
},
{
@ -1001,11 +1011,11 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Huomaa, että opetettavien parametrien määrä kasvoi merkittävästi, mutta se on silti noin 50 % kaikista parametreista.\n",
"Huomaa, että koulutettavien parametrien määrä kasvoi merkittävästi, mutta se on silti noin 50 % kaikista parametreista.\n",
"\n",
"Kun jäädytys poistetaan, voimme tehdä muutaman lisäepookin koulutusta (esimerkissämme teemme vain yhden). Voit myös valita pienemmän oppimisnopeuden, jotta minimoidaan vaikutus esikoulutettuihin painoihin. Kuitenkin, vaikka oppimisnopeus olisi alhainen, voit odottaa tarkkuuden laskevan koulutuksen alussa, kunnes se lopulta saavuttaa hieman korkeamman tason kuin kiinteiden painojen tapauksessa.\n",
"Jäädytyksen purkamisen jälkeen voimme tehdä vielä muutaman koulutuskierroksen (esimerkissä teemme vain yhden). Voit myös valita alemman oppimisnopeuden minimoidaksesi vaikutuksen esikoulutettuihin painoihin. Kuitenkin jopa matalalla oppimisnopeudella tarkkuuden odotetaan laskevan koulutuksen alussa, kunnes se lopulta saavuttaa hieman korkeamman tason kuin kiinteillä painoilla.\n",
"\n",
"> **Huom:** Tämä koulutus tapahtuu paljon hitaammin, koska meidän täytyy välittää gradientit takaisin verkon monien kerrosten läpi!\n"
"> **Huom:** Tämä koulutus tapahtuu paljon hitaammin, koska gradienttien täytyy kulkea takaisin verkon monen kerroksen läpi!\n"
]
},
{
@ -1029,18 +1039,18 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Olemme todennäköisesti saavuttamassa korkeampaa koulutustarkkuutta, koska käytämme tehokkaampaa verkkoa, jossa on enemmän parametreja, mutta validointitarkkuus ei välttämättä parane yhtä paljon.\n",
"Todennäköisesti saavuttamme korkeamman harjoitustarkkuuden, koska käytämme tehokkaampaa verkkoa, jossa on enemmän parametreja, mutta validointitarkkuus ei todennäköisesti kasva yhtä paljon.\n",
"\n",
"Voit halutessasi avata muutaman lisäkerroksen verkosta ja jatkaa koulutusta nähdäksesi, pystytkö saavuttamaan paremman tarkkuuden!\n"
"Voit vapaasti vapauttaa muutaman kerroksen lisää verkosta ja treenata enemmän nähdäksesi, pystytkö saavuttamaan korkeamman tarkkuuden!\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Muut tietokonenäkömallit\n",
"## Muut tietokonenäön mallit\n",
"\n",
"VGG-16 on yksi yksinkertaisimmista tietokonenäön arkkitehtuureista. Keras tarjoaa monia muita valmiiksi koulutettuja verkkoja. Näistä yleisimmin käytettyjä ovat Microsoftin kehittämät **ResNet**-arkkitehtuurit ja Googlen **Inception**. Esimerkiksi, tutkitaan yksinkertaisimman ResNet-50-mallin arkkitehtuuria (ResNet on malliperhe, jossa on eri syvyyksiä – voit kokeilla ResNet-152:ta, jos haluat nähdä, miltä todella syvä malli näyttää):\n"
"VGG-16 on yksi yksinkertaisimmista tietokonenäön arkkitehtuureista. Keras tarjoaa monia muita ennalta koulutettuja verkkoja. Yleisimmin käytettyjä näistä ovat Microsoftin kehittämät **ResNet**-arkkitehtuurit ja Googlen **Inception**. Esimerkiksi tutustutaan yksinkertaisimman ResNet-50-mallin arkkitehtuuriin (ResNet on malliperhe, jossa on eri syvyyksiä, voit kokeilla ResNet-152:ta, jos haluat nähdä, miltä todella syvä malli näyttää):\n"
]
},
{
@ -1442,11 +1452,11 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Kuten huomaat, malli sisältää samat tutut rakennuspalikat: konvoluutiokerrokset, pooling-kerrokset ja lopullisen tiheän luokittelijan. Voimme käyttää tätä mallia täsmälleen samalla tavalla kuin olemme käyttäneet VGG-16:ta siirto-oppimiseen. Voit kokeilla yllä olevaa koodia, käyttää eri ResNet-malleja pohjamallina ja nähdä, miten tarkkuus muuttuu.\n",
"Kuten näet, malli sisältää samat tutut rakennuspalikat: konvoluutio-kerrokset, poolauskerrokset ja lopullisen tiheän luokittelijan. Voimme käyttää tätä mallia täsmälleen samalla tavalla kuin olemme käyttäneet VGG-16:ta siirto-opetuksessa. Voit kokeilla koodia yllä, käyttäen erilaisia ResNet-malleja perusmallina, ja nähdä kuinka tarkkuus muuttuu.\n",
"\n",
"## Eränormalisointi\n",
"\n",
"Tämä verkko sisältää vielä yhden kerrostyypin: **Eränormalisointi**. Eränormalisoinnin idea on tuoda arvot, jotka kulkevat hermoverkon läpi, oikealle välille. Yleensä hermoverkot toimivat parhaiten, kun kaikki arvot ovat välillä [-1,1] tai [0,1], ja siksi skaalaamme/normalisoimme syöttödatamme vastaavasti. Kuitenkin syvän verkon koulutuksen aikana voi tapahtua, että arvot menevät merkittävästi tämän alueen ulkopuolelle, mikä tekee koulutuksesta ongelmallista. Eränormalisointikerros laskee keskiarvon ja keskihajonnan kaikille nykyisen minibatchin arvoille ja käyttää niitä signaalin normalisointiin ennen sen kulkua hermoverkon kerroksen läpi. Tämä parantaa merkittävästi syvien verkkojen vakautta.\n"
"Tämä verkko sisältää vielä toisen tyyppisen kerroksen: **Eränormalisoinnin**. Eränormalisoinnin idea on tuoda arvot, jotka kulkevat neuroverkon läpi, oikealle alueelle. Yleensä neuroverkot toimivat parhaiten, kun kaikki arvot ovat välillä [-1,1] tai [0,1], ja siksi skaalaamme/normalisoimme syöttötietomme vastaavasti. Kuitenkin syvän verkon koulutuksen aikana voi tapahtua, että arvot poikkeavat merkittävästi tästä alueesta, mikä vaikeuttaa koulutusta. Eränormalisointikerros laskee keskiarvon ja keskihajonnan kaikille nykyisen pienryhmän arvoille, ja käyttää niitä signaalin normalisointiin ennen sen läpivientiä neuroverkon kerroksen läpi. Tämä parantaa merkittävästi syvien verkkojen vakautta.\n"
]
},
{
@ -1455,16 +1465,16 @@
"source": [
"## Yhteenveto\n",
"\n",
"Siirtämällä oppimista hyödyntämällä pystyimme nopeasti kokoamaan luokittelijan omaa objektien luokittelutehtäväämme varten ja saavuttamaan korkean tarkkuuden. Tämä esimerkki ei kuitenkaan ollut täysin reilu, koska alkuperäinen VGG-16-verkko oli esikoulutettu tunnistamaan kissoja ja koiria, joten käytimme vain uudelleen suurinta osaa verkossa jo olevista malleista. Voit odottaa alhaisempaa tarkkuutta eksoottisemmilla, tiettyyn alaan liittyvillä objekteilla, kuten tuotantolinjan yksityiskohdilla tehtaassa tai eri puiden lehdillä.\n",
"Siirto-oppimisen avulla pystyimme nopeasti kokoamaan luokittelijan omaa kohdeluokittelutehtäväämme varten ja saavuttamaan korkean tarkkuuden. Tämä esimerkki ei kuitenkaan ollut täysin reilu, koska alkuperäinen VGG-16-verkko oli esikoulutettu tunnistamaan kissoja ja koiria, joten käytimme uudelleen suurinta osaa verkossa jo olemassa olleista malleista. Voit odottaa alhaisempaa tarkkuutta eksoottisemmilla, domaineihin sidotulla kohteilla, kuten tehtaan tuotantolinjan yksityiskohdilla tai erilaisilla puun lehdillä.\n",
"\n",
"Voit huomata, että monimutkaisemmat tehtävät, joita nyt ratkaisemme, vaativat enemmän laskentatehoa, eikä niitä voida helposti ratkaista pelkällä suorittimella. Seuraavassa osiossa yritämme käyttää kevyempää toteutusta kouluttaaksemme saman mallin pienemmillä laskentaresursseilla, mikä johtaa vain hieman alhaisempaan tarkkuuteen.\n"
"Näet, että nykyiset monimutkaisemmat tehtävät vaativat suurempaa laskentatehoa, eikä niitä voi helposti ratkaista pelkällä suorittimella. Seuraavassa jaksossa yritämme käyttää kevyempää toteutusta kouluttaaksemme saman mallin käyttäen vähemmän laskentaresursseja, mikä johtaa vain hieman alhaisempaan tarkkuuteen. \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n---\n\n**Vastuuvapauslauseke**: \nTämä asiakirja on käännetty käyttämällä tekoälypohjaista käännöspalvelua [Co-op Translator](https://github.com/Azure/co-op-translator). Vaikka pyrimme tarkkuuteen, huomioithan, että automaattiset käännökset voivat sisältää virheitä tai epätarkkuuksia. Alkuperäinen asiakirja sen alkuperäisellä kielellä tulisi pitää ensisijaisena lähteenä. Kriittisen tiedon osalta suositellaan ammattimaista ihmiskäännöstä. Emme ole vastuussa väärinkäsityksistä tai virhetulkinnoista, jotka johtuvat tämän käännöksen käytöstä.\n"
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**Vastuuvapauslauseke**:\nTämä asiakirja on käännetty käyttämällä tekoälypohjaista käännöspalvelua [Co-op Translator](https://github.com/Azure/co-op-translator). Vaikka pyrimme tarkkuuteen, otathan huomioon, että automaattiset käännökset saattavat sisältää virheitä tai epätarkkuuksia. Alkuperäinen asiakirja sen alkuperäiskielellä on virallinen lähde. Tärkeissä asioissa suositellaan ammattimaista ihmiskäännöstä. Emme ole vastuussa tämän käännöksen käytöstä aiheutuvista väärinymmärryksistä tai tulkinnoista.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
]
}
],
@ -1485,12 +1495,6 @@
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.10"
},
"coopTranslator": {
"original_hash": "c189abc107848f96051085cc30945129",
"translation_date": "2025-08-28T20:34:52+00:00",
"source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb",
"language_code": "fi"
}
},
"nbformat": 4,

66
translations/fi/lessons/5-NLP/README.md
View File

@ -1,51 +1,51 @@
# Luonnollisen kielen käsittely
![Yhteenveto NLP-tehtävistä doodlena](../../../../translated_images/fi/ai-nlp.b22dcb8ca4707cea.webp)
![Yhteenveto NLP-tehtävistä piirroksena](../../../../translated_images/fi/ai-nlp.b22dcb8ca4707cea.webp)
Tässä osiossa keskitymme käyttämään neuroverkkoja **luonnollisen kielen käsittelyyn (NLP)** liittyvien tehtävien ratkaisemiseen. On monia NLP-ongelmia, joita haluamme tietokoneiden pystyvän ratkaisemaan:
Tässä osiossa keskitymme käyttämään hermoverkkoja tehtävien käsittelemiseksi, jotka liittyvät **luonnollisen kielen käsittelyyn (NLP)**. On monia NLP-ongelmia, jotka haluamme tietokoneiden pystyvän ratkaisemaan:
* **Tekstin luokittelu** on tyypillinen luokitteluongelma, joka liittyy tekstijonoihin. Esimerkkejä ovat sähköpostiviestien luokittelu roskapostiksi tai ei-roskapostiksi, tai artikkeleiden luokittelu urheiluun, liiketoimintaan, politiikkaan jne. Lisäksi chatbotteja kehitettäessä meidän on usein ymmärrettävä, mitä käyttäjä haluaa sanoa – tässä tapauksessa käsittelemme **tarkoituksen luokittelua**. Tarkoituksen luokittelussa on usein käsiteltävä monia kategorioita.
* **Tunneanalyysi** on tyypillinen regressio-ongelma, jossa meidän on annettava lauseelle numero (tunne), joka vastaa sen positiivisuuden/negatiivisuuden astetta. Kehittyneempi versio tunneanalyysistä on **aspektipohjainen tunneanalyysi** (ABSA), jossa tunteet kohdistetaan koko lauseen sijaan sen eri osiin (aspekteihin), esim. *Tässä ravintolassa pidin ruoasta, mutta tunnelma oli kamala*.
* **Nimekkeiden tunnistus** (NER) viittaa ongelmaan, jossa tekstistä poimitaan tiettyjä entiteettejä. Esimerkiksi lauseessa *Minun täytyy lentää huomenna Pariisiin* sanat *huomenna* viittaavat AIKAAN ja *Pariisi* PAIKKAAN.
* **Avainsanojen poiminta** on samankaltainen kuin NER, mutta siinä sanat, jotka ovat tärkeitä lauseen merkityksen kannalta, poimitaan automaattisesti ilman erityistä esikoulutusta tiettyihin entiteettityyppeihin.
* **Tekstin klusterointi** voi olla hyödyllistä, kun haluamme ryhmitellä yhteen samankaltaisia lauseita, esimerkiksi teknisen tuen keskusteluissa esiintyviä samankaltaisia pyyntöjä.
* **Kysymys-vastausjärjestelmät** viittaavat mallin kykyyn vastata tiettyyn kysymykseen. Malli saa syötteenä tekstikappaleen ja kysymyksen, ja sen on löydettävä tekstistä kohta, jossa vastaus kysymykseen on (tai joskus luotava vastausteksti).
* **Tekstin generointi** on mallin kyky luoda uutta tekstiä. Sitä voidaan pitää luokittelutehtävänä, jossa ennustetaan seuraava kirjain/sana jonkin *tekstisyötteen* perusteella. Kehittyneet tekstin generointimallit, kuten GPT-3, pystyvät ratkaisemaan muita NLP-tehtäviä käyttämällä tekniikoita, kuten [prompt-ohjelmointi](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) tai [prompt-suunnittelu](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29).
* **Tekstin tiivistäminen** on tekniikka, jossa haluamme tietokoneen "lukevan" pitkän tekstin ja tiivistävän sen muutamaan lauseeseen.
* **Konekäännös** voidaan nähdä yhdistelmänä tekstin ymmärtämistä yhdellä kielellä ja tekstin generointia toisella kielellä.
* **Tekstin luokittelu** on tyypillinen luokittelutehtävä, joka koskee tekstijonoja. Esimerkkeinä ovat sähköpostiviestien luokittelu roskapostiksi tai ei-roskapostiksi, tai artikkeleiden luokittelu urheilu-, liiketoiminta-, politiikka-kategorioihin jne. Myös, kun kehitetään chatbotteja, meidän on usein ymmärrettävä, mitä käyttäjä halusi sanoa – tässä tapauksessa käsittelemme **aikomusluokittelua**. Usein aikomusluokittelussa pitää käsitellä monia kategorioita.
* **Sentimenttianalyysi** on tyypillinen regressiotehtävä, jossa meidän täytyy antaa numero (sentimentti), joka vastaa kuinka positiivinen/negatiivinen lauseen merkitys on. Kehittyneempi versio sentimenttianalyysistä on **aspektipohjainen sentimenttianalyysi** (ABSA), jossa sentimentti määritetään ei koko lauseelle, vaan sen eri osille (aspekteille), esim. *Tässä ravintolassa pidin ruoasta, mutta ilmapiiri oli hirveä*.
* **Nimien entiteettien tunnistus** (NER) tarkoittaa tiettyjen entiteettien poimimista tekstistä. Esimerkiksi meidän täytyy ymmärtää, että lauseessa *Minun pitää lentää Pariisiin huomenna* sana *huomenna* viittaa PÄIVÄMÄÄRÄÄN, ja *Pariisi* on PAIKKA.
* **Avainsanojen poiminta** on samanlaista kuin NER, mutta tässä meidän täytyy automaattisesti poimia lauseen merkitykselle tärkeitä sanoja ilman ennakkokoulutusta tiettyihin entiteettityyppeihin.
* **Tekstiryhmittely** voi olla hyödyllistä, kun haluamme ryhmitellä samanlaisia lauseita, esimerkiksi samankaltaisia pyyntöjä teknisen tuen keskusteluissa.
* **Kysymysten vastaaminen** tarkoittaa mallin kykyä vastata tiettyyn kysymykseen. Malli saa syötteenä tekstikappaleen ja kysymyksen, ja sen täytyy antaa paikka tekstistä, jossa kysymyksen vastaus on (tai joskus generoida vastausteksti).
* **Tekstin generointi** on kyky generoida uutta tekstiä. Sitä voidaan pitää luokittelutehtävänä, joka ennustaa seuraavan kirjaimen/sanan perustuen johonkin *tekstikehotteeseen*. Edistyneet tekstin generointimallit, kuten GPT-3, pystyvät ratkomaan myös muita NLP-tehtäviä luokittelun osalta käyttämällä tekniikkaa, jota kutsutaan [prompt-ohjelmoinniksi](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) tai [prompt-suunnitteluksi](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29)
* **Tekstin tiivistäminen** on tekniikka, jossa haluamme, että tietokone "lukee" pitkän tekstin ja tiivistää sen muutamaan lauseeseen.
* **Konekäännös** voidaan nähdä tekstin ymmärtämisen ja tekstin generoinnin yhdistelmänä kahdella eri kielellä.
Aluksi suurin osa NLP-tehtävistä ratkaistiin perinteisillä menetelmillä, kuten kielioppeja hyödyntämällä. Esimerkiksi konekäännöksessä käytettiin jäsennin-ohjelmia, jotka muunsivat alkuperäisen lauseen syntaksipuuksi, minkä jälkeen korkeampia semanttisia rakenteita poimittiin lauseen merkityksen esittämiseksi. Tämän merkityksen ja kohdekielen kieliopin perusteella luotiin lopputulos. Nykyään monet NLP-tehtävät ratkaistaan tehokkaammin neuroverkkojen avulla.
Aluksi suurin osa NLP-tehtävistä ratkaistiin perinteisillä menetelmillä, kuten kielioppisääntöjen avulla. Esimerkiksi konekäännöksessä käytettiin jäsennintä (parser), joka muunsi alkuperäisen lauseen syntaksipuuksi, sitten korkeamman tason semanttisia rakenteita poimittiin lauseen merkityksen esittämiseksi, ja tämän merkityksen sekä kohdekielen kieliopin perusteella tulos generoitiin. Nykyään monet NLP-tehtävät ratkaistaan tehokkaammin hermoverkkojen avulla.
> Monet klassiset NLP-menetelmät on toteutettu [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org) -kirjastossa Pythonille. Verkossa on saatavilla erinomainen [NLTK-kirja](https://www.nltk.org/book/), joka kattaa, miten erilaisia NLP-tehtäviä voidaan ratkaista NLTK:ta käyttäen.
> Monet klassiset NLP-menetelmät on toteutettu [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org) Python-kirjastossa. Saatavilla on loistava [NLTK-kirja](https://www.nltk.org/book/), joka kattaa miten erilaisia NLP-tehtäviä voidaan ratkaista käyttämällä NLTK:ta.
Kurssillamme keskitymme pääasiassa neuroverkkojen käyttöön NLP:ssä, ja käytämme NLTK:ta tarvittaessa.
Kurssillamme keskitymme pääasiassa hermoverkkojen käyttöön NLP:ssä, ja käytämme NLTK:ta tarvittaessa.
Olemme jo oppineet käyttämään neuroverkkoja taulukkodatan ja kuvien käsittelyyn. Suurin ero näiden datatyyppien ja tekstin välillä on, että teksti on vaihtelevan pituinen jono, kun taas kuvien tapauksessa syötteen koko tiedetään etukäteen. Vaikka konvoluutiot voivat poimia kuvioita syötteestä, tekstin kuviot ovat monimutkaisempia. Esimerkiksi kielteisyys voi olla erotettuna subjektista monilla sanoilla (esim. *En pidä appelsiineista* vs. *En pidä noista isoista värikkäistä maukkaista appelsiineista*), ja se tulisi silti tulkita yhtenä kuviona. Siksi kielen käsittelyyn tarvitaan uusia neuroverkkotyyppejä, kuten *toistoverkkoja* ja *transformereita*.
Olemme jo oppineet käyttämään hermoverkkoja taulukkomuotoisen datan ja kuvien käsittelyyn. Pääasiallinen ero näiden tietotyyppien ja tekstin välillä on, että teksti on muuttuvan pituinen jono, kun taas kuvien syötekoon koko tiedetään etukäteen. Vaikka konvoluutioneuroverkot pystyvät poimimaan kuvioita syötedatasta, tekstin kuviot ovat monimutkaisempia. Esim., kieltosanat voivat olla erillään subjektista mielivaltaisen monta sanaa (esim. *En pidä appelsiineista* vs. *En pidä niistä isoista värikkäistä maukkaista appelsiineista*), ja tämä pitäisi kuitenkin tulkita yhtenä kuviona. Siksi kielen käsittelyssä tarvitsemme uusia hermoverkkotyyppejä, kuten *toistuvat verkot* ja *transformerit*.
## Kirjastojen asentaminen
## Kirjastojen asennus
Jos käytät paikallista Python-asennusta tämän kurssin suorittamiseen, saatat joutua asentamaan kaikki NLP:ssä tarvittavat kirjastot seuraavilla komennoilla:
Jos käytät paikallista Python-asennusta tämän kurssin ajamiseen, saatat joutua asentamaan kaikki tarvittavat NLP-kirjastot seuraavilla komennoilla:
**PyTorchille**
```bash
pip install -r requirements-torch.txt
pip install -r requirements-pytorch.txt
```
**TensorFlow'lle**
```bash
pip install -r requirements-tf.txt
```
> Voit kokeilla NLP:tä TensorFlow'lla [Microsoft Learnissa](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-tensorflow/?WT.mc_id=academic-77998-cacaste)
> Voit kokeilla NLP:tä TensorFlown kanssa [Microsoft Learnissä](https://docs.microsoft.com/learn/modules/intro-natural-language-processing-tensorflow/?WT.mc_id=academic-77998-cacaste)
## GPU-varoitus
Tässä osiossa joissakin esimerkeissä koulutamme melko suuria malleja.
* **Käytä GPU:lla varustettua tietokonetta**: On suositeltavaa suorittaa muistikirjat GPU:lla varustetulla tietokoneella, jotta odotusajat suurten mallien kanssa lyhenevät.
* **GPU-muistin rajoitukset**: GPU:lla suorittaminen voi johtaa tilanteisiin, joissa GPU-muisti loppuu, erityisesti suuria malleja koulutettaessa.
* **GPU-muistin kulutus**: GPU-muistin kulutus koulutuksen aikana riippuu useista tekijöistä, kuten minibatchin koosta.
* **Pienennä minibatchin kokoa**: Jos kohtaat GPU-muistiongelmia, harkitse minibatchin koon pienentämistä koodissasi mahdollisena ratkaisuna.
* **TensorFlow'n GPU-muistin vapautus**: TensorFlow'n vanhemmat versiot eivät välttämättä vapauta GPU-muistia oikein, kun koulutetaan useita malleja yhdessä Python-ytimessä. GPU-muistin käytön hallitsemiseksi tehokkaasti voit määrittää TensorFlow'n varaamaan GPU-muistia vain tarpeen mukaan.
* **Koodin sisällyttäminen**: Voit asettaa TensorFlow'n kasvattamaan GPU-muistin varausta vain tarvittaessa lisäämällä seuraavan koodin muistikirjoihisi:
Tässä osiossa joidenkin esimerkkien mallien harjoittaminen on melko suurta.
* **Käytä GPU:lla varustettua konetta**: On suositeltavaa ajaa muistikirjojasi GPU:lla varustetulla koneella vähentääksesi odotusaikoja suurten mallien kanssa työskennellessä.
* **GPU-muistin rajoitukset**: GPU:lla ajaminen voi johtaa tilanteisiin, joissa GPU-muisti loppuu, erityisesti suuria malleja kouluttaessa.
* **GPU-muistin kulutus**: Koulutuksen aikana käytetty GPU-muistin määrä riippuu monista tekijöistä, mukaan lukien minibatchin koko.
* **Minibatchin koon minimointi**: Jos kohtaat ongelmia GPU-muistin kanssa, harkitse minibatchin koon pienentämistä koodissasi.
* **TensorFlow'n GPU-muistin vapautus**: Vanhemmat TensorFlow-versiot eivät välttämättä vapauta GPU-muistia oikein, kun koulutetaan useita malleja saman Python-ytimen sisällä. GPU-muistin hallinnan optimoimiseksi voit konfiguroida TensorFlow'hun lataamaan GPU-muistia vain tarpeen mukaan.
* **Koodin lisääminen**: Asettaaksesi TensorFlow'n kasvattamaan GPU-muistin käyttöä tarpeen mukaan, lisää seuraava koodi muistikirjoihisi:
```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)
```
Jos olet kiinnostunut oppimaan NLP:stä klassisen koneoppimisen näkökulmasta, käy [tässä oppituntikokonaisuudessa](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP).
Jos olet kiinnostunut oppimaan NLP:tä klassisesta koneoppimisen näkökulmasta, käy [tässä oppimateriaalissa](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP)
## Tässä osiossa
Tässä osiossa opimme:
* [Tekstin esittäminen tensoreina](13-TextRep/README.md)
* [Sana-upotukset](14-Emdeddings/README.md)
* [Kielimallinnus](15-LanguageModeling/README.md)
* [Toistuvat neuroverkot](16-RNN/README.md)
* [Sanasijoitukset](14-Emdeddings/README.md)
* [Kielimallit](15-LanguageModeling/README.md)
* [Toistuvat hermoverkot](16-RNN/README.md)
* [Generatiiviset verkot](17-GenerativeNetworks/README.md)
* [Transformerit](18-Transformers/README.md)
---
**Vastuuvapauslauseke**:
Tämä asiakirja on käännetty käyttämällä tekoälypohjaista käännöspalvelua [Co-op Translator](https://github.com/Azure/co-op-translator). Vaikka pyrimme tarkkuuteen, huomioithan, että automaattiset käännökset voivat sisältää virheitä tai epätarkkuuksia. Alkuperäistä asiakirjaa sen alkuperäisellä kielellä tulisi pitää ensisijaisena lähteenä. Kriittisen tiedon osalta suositellaan ammattimaista ihmiskäännöstä. Emme ole vastuussa väärinkäsityksistä tai virhetulkinnoista, jotka johtuvat tämän käännöksen käytöstä.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Vastuuvapauslauseke**:
Tämä asiakirja on käännetty käyttämällä tekoälypohjaista käännöspalvelua [Co-op Translator](https://github.com/Azure/co-op-translator). Vaikka pyrimme tarkkuuteen, otathan huomioon, että automaattiset käännökset saattavat sisältää virheitä tai epätarkkuuksia. Alkuperäinen asiakirja sen alkuperäiskielellä on virallinen lähde. Tärkeissä asioissa suositellaan ammattimaista ihmiskäännöstä. Emme ole vastuussa tämän käännöksen käytöstä aiheutuvista väärinymmärryksistä tai tulkinnoista.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

37
translations/nl/.co-op-translator.json
View File

@ -5,6 +5,12 @@
"source_file": "AGENTS.md",
"language_code": "nl"
},
"CONTRIBUTING.md": {
"original_hash": "c6fd7e781b67111a90abd166d0ce4aa0",
"translation_date": "2026-07-08T15:53:13+00:00",
"source_file": "CONTRIBUTING.md",
"language_code": "nl"
},
"README.md": {
"original_hash": "12c8eb6bf0867d2f1c32daf613ac5b8b",
"translation_date": "2026-04-06T21:00:00+00:00",
@ -17,6 +23,19 @@
"source_file": "SECURITY.md",
"language_code": "nl"
},
"__translation_failures__": {
"lessons/sketchnotes/LICENSE.md": {
"original_hash": "45ab63a2cd8f5faef6c9b150618837a4",
"source_file": "lessons/sketchnotes/LICENSE.md",
"language_code": "nl",
"failure_date": "2026-07-08T15:52:34+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-28T20:13:26+00:00",
@ -54,8 +73,8 @@
"language_code": "nl"
},
"examples/README.md": {
"original_hash": "0d1babfdcbeb46525f2db3fbaaa54cd7",
"translation_date": "2025-10-03T11:32:01+00:00",
"original_hash": "7883d52c2e2a221e0b07a7b112a149b9",
"translation_date": "2026-07-08T15:46:20+00:00",
"source_file": "examples/README.md",
"language_code": "nl"
},
@ -66,8 +85,8 @@
"language_code": "nl"
},
"lessons/0-course-setup/how-to-run.md": {
"original_hash": "a4717bd9103b9f6cd84d534b83534689",
"translation_date": "2026-01-16T03:04:55+00:00",
"original_hash": "7ad8c7d8604c53649b3d4d1e2f3a6fa1",
"translation_date": "2026-07-08T15:46:47+00:00",
"source_file": "lessons/0-course-setup/how-to-run.md",
"language_code": "nl"
},
@ -191,6 +210,12 @@
"source_file": "lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md",
"language_code": "nl"
},
"lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb": {
"original_hash": "99b816b6a4957ef4100cee4c4221dff9",
"translation_date": "2026-07-08T15:33:09+00:00",
"source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb",
"language_code": "nl"
},
"lessons/4-ComputerVision/08-TransferLearning/lab/README.md": {
"original_hash": "7765935c35fcee69b9fe2d0cfd6963e2",
"translation_date": "2025-08-28T19:29:25+00:00",
@ -330,8 +355,8 @@
"language_code": "nl"
},
"lessons/5-NLP/README.md": {
"original_hash": "8ef02a9318257ea140ed3ed74442096d",
"translation_date": "2025-08-28T19:57:15+00:00",
"original_hash": "038df6f1a73e49f6430740da083bfd6d",
"translation_date": "2026-07-08T15:47:18+00:00",
"source_file": "lessons/5-NLP/README.md",
"language_code": "nl"
},

29
translations/nl/CONTRIBUTING.md Normal file
View File

@ -0,0 +1,29 @@
# Bijdragen aan AI-For-Beginners
Dank u voor uw interesse om bij te dragen aan AI-For-Beginners! We verwelkomen vertalingen, correcties van lessen en opmaakcorrecties.
## Microsoft Contributor License Agreement (CLA)
Dit project verwelkomt bijdragen en suggesties. De meeste bijdragen vereisen dat u akkoord gaat met een Contributor License Agreement (CLA) waarin u verklaart dat u het recht hebt, en daadwerkelijk, ons de rechten verleent om uw bijdrage te gebruiken. Voor details, bezoek [https://cla.microsoft.com](https://cla.microsoft.com).
Wanneer u een pull request indient, bepaalt een CLA-bot automatisch of u een CLA moet aanleveren en voorziet de PR van de juiste aanduiding (bijvoorbeeld label, opmerking). Volg gewoon de instructies van de bot. U hoeft dit maar één keer te doen voor alle repositories die onze CLA gebruiken.
## Hoe bij te dragen
### 1. Het corrigeren van typfouten / codefouten
Als u een typfout of bug vindt in een Jupyter-notebook of les-markdownbestand:
1. Maak een fork van de repository.
2. Corrigeer de typfout of gebroken link.
3. Dien een Pull Request in met een duidelijke beschrijving van de correctie.
### 2. Vertalingen indienen
We verwelkomen vertalingen van de lessen naar andere talen! Plaats vertalingen in de `translations/` directory met gebruik van de bestaande mapnamen daar (bijvoorbeeld `translations/es/`, `translations/pt-BR/`, `translations/zh-CN/`).
Voor meer details, zie [etc/CONTRIBUTING.md](etc/CONTRIBUTING.md).
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Disclaimer**:
Dit document is vertaald met behulp van de AI vertaaldienst [Co-op Translator](https://github.com/Azure/co-op-translator). Hoewel we streven naar nauwkeurigheid, dient u er rekening mee te houden dat geautomatiseerde vertalingen fouten of onnauwkeurigheden kunnen bevatten. Het originele document in de oorspronkelijke taal moet worden beschouwd als de gezaghebbende bron. Voor kritieke informatie wordt professionele menselijke vertaling aanbevolen. Wij zijn niet aansprakelijk voor eventuele misverstanden of verkeerde interpretaties die voortvloeien uit het gebruik van deze vertaling.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

42
translations/nl/examples/README.md
View File

@ -1,64 +1,64 @@
# Beginner-Vriendelijke AI Voorbeelden
Welkom! Deze map bevat eenvoudige, zelfstandige voorbeelden om je te helpen beginnen met AI en machine learning. Elk voorbeeld is ontworpen om toegankelijk te zijn voor beginners, met gedetailleerde opmerkingen en stapsgewijze uitleg.
Welkom! Deze map bevat eenvoudige, zelfstandige voorbeelden om je te helpen starten met AI en machine learning. Elk voorbeeld is ontworpen om beginner-vriendelijk te zijn met gedetailleerde opmerkingen en stapsgewijze uitleg.
## 📚 Overzicht van Voorbeelden
## 📚 Overzicht Voorbeelden
| Voorbeeld | Beschrijving | Moeilijkheid | Vereisten |
|-----------|--------------|--------------|-----------|
| [Hello AI World](../../../examples/01-hello-ai-world.py) | Je eerste AI-programma - eenvoudige patroonherkenning | ⭐ Beginner | Basiskennis Python |
| [Eenvoudig Neuraal Netwerk](../../../examples/02-simple-neural-network.py) | Bouw een neuraal netwerk vanaf nul | ⭐⭐ Beginner+ | Python, basiswiskunde |
| [Beeldclassifier](./03-image-classifier.ipynb) | Classificeer beelden met een vooraf getraind model | ⭐⭐ Beginner+ | Python, numpy |
| [Tekstsentiment](../../../examples/04-text-sentiment.py) | Analyseer tekstsentiment (positief/negatief) | ⭐⭐ Beginner+ | Python |
|---------|-------------|------------|---------------|
| [Hello AI World](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/01-hello-ai-world.py) | Je eerste AI-programma - eenvoudige patroonherkenning | ⭐ Beginner | Basis Python |
| [Simple Neural Network](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/02-simple-neural-network.py) | Bouw een neuraal netwerk vanaf nul | ⭐⭐ Beginner+ | Python, basis wiskunde |
| [Image Classifier](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/03-image-classifier.ipynb) | Classificeer afbeeldingen met een vooraf getraind model | ⭐⭐ Beginner+ | Python, numpy |
| [Text Sentiment](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/04-text-sentiment.py) | Analyseer tekstsentiment (positief/negatief) | ⭐⭐ Beginner+ | Python |
## 🚀 Aan de Slag
### Vereisten
Zorg ervoor dat je Python hebt geïnstalleerd (3.8 of hoger aanbevolen). Installeer de benodigde pakketten:
Zorg dat je Python geïnstalleerd hebt (3.8 of hoger aanbevolen). Installeer de benodigde pakketten:
```bash
# For Python scripts
# Voor Python-scripts
pip install numpy
# For Jupyter notebooks (image classifier)
# Voor Jupyter-notebooks (beeldclassifier)
pip install jupyter numpy pillow tensorflow
```
Of gebruik de conda-omgeving uit het hoofdcurriculum:
Of gebruik de conda-omgeving van het hoofdleertraject:
```bash
conda env create --name ai4beg --file ../environment.yml
conda activate ai4beg
```
### Voorbeelden Uitvoeren
### De Voorbeelden Uitvoeren
**Voor Python-scripts (.py bestanden):**
```bash
python 01-hello-ai-world.py
```
**Voor Jupyter-notebooks (.ipynb bestanden):**
**Voor Jupyter notebooks (.ipynb bestanden):**
```bash
jupyter notebook 03-image-classifier.ipynb
```
## 📖 Leerpad
We raden aan om de voorbeelden in volgorde te volgen:
We raden aan de voorbeelden in deze volgorde te volgen:
1. **Begin met "Hello AI World"** - Leer de basis van patroonherkenning
2. **Bouw een Eenvoudig Neuraal Netwerk** - Begrijp hoe neurale netwerken werken
3. **Probeer de Beeldclassifier** - Zie AI in actie met echte beelden
3. **Probeer de Image Classifier** - Zie AI in actie met echte afbeeldingen
4. **Analyseer Tekstsentiment** - Verken natuurlijke taalverwerking
## 💡 Tips voor Beginners
- **Lees de opmerkingen in de code zorgvuldig** - Ze leggen uit wat elke regel doet
- **Lees de code-opmerkingen aandachtig** - Ze leggen uit wat elke regel doet
- **Experimenteer!** - Probeer waarden te veranderen en kijk wat er gebeurt
- **Maak je geen zorgen als je niet alles begrijpt** - Leren kost tijd
- **Stel vragen** - Gebruik het [Discussiebord](https://github.com/microsoft/AI-For-Beginners/discussions)
- **Stel vragen** - Gebruik het [Discussieforum](https://github.com/microsoft/AI-For-Beginners/discussions)
## 🔗 Volgende Stappen
@ -70,7 +70,7 @@ Na het voltooien van deze voorbeelden, verken het volledige curriculum:
## 🤝 Bijdragen
Vond je deze voorbeelden nuttig? Help ons ze te verbeteren:
Vonden je deze voorbeelden nuttig? Help ons ze te verbeteren:
- Meld problemen of stel verbeteringen voor
- Voeg meer voorbeelden toe voor beginners
- Verbeter documentatie en opmerkingen
@ -81,5 +81,7 @@ Vond je deze voorbeelden nuttig? Help ons ze te verbeteren:
---
**Disclaimer**:
Dit document is vertaald met behulp van de AI-vertalingsservice [Co-op Translator](https://github.com/Azure/co-op-translator). Hoewel we streven naar nauwkeurigheid, dient u zich ervan bewust te zijn dat geautomatiseerde vertalingen fouten of onnauwkeurigheden kunnen bevatten. Het originele document in de oorspronkelijke taal moet worden beschouwd als de gezaghebbende bron. Voor cruciale informatie wordt professionele menselijke vertaling aanbevolen. Wij zijn niet aansprakelijk voor misverstanden of verkeerde interpretaties die voortvloeien uit het gebruik van deze vertaling.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Disclaimer**:
Dit document is vertaald met behulp van de AI vertaaldienst [Co-op Translator](https://github.com/Azure/co-op-translator). Hoewel we streven naar nauwkeurigheid, dient u er rekening mee te houden dat geautomatiseerde vertalingen fouten of onnauwkeurigheden kunnen bevatten. Het originele document in de oorspronkelijke taal moet worden beschouwd als de gezaghebbende bron. Voor kritieke informatie wordt professionele menselijke vertaling aanbevolen. Wij zijn niet aansprakelijk voor eventuele misverstanden of verkeerde interpretaties die voortvloeien uit het gebruik van deze vertaling.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

44
translations/nl/lessons/0-course-setup/how-to-run.md
View File

@ -1,12 +1,12 @@
# Hoe de code uit te voeren
Dit curriculum bevat veel uitvoerbare voorbeelden en labs die je wilt uitvoeren. Om dit te doen, heb je de mogelijkheid nodig om Python-code uit te voeren in Jupyter Notebooks die als onderdeel van dit curriculum worden meegeleverd. Je hebt verschillende opties om de code uit te voeren:
Deze leergang bevat veel uitvoerbare voorbeelden en labs die je wilt uitvoeren. Om dit te kunnen doen, heb je de mogelijkheid nodig om Python-code uit te voeren in Jupyter Notebooks die deel uitmaken van deze leergang. Je hebt verschillende opties om de code uit te voeren:
## Lokaal op je computer uitvoeren
Om de code lokaal op je computer uit te voeren, is een Python-installatie nodig. Een aanbeveling is om **[miniconda](https://conda.io/en/latest/miniconda.html)** te installeren - het is een vrij lichte installatie die de `conda` package manager ondersteunt voor verschillende Python **virtuele omgevingen**.
Om de code lokaal op je computer uit te voeren, is een Python-installatie nodig. Een aanbeveling is om **[miniconda](https://conda.io/en/latest/miniconda.html)** te installeren - dit is een vrij lichte installatie die de `conda` pakketbeheerder ondersteunt voor verschillende Python **virtuele omgevingen**.
Nadat je miniconda hebt geïnstalleerd, clone je de repository en maak je een virtuele omgeving aan die voor deze cursus gebruikt wordt:
Nadat je miniconda hebt geïnstalleerd, kloon je de repository en maak je een virtuele omgeving aan die voor deze cursus gebruikt zal worden:
```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 gebruiken met Python-extensie
### Gebruik van Visual Studio Code met de Python-extensie
Dit curriculum gebruik je het beste wanneer je het opent in [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) met de [Python-extensie](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste).
Deze leergang is het beste te gebruiken door deze te openen in [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=academic-77998-cacaste) met de [Python-extensie](https://marketplace.visualstudio.com/items?itemName=ms-python.python&WT.mc_id=academic-77998-cacaste).
> **Opmerking**: Zodra je de directory clonet en opent in VS Code, wordt je automatisch voorgesteld om de Python-extensies te installeren. Je moet ook miniconda installeren zoals hierboven beschreven.
> **Opmerking**: Zodra je de map kloont en opent in VS Code, zal het automatisch voorstellen om de Python-extensies te installeren. Je moet ook miniconda installeren zoals hierboven beschreven.
> **Opmerking**: Als VS Code je voorstelt om de repository opnieuw te openen in een container, moet je dit weigeren om de lokale Python-installatie te gebruiken.
> **Opmerking**: Als VS Code je voorstelt om de repository opnieuw te openen in een container, moet je dit weigeren om de lokale Python-installatie te gebruiken.
### Jupyter in de browser gebruiken
### Gebruik van Jupyter in de browser
Je kunt ook een Jupyter-omgeving gebruiken vanuit de browser op je eigen computer. Zowel klassieke Jupyter als JupyterHub bieden een handige ontwikkelomgeving met automatische aanvulling, syntaxmarkering, etc.
Je kunt ook een Jupyter-omgeving vanuit de browser op je eigen computer gebruiken. Zowel klassieke Jupyter als JupyterHub bieden een handige ontwikkelomgeving met automatische aanvulling, code-kleuring, enzovoort.
Om Jupyter lokaal te starten, ga je naar de directory van de cursus, en voer je uit:
Om Jupyter lokaal te starten, ga je naar de map van de cursus en voer je het volgende uit:
```bash
jupyter notebook
@ -36,36 +36,36 @@ of
```bash
jupyterhub
```
Je kunt dan naar een van de `.ipynb`-bestanden navigeren, deze openen en beginnen met werken.
Je kunt dan naar elk `.ipynb`-bestand navigeren, deze openen en beginnen met werken.
### Uitvoeren in een container
Een alternatief voor Python-installatie zou zijn om de code in een container uit te voeren. Omdat onze repository een speciale `.devcontainer` map aanlevert die instructies bevat over hoe een container voor deze repo te bouwen, biedt VS Code de mogelijkheid om de code opnieuw in een container te openen. Dit vereist een Docker-installatie en is ook wat complexer, daarom raden we dit aan voor meer ervaren gebruikers.
Een alternatief voor een Python-installatie is het uitvoeren van de code in een container. Omdat onze repository een speciale `.devcontainer`-map bevat die aangeeft hoe je een container bouwt voor deze repo, biedt VS Code de mogelijkheid om de code opnieuw te openen in een container. Dit vereist een Docker-installatie en is ook wat complexer, dus we raden dit aan voor meer ervaren gebruikers.
## Uitvoeren in de cloud
Als je Python niet lokaal wilt installeren, en toegang hebt tot wat cloudresources, is een goed alternatief om de code in de cloud uit te voeren. Er zijn verschillende manieren om dit te doen:
Als je Python niet lokaal wilt installeren en toegang hebt tot cloudresources, is een goed alternatief om de code in de cloud uit te voeren. Er zijn verschillende manieren om dit te doen:
* Gebruik maken van **[GitHub Codespaces](https://github.com/features/codespaces)**, wat een virtuele omgeving is die voor jou op GitHub wordt aangemaakt, toegankelijk via een VS Code-browserinterface. Als je toegang hebt tot Codespaces, kun je gewoon op de **Code** knop in de repo klikken, een codespace starten en zonder vertraging aan de slag gaan.
* Gebruik maken van **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) biedt gratis computerresources in de cloud voor mensen zoals jij om code op GitHub uit te proberen. Op de startpagina is een knop om de repository in Binder te openen - dit brengt je snel naar de Binder-site, die een onderliggende container bouwt en naadloos een Jupyter-webinterface voor je start.
* Gebruik **[GitHub Codespaces](https://github.com/features/codespaces)**, een virtuele omgeving die voor jou is aangemaakt op GitHub en toegankelijk is via een VS Code-browserinterface. Als je toegang hebt tot Codespaces, kun je gewoon op de **Code**-knop in de repo klikken, een codespace starten en meteen aan de slag gaan.
* Gebruik **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) biedt gratis computerkracht in de cloud voor mensen zoals jij om code van GitHub te testen. Er is een knop op de startpagina om de repository in Binder te openen - dit brengt je snel naar de Binder-site waar een onderliggende container wordt opgebouwd en naadloos een Jupyter-webinterface voor je start.
> **Opmerking**: Om misbruik te voorkomen, heeft Binder toegang tot sommige webresources geblokkeerd. Dit kan voorkomen dat sommige code werkt die modellen en/of datasets van het openbare internet haalt. Mogelijk moet je enkele omwegen vinden. Ook zijn de computerresources van Binder behoorlijk beperkt, dus het trainen zal traag zijn, vooral in latere, meer complexe lessen.
> **Opmerking**: Om misbruik te voorkomen, heeft Binder de toegang tot sommige webresources geblokkeerd. Dit kan voorkomen dat een deel van de code werkt, vooral als deze modellen en/of datasets van het publieke internet ophaalt. Je moet mogelijk een workaround vinden. Ook zijn de computerresources die door Binder worden geleverd vrij basic, dus training zal traag zijn, vooral in latere, meer complexe lessen.
## Uitvoeren in de cloud met GPU
Sommige van de latere lessen in dit curriculum profiteren aanzienlijk van GPU-ondersteuning. Modeltraining kan anders erg traag zijn. Er zijn een paar opties die je kunt volgen, vooral als je toegang hebt tot de cloud, bijvoorbeeld via [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste) of via je instelling:
Sommige van de latere lessen in deze leergang profiteren sterk van GPU-ondersteuning. Bijvoorbeeld het trainen van modellen kan anders erg traag zijn. Er zijn een paar opties die je kunt volgen, vooral als je toegang hebt tot cloud via [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste), of via je onderwijsinstelling:
* Maak een [Data Science Virtual Machine](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) aan en verbind ermee via Jupyter. Je kunt de repo dan direct op de machine clonen en beginnen met leren. NC-series VM's hebben GPU-ondersteuning.
* Maak een [Data Science Virtual Machine](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) aan en maak verbinding via Jupyter. Je kunt dan de repo direct op de machine klonen en beginnen met leren. NC-series VM’s hebben GPU-ondersteuning.
> **Opmerking**: Sommige abonnementen, waaronder Azure for Students, bieden standaard geen GPU-ondersteuning. Je moet mogelijk extra GPU-cores aanvragen via een technische supportaanvraag.
> **Opmerking**: Sommige abonnementen, waaronder Azure for Students, bieden niet direct GPU-ondersteuning. Je moet mogelijk extra GPU-kernen aanvragen via een technische supportaanvraag.
* Maak een [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) aan en gebruik dan de Notebook-functie daar. [Deze video](https://azure-for-academics.github.io/quickstart/azureml-papers/) laat zien hoe je een repository in een Azure ML-notebook clonet en gebruikt.
* Maak een [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) aan en gebruik daar de Notebook-functie. [Deze video](https://azure-for-academics.github.io/quickstart/azureml-papers/) laat zien hoe je een repository naar een Azure ML-notebook kloont en er begint mee te werken.
Je kunt ook Google Colab gebruiken, dat enige gratis GPU-ondersteuning heeft, en Jupyter Notebooks daar uploaden om ze stuk voor stuk uit te voeren.
Je kunt ook Google Colab gebruiken, dat met wat gratis GPU-ondersteuning komt, en daar Jupyter Notebooks uploaden om ze één voor één uit te voeren.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Disclaimer**:
Dit document is vertaald met behulp van de AI-vertalingsdienst [Co-op Translator](https://github.com/Azure/co-op-translator). Hoewel we streven naar nauwkeurigheid, dient u er rekening mee te houden dat automatische vertalingen fouten of onnauwkeurigheden kunnen bevatten. Het originele document in de oorspronkelijke taal dient als de gezaghebbende bron te worden beschouwd. Voor cruciale informatie wordt een professionele menselijke vertaling aanbevolen. Wij zijn niet aansprakelijk voor misverstanden of verkeerde interpretaties die voortvloeien uit het gebruik van deze vertaling.
Dit document is vertaald met behulp van de AI vertaaldienst [Co-op Translator](https://github.com/Azure/co-op-translator). Hoewel we streven naar nauwkeurigheid, dient u er rekening mee te houden dat geautomatiseerde vertalingen fouten of onnauwkeurigheden kunnen bevatten. Het originele document in de oorspronkelijke taal moet worden beschouwd als de gezaghebbende bron. Voor kritieke informatie wordt professionele menselijke vertaling aanbevolen. Wij zijn niet aansprakelijk voor eventuele misverstanden of verkeerde interpretaties die voortvloeien uit het gebruik van deze vertaling.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

129
translations/nl/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb
View File

@ -4,11 +4,11 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"# Voorgetrainde modellen en transfer learning\n",
"# Voorgetrainde modellen en transferleren\n",
"\n",
"Het trainen van CNN's kan veel tijd kosten, en er is veel data nodig voor die taak. Echter, een groot deel van de tijd wordt besteed aan het leren van de beste laag-niveau filters die een netwerk gebruikt om patronen uit afbeeldingen te halen. Een logische vraag die dan opkomt is: kunnen we een neuraal netwerk dat op één dataset is getraind gebruiken en aanpassen om andere afbeeldingen te classificeren zonder het volledige trainingsproces te doorlopen?\n",
"Het trainen van CNN's kan veel tijd in beslag nemen, en daarvoor is veel data nodig. Echter, een groot deel van de tijd wordt besteed aan het leren van de beste laag-niveau filters die een netwerk gebruikt om patronen uit afbeeldingen te extraheren. Een natuurlijke vraag rijst - kunnen we een neuraal netwerk dat op een dataset is getraind gebruiken en aanpassen voor het classificeren van andere afbeeldingen zonder het volledige trainingsproces door te lopen?\n",
"\n",
"Deze aanpak wordt **transfer learning** genoemd, omdat we kennis overdragen van het ene neurale netwerkmodel naar het andere. Bij transfer learning beginnen we meestal met een voorgetraind model, dat is getraind op een grote afbeeldingsdataset, zoals **ImageNet**. Deze modellen kunnen al goed verschillende kenmerken uit algemene afbeeldingen halen, en in veel gevallen kan het bouwen van een classifier bovenop die geëxtraheerde kenmerken al tot goede resultaten leiden.\n"
"Deze aanpak heet **transferleren**, omdat we wat kennis overdragen van het ene neurale netwerkmodel naar het andere. Bij transferleren beginnen we meestal met een voorgetraind model, dat is getraind op een grote afbeeldingsdataset, zoals **ImageNet**. Die modellen kunnen al goed verschillende kenmerken uit generieke afbeeldingen extraheren, en in veel gevallen kan het bouwen van een classifier bovenop die geëxtraheerde kenmerken al een goed resultaat opleveren.\n"
]
},
{
@ -31,9 +31,9 @@
"source": [
"## Cats vs. Dogs Dataset\n",
"\n",
"In deze unit gaan we een real-life probleem oplossen: het classificeren van afbeeldingen van katten en honden. Hiervoor gebruiken we [Kaggle Cats vs. Dogs Dataset](https://www.kaggle.com/c/dogs-vs-cats), die ook kan worden gedownload [van Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n",
"In deze eenheid zullen we een praktisch probleem oplossen door afbeeldingen van katten en honden te classificeren. Hiervoor gebruiken we de [Kaggle Cats vs. Dogs Dataset](https://www.kaggle.com/c/dogs-vs-cats), die ook kan worden gedownload [van Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n",
"\n",
"Laten we deze dataset downloaden en uitpakken in de `data`-map (dit proces kan enige tijd duren!):\n"
"Laten we deze dataset downloaden en uitpakken in de `data` map (dit proces kan even duren!):\n"
]
},
{
@ -64,7 +64,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Helaas zijn er enkele corrupte afbeeldingsbestanden in de dataset. We moeten snel schoonmaken om te controleren op corrupte bestanden. Om deze tutorial niet te verstoren, hebben we de code om de dataset te verifiëren naar een module verplaatst.\n"
"Helaas zijn er enkele beschadigde afbeeldingsbestanden in de dataset. We moeten een snelle schoonmaak uitvoeren om te controleren op beschadigde bestanden. Om deze tutorial niet te verstoren, hebben we de code om de dataset te verifiëren naar een module verplaatst.\n"
]
},
{
@ -335,11 +335,11 @@
"source": [
"## Het laden van de dataset\n",
"\n",
"In eerdere voorbeelden hebben we datasets geladen die ingebouwd zijn in Keras. Nu gaan we werken met onze eigen dataset, die we moeten laden vanuit een map met afbeeldingen.\n",
"In vorige voorbeelden laadden we datasets die ingebouwd zijn in Keras. Nu gaan we aan de slag met onze eigen dataset, die we moeten laden vanuit een map met afbeeldingen.\n",
"\n",
"In de praktijk kunnen de afmetingen van afbeeldingsdatasets behoorlijk groot zijn, en je kunt er niet op vertrouwen dat alle data in het geheugen past. Daarom worden datasets vaak weergegeven als **generatoren** die data kunnen teruggeven in minibatches die geschikt zijn voor training.\n",
"In de praktijk kunnen de omvang van afbeeldingsdatasets behoorlijk groot zijn, en men kan er niet vanuit gaan dat alle data in het geheugen past. Daarom worden datasets vaak voorgesteld als **generators** die data in minibatches kunnen teruggeven die geschikt zijn voor training.\n",
"\n",
"Om met beeldclassificatie om te gaan, bevat Keras een speciale functie `image_dataset_from_directory`, die afbeeldingen kan laden uit submappen die overeenkomen met verschillende klassen. Deze functie zorgt ook voor het schalen van afbeeldingen en kan de dataset opsplitsen in trainings- en testsets:\n"
"Om te werken met beeldclassificatie, bevat Keras de speciale functie `image_dataset_from_directory`, die afbeeldingen kan laden vanuit submappen die overeenkomen met verschillende klassen. Deze functie zorgt ook voor het schalen van afbeeldingen, en kan ook de dataset splitsen in train- en testgedeelten:\n"
]
},
{
@ -383,9 +383,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Het is belangrijk om dezelfde `seed` waarde in te stellen voor beide oproepen, omdat dit invloed heeft op de verdeling van afbeeldingen tussen de train- en testdataset.\n",
"Het is belangrijk om dezelfde `seed` waarde in te stellen voor beide aanroepen, omdat dit de verdeling van afbeeldingen tussen de train- en testdataset beïnvloedt.\n",
"\n",
"De dataset haalt automatisch de klassenamen op uit de mappen, en je kunt ze indien nodig opvragen door:\n"
"Dataset haalt automatisch klasnamen uit mappen op, en je kunt ze indien nodig benaderen door te bellen:\n"
]
},
{
@ -412,7 +412,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Datasets die we hebben verkregen kunnen direct worden doorgegeven aan de `fit`-functie om het model te trainen. Ze bevatten zowel bijbehorende afbeeldingen als labels, die kunnen worden doorlopen met behulp van de volgende constructie:\n"
"Datasets die we hebben verkregen kunnen direct aan de `fit` functie worden doorgegeven om het model te trainen. Ze bevatten zowel bijbehorende afbeeldingen als labels, waarover kan worden geloopt met de volgende constructie:\n"
]
},
{
@ -453,7 +453,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"> **Opmerking**: Alle afbeeldingen in de dataset worden weergegeven als floating-point tensors met een bereik van 0-255. Voordat we ze aan het neurale netwerk doorgeven, moeten we deze waarden schalen naar een bereik van 0-1. Bij het plotten van afbeeldingen moeten we hetzelfde doen, of de waarden converteren naar het `int`-type (wat we doen in de bovenstaande code), om `matplotlib` te laten zien dat we de originele niet-geschaalde afbeelding willen plotten.\n"
"> **Opmerking**: Alle afbeeldingen in de dataset worden weergegeven als floating point-tensoren met een bereik van 0-255. Voordat we ze aan het neurale netwerk doorgeven, moeten we deze waarden schalen naar een bereik van 0-1. Bij het plotten van afbeeldingen moeten we hetzelfde doen, of waarden converteren naar het `int`-type (wat we hierboven in de code doen), om aan `matplotlib` te laten zien dat we de oorspronkelijke, niet-geschaalde afbeelding willen plotten.\n"
]
},
{
@ -462,7 +462,7 @@
"source": [
"## Voorgetrainde modellen\n",
"\n",
"Voor veel beeldclassificatietaken zijn er voorgetrainde neurale netwerkmodellen beschikbaar. Veel van deze modellen zijn te vinden binnen de `keras.applications` namespace, en nog meer modellen zijn beschikbaar op het internet. Laten we eens kijken hoe het eenvoudigste VGG-16 model geladen en gebruikt kan worden:\n"
"Voor veel beeldclassificatietaken zijn er voorgetrainde neurale netwerkmodellen beschikbaar. Veel van die modellen zijn beschikbaar binnen de `keras.applications` namespace, en nog meer modellen zijn te vinden op het internet. Laten we eens zien hoe het eenvoudigste VGG-16 model kan worden geladen en gebruikt:\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": [
"Er zijn een paar belangrijke dingen hier:\n",
"* Voordat een invoer aan een voorgetraind netwerk wordt doorgegeven, moet deze op een bepaalde manier worden voorbewerkt. Dit gebeurt door de bijbehorende functie `preprocess_input` aan te roepen, die een batch afbeeldingen ontvangt en hun bewerkte vorm teruggeeft. In het geval van VGG-16 worden de afbeeldingen genormaliseerd en wordt een vooraf bepaalde gemiddelde waarde voor elke kanaal afgetrokken. Dit komt omdat VGG-16 oorspronkelijk met deze voorbewerking is getraind.\n",
"* Het neurale netwerk wordt toegepast op de invoerbatch, en als resultaat ontvangen we een batch van 1000-element tensors die de waarschijnlijkheid van elke klasse aangeven. We kunnen het meest waarschijnlijke klasnummer vinden door `argmax` op deze tensor aan te roepen.\n",
"* Het verkregen resultaat is een [nummer van een `ImageNet`-klasse](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). Om dit resultaat te begrijpen, kunnen we ook de functie `decode_predictions` gebruiken, die de top n klassen samen met hun namen retourneert.\n"
"Er zijn hier een paar belangrijke dingen:\n",
"* Voordat een invoer naar een vooraf getraind netwerk wordt gestuurd, moet deze op een bepaalde manier worden voorbewerkt. Dit gebeurt door het aanroepen van de bijbehorende `preprocess_input` functie, die een batch afbeeldingen ontvangt en hun verwerkte vorm retourneert. In het geval van VGG-16 worden afbeeldingen genormaliseerd en wordt een vooraf gedefinieerde gemiddelde waarde voor elk kanaal afgetrokken. Dat is omdat VGG-16 oorspronkelijk met deze voorbewerking is getraind.\n",
"* Het neurale netwerk wordt toegepast op de invoerbatch, en we ontvangen als resultaat een batch van 1000-elemententensors die de waarschijnlijkheid van elke klasse weergeven. We kunnen het meest waarschijnlijke klasnummer vinden door `argmax` op deze tensor aan te roepen.\n",
"* Het verkregen resultaat is een [nummer van een `ImageNet` klasse](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). Om dit resultaat te interpreteren, kunnen we ook de `decode_predictions` functie gebruiken, die de top n klassen retourneert samen met hun namen.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Laten we ook de architectuur van het VGG-16-netwerk bekijken:\n"
"Laten we ook de architectuur van het VGG-16 netwerk bekijken:\n"
]
},
{
@ -599,7 +609,7 @@
"source": [
"## GPU-berekeningen\n",
"\n",
"Diepe neurale netwerken, zoals VGG-16 en andere modernere architecturen, vereisen behoorlijk wat rekenkracht om te draaien. Het is logisch om GPU-versnelling te gebruiken als deze beschikbaar is. Gelukkig versnelt Keras automatisch de berekeningen op de GPU als deze beschikbaar is. We kunnen controleren of Tensorflow de GPU kan gebruiken met de volgende code:\n"
"Diepe neurale netwerken, zoals VGG-16 en andere meer moderne architecturen, vereisen behoorlijk wat rekenkracht om te draaien. Het is logisch om gebruik te maken van GPU-versnelling, als deze beschikbaar is. Gelukkig versnelt Keras automatisch de berekeningen op de GPU als deze beschikbaar is. We kunnen controleren of Tensorflow de GPU kan gebruiken met de volgende code:\n"
]
},
{
@ -626,9 +636,10 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"## VGG-functies extraheren\n",
"\n",
"Als we VGG-16 willen gebruiken om functies uit onze afbeeldingen te halen, hebben we het model nodig zonder de laatste classificatielagen. We kunnen het VGG-16 model zonder de bovenste lagen instantiëren met deze code:\n"
"## VGG-kenmerken extraheren\n",
"\n",
"Als we VGG-16 willen gebruiken om kenmerken uit onze afbeeldingen te halen, hebben we het model zonder de laatste classificatielagen nodig. We kunnen het VGG-16-model zonder bovenste lagen instantiëren met deze code:\n"
]
},
{
@ -680,9 +691,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"De dimensie van de feature-tensor is 7x7x512, maar om het te kunnen visualiseren moesten we het omvormen naar een 2D-vorm.\n",
"De dimensie van de feature-tensor is 7x7x512, maar om deze te visualiseren moesten we het herschikken naar een 2D-vorm.\n",
"\n",
"Laten we nu proberen te zien of deze features gebruikt kunnen worden om afbeeldingen te classificeren. We nemen handmatig een deel van de afbeeldingen (in ons geval 50 minibatches) en berekenen vooraf hun feature-vectoren. We kunnen hiervoor de **dataset** API van Tensorflow gebruiken. De `map`-functie neemt een dataset en past een gegeven lambda-functie toe om deze te transformeren. We gebruiken dit mechanisme om nieuwe datasets te maken, `ds_features_train` en `ds_features_test`, die VGG-geëxtraheerde features bevatten in plaats van de originele afbeeldingen.\n"
"Laten we nu proberen te zien of die features gebruikt kunnen worden om afbeeldingen te classificeren. Laten we handmatig een deel van de afbeeldingen nemen (50 minibatches, in ons geval) en hun featurevectoren vooraf berekenen. We kunnen de Tensorflow **dataset** API gebruiken om dat te doen. De `map` functie neemt een dataset en past er een gegeven lambda-functie op toe om deze te transformeren. We gebruiken dit mechanisme om nieuwe datasets te construeren, `ds_features_train` en `ds_features_test`, die VGG-extractie features bevatten in plaats van originele afbeeldingen.\n"
]
},
{
@ -712,9 +723,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"We gebruikten de constructie `.take(50)` om de datasetgrootte te beperken, zodat onze demonstratie sneller verloopt. Je kunt dit experiment natuurlijk ook uitvoeren op de volledige dataset.\n",
"We hebben de constructie `.take(50)` gebruikt om de datasetgrootte te beperken, om onze demonstratie te versnellen. Je kunt dit experiment natuurlijk uitvoeren op de volledige dataset.\n",
"\n",
"Nu we een dataset hebben met geëxtraheerde kenmerken, kunnen we een eenvoudige dense classifier trainen om onderscheid te maken tussen katten en honden. Dit netwerk neemt een featurevector met de vorm (7,7,512) en produceert één output die overeenkomt met ofwel een hond of een kat. Omdat het een binaire classificatie is, gebruiken we de `sigmoid` activatiefunctie en de `binary_crossentropy` verliesfunctie.\n"
"Nu we een dataset hebben met geëxtraheerde kenmerken, kunnen we een eenvoudige dense classifier trainen om katten en honden van elkaar te onderscheiden. Dit netwerk neemt een featurevector van vorm (7,7,512) en produceert één output die overeenkomt met een hond of een kat. Omdat het een binaire classificatie is, gebruiken we de `sigmoid` activatiefunctie en de `binary_crossentropy` loss.\n"
]
},
{
@ -743,13 +754,13 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Het resultaat is geweldig, we kunnen met bijna 95% zekerheid onderscheid maken tussen een kat en een hond! Echter, we hebben deze aanpak alleen getest op een subset van alle afbeeldingen, omdat handmatige feature-extractie veel tijd lijkt te kosten.\n",
"Het resultaat is geweldig, we kunnen bijna 95% waarschijnlijkheid onderscheid maken tussen een kat en een hond! We hebben deze benadering echter alleen getest op een subset van alle afbeeldingen, omdat handmatige kenmerkextractie veel tijd lijkt te kosten.\n",
"\n",
"## Transfer learning met één VGG-netwerk\n",
"\n",
"We kunnen het handmatig vooraf berekenen van de features ook vermijden door tijdens de training de originele VGG-16 netwerk in zijn geheel te gebruiken, door een feature extractor toe te voegen als eerste laag van ons netwerk.\n",
"We kunnen ook voorkomen dat we de kenmerken handmatig vooraf berekenen door het originele VGG-16 netwerk als geheel te gebruiken tijdens het trainen, door een feature extractor toe te voegen aan ons netwerk als eerste laag.\n",
"\n",
"Het mooie van de Keras-architectuur is dat het VGG-16 model dat we hierboven hebben gedefinieerd ook kan worden gebruikt als een laag in een ander neuraal netwerk! We hoeven alleen een netwerk te construeren met een dense classifier erbovenop, en vervolgens het hele netwerk te trainen met behulp van backpropagation.\n"
"Het mooie van de Keras-architectuur is dat het VGG-16 model dat we hierboven hebben gedefinieerd ook kan worden gebruikt als een laag in een ander neuraal netwerk! We hoeven alleen maar een netwerk te bouwen met een dense classifier erbovenop, en vervolgens het hele netwerk te trainen met behulp van backpropagation.\n"
]
},
{
@ -793,13 +804,13 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Dit model lijkt op een end-to-end classificatienetwerk, dat een afbeelding neemt en de klasse retourneert. Het lastige is echter dat we willen dat VGG16 fungeert als een feature extractor en niet opnieuw wordt getraind. Daarom moeten we de **gewichten van de convolutionele feature extractor bevriezen**. We kunnen toegang krijgen tot de eerste laag van het netwerk door `model.layers[0]` aan te roepen, en we hoeven alleen maar de eigenschap `trainable` op `False` te zetten.\n",
"Dit model lijkt op een end-to-end classificatienetwerk, dat een afbeelding neemt en de klasse retourneert. Het lastige is echter dat we willen dat VGG16 fungeert als een feature-extractor, en niet opnieuw getraind wordt. Daarom moeten we de **gewichten van de convolutionele feature-extractor bevriezen**. We kunnen toegang krijgen tot de eerste laag van het netwerk door `model.layers[0]` aan te roepen, en we hoeven alleen de eigenschap `trainable` op `False` te zetten.\n",
"\n",
"> **Opmerking**: Het bevriezen van de gewichten van de feature extractor is nodig, omdat anders de ongetrainde classifier-laag de originele voorgetrainde gewichten van de convolutionele extractor kan overschrijven.\n",
"> **Opmerking**: Het bevriezen van de gewichten van de feature-extractor is nodig, omdat anders de niet-getrainde classificatielaag de originele voor-getrainde gewichten van de convolutionele extractor kan vernietigen.\n",
"\n",
"Je kunt opmerken dat, hoewel het totale aantal parameters in ons netwerk ongeveer 15 miljoen is, we slechts 25k parameters trainen. Alle andere parameters van de bovenste convolutionele filters zijn voorgetraind. Dat is goed, omdat we een kleiner aantal parameters kunnen fijn afstellen met een kleiner aantal voorbeelden.\n",
"Je kunt zien dat hoewel het totale aantal parameters in ons netwerk ongeveer 15 miljoen is, we slechts 25k parameters trainen. Alle andere parameters van convolutionele filters op hoog niveau zijn voorgetraind. Dat is goed, omdat we in staat zijn een kleiner aantal parameters te verfijnen met een kleiner aantal voorbeelden.\n",
"\n",
"We gaan nu ons netwerk trainen en kijken hoe goed we kunnen presteren. Verwacht een vrij lange uitvoeringstijd, en maak je geen zorgen als het lijkt alsof de uitvoering een tijdje vastloopt.\n"
"We gaan nu ons netwerk trainen en kijken hoe goed we kunnen worden. Verwacht een tamelijk lange looptijd, en maak je geen zorgen als de uitvoering enige tijd lijkt te bevriezen.\n"
]
},
{
@ -824,9 +835,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Het lijkt erop dat we een redelijk nauwkeurige katten- versus hondenclassifier hebben verkregen!\n",
"Het lijkt erop dat we een redelijk nauwkeurige katten versus honden classifier hebben verkregen!\n",
"\n",
"## Het model opslaan en laden\n",
"## Het opslaan en laden van het model\n",
"\n",
"Zodra we het model hebben getraind, kunnen we de modelarchitectuur en getrainde gewichten opslaan in een bestand voor toekomstig gebruik:\n"
]
@ -852,7 +863,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"We kunnen het model op elk moment vanuit een bestand laden. Dit kan handig zijn als het volgende experiment het model vernietigt - je hoeft dan niet helemaal opnieuw te beginnen.\n"
"We kunnen het model dan op elk moment vanuit het bestand laden. Dit kan handig zijn voor het geval het volgende experiment het model vernietigt - dan hoef je niet helemaal opnieuw te beginnen.\n"
]
},
{
@ -868,15 +879,15 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"## Fine-tuning transfer learning\n",
"## Fijn afstemmen van transfer learning\n",
"\n",
"In de vorige sectie hebben we de laatste classifier-laag getraind om afbeeldingen in onze eigen dataset te classificeren. Echter, we hebben de feature extractor niet opnieuw getraind, en ons model maakte gebruik van de features die het model heeft geleerd op ImageNet-data. Als jouw objecten visueel verschillen van gewone ImageNet-afbeeldingen, werkt deze combinatie van features mogelijk niet optimaal. Daarom is het logisch om ook de convolutionele lagen te gaan trainen.\n",
"In de vorige sectie hebben we de laatste classificatielaag getraind om afbeeldingen in onze eigen dataset te classificeren. We hebben echter de feature-extractor niet opnieuw getraind en ons model vertrouwde op de kenmerken die het model had geleerd van ImageNet-gegevens. Als uw objecten visueel verschillen van gewone ImageNet-afbeeldingen, werkt deze combinatie van kenmerken mogelijk niet het beste. Het is daarom logisch om ook de convolutionele lagen te trainen.\n",
"\n",
"Om dat te doen, kunnen we de parameters van de convolutionele filters die we eerder hebben bevroren, weer vrijgeven.\n",
"Om dat te doen, kunnen we de parameters van de convolutionele filter 'ontdooien' die we eerder hadden bevroren.\n",
"\n",
"> **Note:** Het is belangrijk dat je eerst de parameters bevriest en enkele epochs traint om de gewichten in de classificatielaag te stabiliseren. Als je meteen begint met het trainen van een end-to-end netwerk met vrijgegeven parameters, is de kans groot dat grote fouten de voorgetrainde gewichten in de convolutionele lagen vernietigen.\n",
"> **Opmerking:** Het is belangrijk dat u eerst de parameters bevriest en een aantal epochs training uitvoert om de gewichten in de classificatielaag te stabiliseren. Als u onmiddellijk begint met het trainen van het end-to-end netwerk met ontdooide parameters, is de kans groot dat grote fouten de vooraf getrainde gewichten in de convolutionele lagen vernietigen.\n",
"\n",
"Ons convolutionele VGG-16 model bevindt zich in de eerste laag en bestaat zelf uit veel lagen. We kunnen de structuur ervan bekijken:\n"
"Ons convolutionele VGG-16 model bevindt zich binnen de eerste laag en bestaat zelf uit veel lagen. We kunnen zijn structuur bekijken:\n"
]
},
{
@ -945,7 +956,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"We kunnen alle lagen van de convolutionele basis ontgrendelen:\n"
"We kunnen alle lagen van de convolutionele basis deblokkeren:\n"
]
},
{
@ -961,7 +972,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Echter, het tegelijkertijd ontgrendelen van allemaal is niet het beste idee. We kunnen eerst slechts een paar laatste lagen van convoluties ontgrendelen, omdat deze hogere niveau patronen bevatten die relevant zijn voor onze afbeeldingen. Bijvoorbeeld, om te beginnen, kunnen we alle lagen bevroren houden behalve de laatste 4:\n"
"Het tegelijk unfreezen van ze allemaal is echter niet het beste idee. We kunnen eerst alleen een paar laatste convolutielagen unfreezen, omdat deze hogere niveau patronen bevatten die relevant zijn voor onze afbeeldingen. Bijvoorbeeld, om te beginnen kunnen we alle lagen bevriezen behalve de laatste 4: \n"
]
},
{
@ -1002,7 +1013,7 @@
"source": [
"Merk op dat het aantal trainbare parameters aanzienlijk is toegenomen, maar het is nog steeds ongeveer 50% van alle parameters.\n",
"\n",
"Na het ontgrendelen kunnen we nog een paar extra epochs trainen (in ons voorbeeld doen we er slechts één). Je kunt ook een lagere leersnelheid kiezen om de impact op de voorgetrainde gewichten te minimaliseren. Echter, zelfs met een lage leersnelheid kun je verwachten dat de nauwkeurigheid in het begin van de training daalt, totdat uiteindelijk een iets hoger niveau wordt bereikt dan in het geval van vaste gewichten.\n",
"Na het deblokkeren kunnen we nog een paar tijdperken van training doen (in ons voorbeeld doen we er maar één). Je kunt ook een lagere leer snelheid kiezen om de impact op de voorgetrainde gewichten te minimaliseren. Echter, zelfs met een lage leer snelheid kun je verwachten dat de nauwkeurigheid aan het begin van de training daalt, totdat deze uiteindelijk iets hoger wordt dan in het geval van vaste gewichten.\n",
"\n",
"> **Opmerking:** Deze training verloopt veel langzamer, omdat we de gradiënten terug moeten propageren door veel lagen van het netwerk!\n"
]
@ -1028,18 +1039,18 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"We zullen waarschijnlijk een hogere trainingsnauwkeurigheid bereiken, omdat we een krachtiger netwerk met meer parameters gebruiken, maar de validatienauwkeurigheid zal niet evenredig toenemen.\n",
"We zullen waarschijnlijk een hogere trainingsnauwkeurigheid bereiken, omdat we een krachtiger netwerk met meer parameters gebruiken, maar de validatienauwkeurigheid zal niet zoveel toenemen.\n",
"\n",
"Voel je vrij om nog een paar extra lagen van het netwerk te ontgrendelen en verder te trainen, om te zien of je een hogere nauwkeurigheid kunt behalen!\n"
"Voel je vrij om nog een paar lagen van het netwerk te ontvriezen en meer te trainen, om te zien of je een hogere nauwkeurigheid kunt bereiken!\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Andere computervisiemodellen\n",
"## Andere computer vision-modellen\n",
"\n",
"VGG-16 is een van de eenvoudigste computervisie-architecturen. Keras biedt veel meer vooraf getrainde netwerken. De meest gebruikte hiervan zijn **ResNet**-architecturen, ontwikkeld door Microsoft, en **Inception** van Google. Laten we bijvoorbeeld de architectuur van het eenvoudigste ResNet-50 model verkennen (ResNet is een familie van modellen met verschillende dieptes, je kunt experimenteren met ResNet-152 als je wilt zien hoe een echt diep model eruitziet):\n"
"VGG-16 is een van de eenvoudigste computer vision-architecturen. Keras biedt nog veel meer vooraf getrainde netwerken. De meest gebruikte daarvan zijn de **ResNet**-architecturen, ontwikkeld door Microsoft, en **Inception** van Google. Laten we bijvoorbeeld de architectuur van het eenvoudigste ResNet-50-model verkennen (ResNet is een familie van modellen met verschillende dieptes; je kunt experimenteren met ResNet-152 als je wilt zien hoe een echt diep model eruitziet):\n"
]
},
{
@ -1441,29 +1452,29 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Zoals je kunt zien, bevat het model dezelfde vertrouwde bouwstenen: convolutionele lagen, poolinglagen en een uiteindelijke dense classifier. We kunnen dit model op exact dezelfde manier gebruiken als we VGG-16 hebben gebruikt voor transfer learning. Je kunt experimenteren met de bovenstaande code door verschillende ResNet-modellen als basismodel te gebruiken en te kijken hoe de nauwkeurigheid verandert.\n",
"Zoals je kunt zien, bevat het model dezelfde vertrouwde bouwstenen: convolutionele lagen, pooling-lagen en een uiteindelijke dichte classifier. We kunnen dit model op exact dezelfde manier gebruiken als we VGG-16 hebben gebruikt voor transfer learning. Je kunt proberen te experimenteren met de bovenstaande code, door verschillende ResNet-modellen als basismodel te gebruiken, en te zien hoe de nauwkeurigheid verandert.\n",
"\n",
"## Batch Normalisatie\n",
"## Batchnormalisatie\n",
"\n",
"Dit netwerk bevat nog een ander type laag: **Batch Normalisatie**. Het idee achter batch normalisatie is om de waarden die door het neurale netwerk stromen naar het juiste interval te brengen. Neurale netwerken werken meestal het beste wanneer alle waarden zich in het bereik van [-1,1] of [0,1] bevinden, en daarom schalen/normaliseren we onze invoergegevens dienovereenkomstig. Tijdens het trainen van een diep netwerk kan het echter gebeuren dat waarden aanzienlijk buiten dit bereik vallen, wat het trainen problematisch maakt. De batch normalisatielaag berekent het gemiddelde en de standaardafwijking voor alle waarden van de huidige minibatch en gebruikt deze om het signaal te normaliseren voordat het door een laag van het neurale netwerk wordt gestuurd. Dit verbetert de stabiliteit van diepe netwerken aanzienlijk.\n"
"Dit netwerk bevat nog een ander type laag: **Batchnormalisatie**. Het idee van batchnormalisatie is om waarden die door het neurale netwerk stromen naar het juiste interval te brengen. Gewoonlijk werken neurale netwerken het beste wanneer alle waarden binnen het bereik van [-1,1] of [0,1] liggen, en dat is de reden dat we onze invoergegevens dienovereenkomstig schalen/normaliseren. Tijdens het trainen van een diep netwerk kan het echter gebeuren dat waarden aanzienlijk buiten dit bereik komen, wat het trainen problematisch maakt. De batchnormalisatielaag berekent het gemiddelde en de standaarddeviatie voor alle waarden van de huidige minibatch, en gebruikt deze om het signaal te normaliseren voordat het door een neurale netwerklaag wordt gestuurd. Dit verbetert de stabiliteit van diepe netwerken aanzienlijk.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Belangrijkste punten\n",
"## Conclusie\n",
"\n",
"Met behulp van transfer learning konden we snel een classifier samenstellen voor onze aangepaste objectclassificatietaak en een hoge nauwkeurigheid behalen. Dit voorbeeld was echter niet helemaal eerlijk, omdat het originele VGG-16-netwerk vooraf was getraind om katten en honden te herkennen. We maakten dus vooral gebruik van patronen die al in het netwerk aanwezig waren. Je kunt een lagere nauwkeurigheid verwachten bij meer exotische, domeinspecifieke objecten, zoals details op een productielijn in een fabriek of verschillende boombladeren.\n",
"Met transfer learning konden we snel een classifier samenstellen voor onze aangepaste objectclassificatietaak en een hoge nauwkeurigheid bereiken. Deze voorbeeld was echter niet helemaal eerlijk, omdat het originele VGG-16-netwerk vooraf was getraind om katten en honden te herkennen, en we dus grotendeels de patronen hergebruikten die al in het netwerk aanwezig waren. Je kunt een lagere nauwkeurigheid verwachten bij exotischere domeinspecifieke objecten, zoals details op een productielijn in een fabriek, of verschillende boombladeren.\n",
"\n",
"Je ziet dat complexere taken die we nu oplossen meer rekenkracht vereisen en niet eenvoudig op de CPU kunnen worden uitgevoerd. In de volgende eenheid proberen we een lichtere implementatie te gebruiken om hetzelfde model te trainen met minder rekenbronnen, wat resulteert in slechts een iets lagere nauwkeurigheid.\n"
"Je kunt zien dat complexere taken die we nu oplossen, hogere rekenkracht vereisen en niet eenvoudig op de CPU kunnen worden opgelost. In de volgende eenheid zullen we proberen een lichtere implementatie te gebruiken om hetzelfde model te trainen met minder rekenbronnen, wat resulteert in slechts een iets lagere nauwkeurigheid.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n---\n\n**Disclaimer**: \nDit document is vertaald met behulp van de AI-vertalingsservice [Co-op Translator](https://github.com/Azure/co-op-translator). Hoewel we streven naar nauwkeurigheid, dient u zich ervan bewust te zijn dat geautomatiseerde vertalingen fouten of onnauwkeurigheden kunnen bevatten. Het originele document in zijn oorspronkelijke taal moet worden beschouwd als de gezaghebbende bron. Voor cruciale informatie wordt professionele menselijke vertaling aanbevolen. Wij zijn niet aansprakelijk voor eventuele misverstanden of verkeerde interpretaties die voortvloeien uit het gebruik van deze vertaling.\n"
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**Disclaimer**:\nDit document is vertaald met behulp van de AI vertaaldienst [Co-op Translator](https://github.com/Azure/co-op-translator). Hoewel we streven naar nauwkeurigheid, dient u er rekening mee te houden dat geautomatiseerde vertalingen fouten of onnauwkeurigheden kunnen bevatten. Het originele document in de oorspronkelijke taal moet worden beschouwd als de gezaghebbende bron. Voor kritieke informatie wordt professionele menselijke vertaling aanbevolen. Wij zijn niet aansprakelijk voor eventuele misverstanden of verkeerde interpretaties die voortvloeien uit het gebruik van deze vertaling.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
]
}
],
@ -1484,12 +1495,6 @@
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.10"
},
"coopTranslator": {
"original_hash": "c189abc107848f96051085cc30945129",
"translation_date": "2025-08-28T20:36:07+00:00",
"source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb",
"language_code": "nl"
}
},
"nbformat": 4,

54
translations/nl/lessons/5-NLP/README.md
View File

@ -1,34 +1,34 @@
# Natuurlijke Taalverwerking
![Samenvatting van NLP-taken in een schets](../../../../translated_images/nl/ai-nlp.b22dcb8ca4707cea.webp)
![Overzicht van NLP-taken in een schets](../../../../translated_images/nl/ai-nlp.b22dcb8ca4707cea.webp)
In deze sectie richten we ons op het gebruik van neurale netwerken om taken met betrekking tot **Natuurlijke Taalverwerking (NLP)** uit te voeren. Er zijn veel NLP-problemen die we willen dat computers kunnen oplossen:
In deze sectie richten we ons op het gebruik van neurale netwerken voor het uitvoeren van taken gerelateerd aan **Natuurlijke Taalverwerking (NLP)**. Er zijn veel NLP-problemen die we willen dat computers kunnen oplossen:
* **Tekstclassificatie** is een typisch classificatieprobleem dat betrekking heeft op tekstreeksen. Voorbeelden zijn het classificeren van e-mails als spam versus geen spam, of het categoriseren van artikelen als sport, zakelijk, politiek, enzovoort. Ook bij het ontwikkelen van chatbots moeten we vaak begrijpen wat een gebruiker bedoelt -- in dit geval hebben we te maken met **intentieclassificatie**. Bij intentieclassificatie moeten we vaak omgaan met veel categorieën.
* **Sentimentanalyse** is een typisch regressieprobleem, waarbij we een getal (een sentiment) moeten toekennen dat aangeeft hoe positief/negatief de betekenis van een zin is. Een meer geavanceerde versie van sentimentanalyse is **aspect-gebaseerde sentimentanalyse** (ABSA), waarbij we sentiment niet toekennen aan de hele zin, maar aan verschillende delen ervan (aspecten), bijvoorbeeld: *In dit restaurant vond ik de keuken lekker, maar de sfeer was vreselijk*.
* **Tekstclassificatie** is een typisch classificatieprobleem met betrekking tot tekstreeksen. Voorbeelden zijn het classificeren van e-mailberichten als spam versus geen spam, of het categoriseren van artikelen als sport, zakelijk, politiek, enz. Ook bij het ontwikkelen van chatbots moeten we vaak begrijpen wat een gebruiker wilde zeggen – in dit geval hebben we te maken met **intentieclassificatie**. Vaak moeten we in intentieclassificatie met veel categorieën omgaan.
* **Sentimentanalyse** is een typisch regressieprobleem, waarbij we een getal (een sentiment) moeten toekennen dat aangeeft hoe positief/negatief de betekenis van een zin is. Een geavanceerdere versie van sentimentanalyse is **aspect-gebaseerde sentimentanalyse** (ABSA), waarbij we het sentiment niet aan de hele zin toekennen, maar aan verschillende delen ervan (aspecten), bijvoorbeeld *In dit restaurant vond ik de keuken lekker, maar de sfeer was verschrikkelijk*.
* **Named Entity Recognition** (NER) verwijst naar het probleem van het extraheren van bepaalde entiteiten uit tekst. Bijvoorbeeld, we moeten begrijpen dat in de zin *Ik moet morgen naar Parijs vliegen* het woord *morgen* verwijst naar DATUM, en *Parijs* een LOCATIE is.
* **Sleutelwoordextractie** lijkt op NER, maar hierbij moeten we woorden die belangrijk zijn voor de betekenis van de zin automatisch extraheren, zonder vooraf te trainen op specifieke entiteitstypen.
* **Trefwoordanalyse** is vergelijkbaar met NER, maar we moeten automatisch woorden extraheren die belangrijk zijn voor de betekenis van de zin, zonder vooraf te trainen op specifieke entiteitstypen.
* **Tekstclustering** kan nuttig zijn wanneer we vergelijkbare zinnen willen groeperen, bijvoorbeeld vergelijkbare verzoeken in technische ondersteuningsgesprekken.
* **Vraagbeantwoording** verwijst naar het vermogen van een model om een specifieke vraag te beantwoorden. Het model ontvangt een tekstpassage en een vraag als invoer, en moet een plaats in de tekst aangeven waar het antwoord op de vraag te vinden is (of soms het antwoord genereren).
* **Tekstgeneratie** is het vermogen van een model om nieuwe tekst te genereren. Het kan worden beschouwd als een classificatietaak die de volgende letter/woord voorspelt op basis van een *tekstprompt*. Geavanceerde tekstgeneratiemodellen, zoals GPT-3, kunnen andere NLP-taken oplossen, zoals classificatie, met behulp van een techniek genaamd [prompt programming](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) of [prompt engineering](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29).
* **Tekstsamenvatting** is een techniek waarbij we willen dat een computer lange tekst "leest" en samenvat in een paar zinnen.
* **Machinevertaling** kan worden gezien als een combinatie van tekstbegrip in één taal en tekstgeneratie in een andere taal.
* **Vraag beantwoorden** verwijst naar het vermogen van een model om een specifieke vraag te beantwoorden. Het model ontvangt een tekstpassage en een vraag als invoer en moet een plek in de tekst aangeven waar het antwoord op de vraag te vinden is (of soms het antwoord genereren).
* **Tekstgeneratie** is het vermogen van een model om nieuwe tekst te genereren. Dit kan worden gezien als een classificatieprobleem waarbij het volgende teken/woord wordt voorspeld op basis van een *tekstprompt*. Geavanceerde tekstgeneratiemodellen, zoals GPT-3, kunnen ook andere NLP-taken oplossen zoals classificatie met een techniek genaamd [prompt programming](https://towardsdatascience.com/software-3-0-how-prompting-will-change-the-rules-of-the-game-a982fbfe1e0) of [prompt engineering](https://medium.com/swlh/openai-gpt-3-and-prompt-engineering-dcdc2c5fcd29)
* **Tekstsamenvatting** is een techniek waarbij we een computer willen laten "lezen" van lange tekst en deze samenvatten in een paar zinnen.
* **Machinevertaling** kan worden gezien als een combinatie van tekstbegrip in de ene taal en tekstgeneratie in een andere taal.
Aanvankelijk werden de meeste NLP-taken opgelost met traditionele methoden zoals grammatica's. Bijvoorbeeld, bij machinevertaling werden parsers gebruikt om de oorspronkelijke zin om te zetten in een syntaxisboom, waarna hogere semantische structuren werden geëxtraheerd om de betekenis van de zin te vertegenwoordigen. Op basis van deze betekenis en de grammatica van de doeltaal werd het resultaat gegenereerd. Tegenwoordig worden veel NLP-taken effectiever opgelost met neurale netwerken.
Aanvankelijk werden de meeste NLP-taken opgelost met traditionele methoden zoals grammatica’s. Bijvoorbeeld, bij machinevertaling werden parsers gebruikt om de oorspronkelijke zin om te zetten in een syntaxisboom, daarna werden hogere semantische structuren geëxtraheerd om de betekenis van de zin te vertegenwoordigen en op basis van deze betekenis en de grammatica van de doeltaal werd het resultaat gegenereerd. Tegenwoordig worden veel NLP-taken effectiever opgelost met neurale netwerken.
> Veel klassieke NLP-methoden zijn geïmplementeerd in de [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org) Python-bibliotheek. Er is een geweldig [NLTK Boek](https://www.nltk.org/book/) online beschikbaar dat behandelt hoe verschillende NLP-taken kunnen worden opgelost met NLTK.
> Veel klassieke NLP-methoden zijn geïmplementeerd in de Python-bibliotheek [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org). Er is een geweldige [NLTK-boek](https://www.nltk.org/book/) online beschikbaar dat behandelt hoe verschillende NLP-taken met NLTK kunnen worden opgelost.
In onze cursus zullen we ons voornamelijk richten op het gebruik van neurale netwerken voor NLP, en we zullen NLTK gebruiken waar nodig.
In onze cursus zullen we ons vooral richten op het gebruik van neurale netwerken voor NLP en waar nodig NLTK gebruiken.
We hebben al geleerd hoe we neurale netwerken kunnen gebruiken voor het werken met tabelgegevens en afbeeldingen. Het belangrijkste verschil tussen die soorten gegevens en tekst is dat tekst een reeks van variabele lengte is, terwijl de invoergrootte bij afbeeldingen vooraf bekend is. Hoewel convolutionele netwerken patronen uit invoergegevens kunnen extraheren, zijn patronen in tekst complexer. Bijvoorbeeld, ontkenning kan gescheiden zijn van het onderwerp door willekeurig veel woorden (bijvoorbeeld *Ik hou niet van sinaasappels* versus *Ik hou niet van die grote kleurrijke smakelijke sinaasappels*), en dat moet nog steeds worden geïnterpreteerd als één patroon. Daarom moeten we om taal te verwerken nieuwe typen neurale netwerken introduceren, zoals *recurrente netwerken* en *transformers*.
We hebben al geleerd hoe we neurale netwerken gebruiken om om te gaan met tabeldata en met afbeeldingen. Het belangrijkste verschil tussen die typen data en tekst is dat tekst een sequentie van variabele lengte is, terwijl de invoergrootte bij afbeeldingen van tevoren bekend is. Terwijl convolutionele netwerken patronen uit inputdata kunnen extraheren, zijn patronen in tekst complexer. Bijvoorbeeld, we kunnen hebben dat een ontkenning gescheiden is van het onderwerp door een willekeurig aantal woorden (bijv. *Ik hou niet van sinaasappels* versus *Ik hou niet van die grote kleurrijke smakelijke sinaasappels*), en dat moet toch als één patroon worden geïnterpreteerd. Daarom moeten we om taal te verwerken nieuwe typen neurale netwerken introduceren, zoals *recurrerende netwerken* en *transformers*.
## Bibliotheken installeren
Als je een lokale Python-installatie gebruikt om deze cursus uit te voeren, moet je mogelijk alle vereiste bibliotheken voor NLP installeren met de volgende commando's:
Als je een lokale Python-installatie gebruikt om deze cursus te volgen, moet je mogelijk alle vereiste bibliotheken voor NLP installeren met de volgende opdrachten:
**Voor PyTorch**
```bash
pip install -r requirements-torch.txt
pip install -r requirements-pytorch.txt
```
**Voor TensorFlow**
```bash
@ -39,13 +39,13 @@ pip install -r requirements-tf.txt
## GPU Waarschuwing
In deze sectie zullen we in sommige voorbeelden vrij grote modellen trainen.
* **Gebruik een computer met GPU-ondersteuning**: Het is aan te raden om je notebooks op een computer met GPU-ondersteuning uit te voeren om wachttijden te verminderen bij het werken met grote modellen.
* **Beperkingen van GPU-geheugen**: Het gebruik van een GPU kan leiden tot situaties waarin je geen GPU-geheugen meer hebt, vooral bij het trainen van grote modellen.
* **GPU-geheugenverbruik**: De hoeveelheid GPU-geheugen die wordt verbruikt tijdens training hangt af van verschillende factoren, waaronder de grootte van de minibatch.
* **Minimaliseer minibatchgrootte**: Als je problemen ondervindt met GPU-geheugen, overweeg dan om de minibatchgrootte in je code te verkleinen als mogelijke oplossing.
* **TensorFlow GPU-geheugen vrijgeven**: Oudere versies van TensorFlow kunnen GPU-geheugen mogelijk niet correct vrijgeven bij het trainen van meerdere modellen binnen één Python-kernel. Om GPU-geheugen effectief te beheren, kun je TensorFlow configureren om GPU-geheugen alleen toe te wijzen wanneer dat nodig is.
* **Code toevoegen**: Om TensorFlow zo in te stellen dat GPU-geheugen alleen groeit wanneer nodig, voeg je de volgende code toe aan je notebooks:
In deze sectie zullen we in sommige voorbeelden behoorlijk grote modellen trainen.
* **Gebruik een computer met GPU-ondersteuning**: Het is aan te raden om je notitieboeken op een computer met GPU-ondersteuning uit te voeren om wachttijden te verkorten bij het werken met grote modellen.
* **Beperkingen van GPU-geheugen**: Bij gebruik van een GPU kan het voorkomen dat je zonder GPU-geheugen komt te zitten, vooral bij het trainen van grote modellen.
* **GPU-geheugenverbruik**: De hoeveelheid GPU-geheugen die tijdens het trainen wordt gebruikt, hangt af van verschillende factoren, waaronder de minibatch-grootte.
* **Minimaliseer de minibatch-grootte**: Als je problemen ervaart met GPU-geheugen, overweeg dan om de minibatch-grootte in je code te verminderen als mogelijke oplossing.
* **TensorFlow GPU geheugen vrijgave**: Oudere versies van TensorFlow maken mogelijk GPU-geheugen niet correct vrij bij het trainen van meerdere modellen binnen één Python-kernel. Om het GPU-geheugenbeheer effectief te maken, kun je TensorFlow configureren zodat het GPU-geheugen alleen wordt toegewezen wanneer dat nodig is.
* **Code opnemen**: Om TensorFlow zo in te stellen dat het GPU-geheugen alleen groeit als dat nodig is, neem je de volgende code op in je notitieboeken:
```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)
```
Als je geïnteresseerd bent in het leren over NLP vanuit een klassiek ML-perspectief, bezoek dan [deze reeks lessen](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP).
Als je geïnteresseerd bent in NLP leren vanuit een klassiek ML-perspectief, bezoek dan [deze reeks lessen](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP)
## In deze sectie
In deze sectie leren we over:
* [Tekst representeren als tensors](13-TextRep/README.md)
* [Woordembeddings](14-Emdeddings/README.md)
* [Woorden-embedding](14-Emdeddings/README.md)
* [Taalmodellering](15-LanguageModeling/README.md)
* [Recurrente neurale netwerken](16-RNN/README.md)
* [Generatieve netwerken](17-GenerativeNetworks/README.md)
@ -67,5 +67,7 @@ In deze sectie leren we over:
---
**Disclaimer**:
Dit document is vertaald met behulp van de AI-vertalingsservice [Co-op Translator](https://github.com/Azure/co-op-translator). Hoewel we streven naar nauwkeurigheid, dient u zich ervan bewust te zijn dat geautomatiseerde vertalingen fouten of onnauwkeurigheden kunnen bevatten. Het originele document in de oorspronkelijke taal moet worden beschouwd als de gezaghebbende bron. Voor cruciale informatie wordt professionele menselijke vertaling aanbevolen. Wij zijn niet aansprakelijk voor eventuele misverstanden of verkeerde interpretaties die voortvloeien uit het gebruik van deze vertaling.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Disclaimer**:
Dit document is vertaald met behulp van de AI vertaaldienst [Co-op Translator](https://github.com/Azure/co-op-translator). Hoewel we streven naar nauwkeurigheid, dient u er rekening mee te houden dat geautomatiseerde vertalingen fouten of onnauwkeurigheden kunnen bevatten. Het originele document in de oorspronkelijke taal moet worden beschouwd als de gezaghebbende bron. Voor kritieke informatie wordt professionele menselijke vertaling aanbevolen. Wij zijn niet aansprakelijk voor eventuele misverstanden of verkeerde interpretaties die voortvloeien uit het gebruik van deze vertaling.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

37
translations/no/.co-op-translator.json
View File

@ -5,6 +5,12 @@
"source_file": "AGENTS.md",
"language_code": "no"
},
"CONTRIBUTING.md": {
"original_hash": "c6fd7e781b67111a90abd166d0ce4aa0",
"translation_date": "2026-07-08T15:52:54+00:00",
"source_file": "CONTRIBUTING.md",
"language_code": "no"
},
"README.md": {
"original_hash": "12c8eb6bf0867d2f1c32daf613ac5b8b",
"translation_date": "2026-04-06T20:56:32+00:00",
@ -17,6 +23,19 @@
"source_file": "SECURITY.md",
"language_code": "no"
},
"__translation_failures__": {
"lessons/sketchnotes/LICENSE.md": {
"original_hash": "45ab63a2cd8f5faef6c9b150618837a4",
"source_file": "lessons/sketchnotes/LICENSE.md",
"language_code": "no",
"failure_date": "2026-07-08T15:39:34+00:00",
"status": "failed",
"error_type": "TranslationIncompleteError",
"error_message": "Markdown translation remained incomplete for chunk 1.2.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:07:01+00:00",
@ -54,8 +73,8 @@
"language_code": "no"
},
"examples/README.md": {
"original_hash": "0d1babfdcbeb46525f2db3fbaaa54cd7",
"translation_date": "2025-10-03T11:31:39+00:00",
"original_hash": "7883d52c2e2a221e0b07a7b112a149b9",
"translation_date": "2026-07-08T15:33:46+00:00",
"source_file": "examples/README.md",
"language_code": "no"
},
@ -66,8 +85,8 @@
"language_code": "no"
},
"lessons/0-course-setup/how-to-run.md": {
"original_hash": "a4717bd9103b9f6cd84d534b83534689",
"translation_date": "2026-01-16T02:55:55+00:00",
"original_hash": "7ad8c7d8604c53649b3d4d1e2f3a6fa1",
"translation_date": "2026-07-08T15:34:07+00:00",
"source_file": "lessons/0-course-setup/how-to-run.md",
"language_code": "no"
},
@ -191,6 +210,12 @@
"source_file": "lessons/4-ComputerVision/08-TransferLearning/TrainingTricks.md",
"language_code": "no"
},
"lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb": {
"original_hash": "99b816b6a4957ef4100cee4c4221dff9",
"translation_date": "2026-07-08T15:29:36+00:00",
"source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb",
"language_code": "no"
},
"lessons/4-ComputerVision/08-TransferLearning/lab/README.md": {
"original_hash": "7765935c35fcee69b9fe2d0cfd6963e2",
"translation_date": "2025-08-28T15:18:01+00:00",
@ -330,8 +355,8 @@
"language_code": "no"
},
"lessons/5-NLP/README.md": {
"original_hash": "8ef02a9318257ea140ed3ed74442096d",
"translation_date": "2025-08-28T15:51:26+00:00",
"original_hash": "038df6f1a73e49f6430740da083bfd6d",
"translation_date": "2026-07-08T15:34:30+00:00",
"source_file": "lessons/5-NLP/README.md",
"language_code": "no"
},

29
translations/no/CONTRIBUTING.md Normal file
View File

@ -0,0 +1,29 @@
# Bidra til AI-For-Beginners
Takk for din interesse for å bidra til AI-For-Beginners! Vi ønsker oversettelser, rettelser av leksjoner og formateringskorrigeringer velkommen.
## Microsoft Contributor License Agreement (CLA)
Dette prosjektet ønsker bidrag og forslag velkommen. De fleste bidrag krever at du godtar en Contributor License Agreement (CLA) som erklærer at du har rett til, og faktisk gir oss, rettighetene til å bruke ditt bidrag. For detaljer, besøk [https://cla.microsoft.com](https://cla.microsoft.com).
Når du sender inn en pull request, vil en CLA-bot automatisk avgjøre om du må sende inn en CLA og dekorere PR-en passende (f.eks. etikett, kommentar). Følg bare instruksjonene som boten gir. Du trenger bare gjøre dette én gang for alle repositorier som bruker vår CLA.
## Hvordan bidra
### 1. Rette skrivefeil / kodefeil
Hvis du finner en skrivefeil eller feil i en Jupyter-notatbok eller leksjonens markdown-fil:
1. Fork repositoriet.
2. Rett skrivefeilen eller den ødelagte linken.
3. Send inn en Pull Request med en tydelig beskrivelse av rettelsen.
### 2. Sende inn oversettelser
Vi ønsker oversettelser av leksjonene til andre språk velkommen! Vennligst legg oversettelsene under `translations/`-mappen ved å bruke de eksisterende mappenavnene der (for eksempel `translations/es/`, `translations/pt-BR/`, `translations/zh-CN/`).
For mer informasjon, se [etc/CONTRIBUTING.md](etc/CONTRIBUTING.md).
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Ansvarsfraskrivelse**:
Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det opprinnelige dokumentet på originalspråket skal betraktes som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

54
translations/no/examples/README.md
View File

@ -1,27 +1,27 @@
# Nybegynnervennlige AI-eksempler
Velkommen! Denne katalogen inneholder enkle, frittstående eksempler som hjelper deg med å komme i gang med AI og maskinlæring. Hvert eksempel er laget for å være nybegynnervennlig med detaljerte kommentarer og trinnvise forklaringer.
Velkommen! Denne katalogen inneholder enkle, frittstående eksempler som hjelper deg i gang med AI og maskinlæring. Hvert eksempel er designet for å være nybegynnervennlig med detaljerte kommentarer og trinnvise forklaringer.
## 📚 Oversikt over eksempler
## 📚 Eksempelsammendrag
| Eksempel | Beskrivelse | Vanskelighetsgrad | Forutsetninger |
|----------|-------------|--------------------|----------------|
| [Hello AI World](../../../examples/01-hello-ai-world.py) | Ditt første AI-program – enkel mønstergjenkjenning | ⭐ Nybegynner | Grunnleggende Python |
| [Enkel nevralt nettverk](../../../examples/02-simple-neural-network.py) | Bygg et nevralt nettverk fra bunnen av | ⭐⭐ Nybegynner+ | Python, grunnleggende matematikk |
| [Bildeklassifisering](./03-image-classifier.ipynb) | Klassifiser bilder med en forhåndstrent modell | ⭐⭐ Nybegynner+ | Python, numpy |
| [Tekstsentiment](../../../examples/04-text-sentiment.py) | Analyser tekstsentiment (positiv/negativ) | ⭐⭐ Nybegynner+ | Python |
|---------|-------------|------------|---------------|
| [Hello AI World](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/01-hello-ai-world.py) | Ditt første AI-program - enkel mønstergjenkjenning | ⭐ Nybegynner | Grunnleggende Python |
| [Simple Neural Network](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/02-simple-neural-network.py) | Bygg et nevralt nettverk fra bunnen | ⭐⭐ Nybegynner+ | Python, grunnleggende matte |
| [Image Classifier](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/03-image-classifier.ipynb) | Klassifiser bilder med en forhåndstrent modell | ⭐⭐ Nybegynner+ | Python, numpy |
| [Text Sentiment](https://github.com/microsoft/AI-For-Beginners/blob/main/examples/04-text-sentiment.py) | Analyser tekstfølelse (positiv/negativ) | ⭐⭐ Nybegynner+ | Python |
## 🚀 Kom i gang
## 🚀 Komme i gang
### Forutsetninger
Sørg for at du har Python installert (anbefalt versjon 3.8 eller høyere). Installer nødvendige pakker:
Pass på at du har Python installert (3.8 eller nyere anbefales). Installer nødvendige pakker:
```bash
# For Python scripts
# For Python-skript
pip install numpy
# For Jupyter notebooks (image classifier)
# For Jupyter-notatbøker (bildefinner)
pip install jupyter numpy pillow tensorflow
```
@ -34,12 +34,12 @@ conda activate ai4beg
### Kjøre eksemplene
**For Python-skript (.py-filer):**
**For Python-skript (.py filer):**
```bash
python 01-hello-ai-world.py
```
**For Jupyter-notatbøker (.ipynb-filer):**
**For Jupyter-notatbøker (.ipynb filer):**
```bash
jupyter notebook 03-image-classifier.ipynb
```
@ -48,17 +48,17 @@ jupyter notebook 03-image-classifier.ipynb
Vi anbefaler å følge eksemplene i rekkefølge:
1. **Start med "Hello AI World"** – Lær det grunnleggende om mønstergjenkjenning
2. **Bygg et enkelt nevralt nettverk** – Forstå hvordan nevrale nettverk fungerer
3. **Prøv bildeklassifisering** – Se AI i aksjon med ekte bilder
4. **Analyser tekstsentiment** – Utforsk naturlig språkbehandling
1. **Start med "Hello AI World"** - Lær det grunnleggende om mønstergjenkjenning
2. **Bygg et enkelt nevralt nettverk** - Forstå hvordan nevrale nettverk fungerer
3. **Prøv bildeklassifikatoren** - Se AI i aksjon med ekte bilder
4. **Analyser tekstfølelse** - Utforsk naturlig språkbehandling
## 💡 Tips for nybegynnere
- **Les kodekommentarene nøye** – De forklarer hva hver linje gjør
- **Eksperimenter!** – Prøv å endre verdier og se hva som skjer
- **Ikke bekymre deg for å forstå alt** – Læring tar tid
- **Still spørsmål** – Bruk [Diskusjonsforumet](https://github.com/microsoft/AI-For-Beginners/discussions)
- **Les kodekommentarene nøye** - De forklarer hva hver linje gjør
- **Eksperimenter!** - Prøv å endre verdier og se hva som skjer
- **Ikke bekymre deg for å forstå alt med en gang** - Læring tar tid
- **Still spørsmål** - Bruk [Diskusjonsforumet](https://github.com/microsoft/AI-For-Beginners/discussions)
## 🔗 Neste steg
@ -70,16 +70,18 @@ Etter å ha fullført disse eksemplene, utforsk hele pensumet:
## 🤝 Bidra
Fant du disse eksemplene nyttige? Hjelp oss med å forbedre dem:
- Rapporter problemer eller foreslå forbedringer
Synes du disse eksemplene var nyttige? Hjelp oss å forbedre dem:
- Rapportér problemer eller foreslå forbedringer
- Legg til flere eksempler for nybegynnere
- Forbedre dokumentasjon og kommentarer
---
*Husk: Hver ekspert var en gang nybegynner. Lykke til med læringen! 🎓*
*Husk: Hver ekspert har en gang vært nybegynner. Lykke til med læringen! 🎓*
---
**Ansvarsfraskrivelse**:
Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Ansvarsfraskrivelse**:
Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det opprinnelige dokumentet på originalspråket skal betraktes som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

48
translations/no/lessons/0-course-setup/how-to-run.md
View File

@ -1,10 +1,10 @@
# Hvordan kjøre koden
Dette pensumet inneholder mange kjørbare eksempler og laboratorier som du vil kjøre. For å gjøre dette trenger du muligheten til å kjøre Python-kode i Jupyter Notebooks som følger med i dette pensumet. Du har flere alternativer for å kjøre koden:
Dette pensumet inneholder mange kjørbare eksempler og laboratorier som du vil kjøre. For å kunne gjøre dette, trenger du muligheten til å kjøre Python-kode i Jupyter Notebooks som følger med som en del av dette pensumet. Du har flere alternativer for å kjøre koden:
## Kjør lokalt på din egen datamaskin
For å kjøre koden lokalt på din datamaskin, trengs en Python-installasjon. En anbefaling er å installere **[miniconda](https://conda.io/en/latest/miniconda.html)** - det er en ganske lett installasjon som støtter `conda` pakkebehandler for forskjellige Python **virtuelle miljøer**.
For å kjøre koden lokalt på din egen datamaskin, trenger du en Python-installasjon. En anbefaling er å installere **[miniconda](https://conda.io/en/latest/miniconda.html)** - det er en relativt lettvekts installasjon som støtter `conda` pakkehåndtereren for forskjellige Python **virtuelle miljøer**.
Etter at du har installert miniconda, klon depotet og opprett et virtuelt miljø som skal brukes for dette kurset:
@ -15,57 +15,57 @@ conda env create --name ai4beg --file .devcontainer/environment.yml
conda activate ai4beg
```
### Bruke Visual Studio Code med Python Extension
### Bruke Visual Studio Code med Python-utvidelse
Dette pensumet fungerer best når du åpner 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 pensumet er best å bruke ved å åpne 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).
> **Merk**: Når du har klonet og åpnet mappen i VS Code, vil det automatisk foreslå deg å installere Python-utvidelser. Du må også installere miniconda som beskrevet ovenfor.
> **Merk**: Når du har klonet og åpnet katalogen i VS Code, vil det automatisk foreslå at du installerer Python-utvidelser. Du må også installere miniconda som beskrevet ovenfor.
> **Merk**: Hvis VS Code foreslår deg å åpne depotet på nytt i en container, bør du avslå dette for å bruke den lokale Python-installasjonen.
> **Merk**: Hvis VS Code foreslår at du åpner depotet på nytt i en container, bør du avslå dette for å bruke den lokale Python-installasjonen.
### Bruke Jupyter i nettleseren
Du kan også bruke et Jupyter-miljø fra nettleseren på din egen datamaskin. Både klassisk Jupyter og JupyterHub tilbyr et praktisk utviklingsmiljø med automatisk utfylling, kodeutheving, osv.
Du kan også bruke et Jupyter-miljø fra nettleseren på din egen datamaskin. Både klassisk Jupyter og JupyterHub gir et praktisk utviklingsmiljø med autofullføring, kodeutheving, osv.
For å starte Jupyter lokalt, gå til mappen for kurset, og kjør:
For å starte Jupyter lokalt, gå til katalogen for kurset, og kjør:
```bash
jupyter notebook
```
eller
eller
```bash
jupyterhub
```
Du kan da navigere til hvilke som helst `.ipynb`-filer, åpne dem og begynne å jobbe.
Du kan deretter navigere til alle `.ipynb`-filer, åpne dem og begynne å jobbe.
### Kjøring i container
### Kjøre i container
Et alternativ til Python-installasjon er å kjøre koden i en container. Siden vårt depot inneholder en spesiell `.devcontainer`-mappe som beskriver hvordan man bygger en container for dette depotet, tilbyr VS Code muligheten til å åpne koden i en container. Dette krever Docker-installasjon, og vil også være mer komplekst, så vi anbefaler dette for mer erfarne brukere.
Et alternativ til Python-installasjon vil være å kjøre koden i en container. Siden vårt depot inneholder en spesiell `.devcontainer`-mappe som instruerer hvordan bygge en container for dette repoet, tilbyr VS Code muligheten til å åpne koden i en container på nytt. Dette krever Docker-installasjon, og det kan også være mer komplisert, så vi anbefaler dette til mer erfarne brukere.
## Kjøring i skyen
## Kjøre i skyen
Hvis du ikke ønsker å installere Python lokalt, og har tilgang til noen skyressurser – vil det være et godt alternativ å kjøre koden i skyen. Det finnes flere måter du kan gjøre dette på:
Hvis du ikke ønsker å installere Python lokalt, og har tilgang til noen skyressurser - er et godt alternativ å kjøre koden i skyen. Det finnes flere måter du kan gjøre dette på:
* Bruke **[GitHub Codespaces](https://github.com/features/codespaces)**, som er et virtuelt miljø opprettet for deg på GitHub, tilgjengelig gjennom en VS Code nettlesergrensesnitt. Hvis du har tilgang til Codespaces, kan du bare trykke på **Code**-knappen i depotet, starte et codespace, og komme i gang på kort tid.
* Bruke **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) tilbyr gratis databehandlingsressurser i skyen for folk som deg for å teste ut kode på GitHub. Det finnes en knapp på forsiden for å åpne depotet i Binder – dette vil raskt ta deg til binder-siden, som vil bygge en underliggende container og starte et Jupyter-nettgrensesnitt for deg sømløst.
* Bruke **[GitHub Codespaces](https://github.com/features/codespaces)**, som er et virtuelt miljø opprettet for deg på GitHub, tilgjengelig via en VS Code nettlesergrensesnitt. Hvis du har tilgang til Codespaces, kan du bare klikke på **Code**-knappen i repoet, starte en codespace, og komme i gang på kort tid.
* Bruke **[Binder](https://mybinder.org/v2/gh/microsoft/ai-for-beginners/HEAD)**. [Binder](https://mybinder.org) tilbyr gratis databehandlingsressurser i skyen for folk som deg til å teste ut litt kode på GitHub. Det finnes en knapp på forsiden for å åpne depotet i Binder - dette skal raskt ta deg til binder-siden som vil bygge en underliggende container og starte et Jupyter-webgrensesnitt for deg sømløst.
> **Merk**: For å forhindre misbruk har Binder blokkert tilgang til noen nettressurser. Dette kan forhindre at noe av koden fungerer, som henter modeller og/eller datasett fra det offentlige Internett. Du må kanskje finne noen alternative løsninger. Også de beregningsressursene som tilbys av Binder er ganske enkle, så trening vil være treg, spesielt i senere, mer komplekse leksjoner.
> **Merk**: For å forhindre misbruk, har Binder tilgang til noen nettressurser blokkert. Dette kan hindre noe av koden i å fungere, spesielt den som henter modeller og/eller datasett fra det offentlige Internett. Du kan trenge noen løsninger. I tillegg er databehandlingsressursene fra Binder ganske grunnleggende, så trening vil være langsom, spesielt i senere, mer komplekse leksjoner.
## Kjøring i skyen med GPU
## Kjøre i skyen med GPU
Noen av de senere leksjonene i dette pensumet vil ha stor nytte av GPU-støtte. Modelltrening kan ellers bli smertefullt langsom. Det finnes noen få alternativer du kan følge, spesielt hvis du har tilgang til skyen enten via [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste), eller gjennom din utdanningsinstitusjon:
Noen av de senere leksjonene i dette pensumet vil i stor grad dra nytte av GPU-støtte. Modelltrening, for eksempel, kan være smertefullt tregt ellers. Det finnes noen alternativer du kan følge, spesielt hvis du har tilgang til skyen enten gjennom [Azure for Students](https://azure.microsoft.com/free/students/?WT.mc_id=academic-77998-cacaste), eller gjennom din institusjon:
* Opprett [Data Science Virtual Machine](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) og koble til den via Jupyter. Du kan da klone depotet rett på maskinen, og begynne å lære. NC-serie VM-er har GPU-støtte.
* Opprett [Data Science Virtual Machine](https://docs.microsoft.com/learn/modules/intro-to-azure-data-science-virtual-machine/?WT.mc_id=academic-77998-cacaste) og koble til den via Jupyter. Du kan da klone repoet direkte på maskinen, og begynne å lære. NC-serie VM-er har GPU-støtte.
> **Merk**: Noen abonnementer, inkludert Azure for Students, tilbyr ikke GPU-støtte som standard. Du må kanskje be om ekstra GPU-kjerner via en teknisk støtteforespørsel.
> **Merk**: Noen abonnementer, inkludert Azure for Students, tilbyr ikke GPU-støtte som standard. Du må kanskje be om flere GPU-kjerner via en teknisk supportforespørsel.
* Opprett [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) og bruk deretter Notebook-funksjonen der. [Denne videoen](https://azure-for-academics.github.io/quickstart/azureml-papers/) viser hvordan du kloner et depot inn i Azure ML-notatbok og begynner å bruke det.
* Opprett [Azure Machine Learning Workspace](https://azure.microsoft.com/services/machine-learning/?WT.mc_id=academic-77998-cacaste) og bruk deretter Notebook-funksjonen der. [Denne videoen](https://azure-for-academics.github.io/quickstart/azureml-papers/) viser hvordan du kloner et depot inn i Azure ML-notatbok og begynner å bruke den.
Du kan også bruke Google Colab, som kommer med noe gratis GPU-støtte, og laste opp Jupyter Notebooks der for å kjøre dem én etter én.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Ansvarsfraskrivelse**:
Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi søker å oppnå nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det opprinnelige dokumentet på originalspråket bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som følge av bruk av denne oversettelsen.
**Ansvarsfraskrivelse**:
Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det opprinnelige dokumentet på originalspråket skal betraktes som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

136
translations/no/lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb
View File

@ -4,11 +4,11 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"# Forhåndstrente modeller og transfer learning\n",
"# Fortrente modeller og overføringslæring\n",
"\n",
"Å trene CNN-er kan ta mye tid, og det kreves store mengder data for denne oppgaven. Imidlertid brukes mye av tiden på å lære de beste lavnivåfiltrene som et nettverk bruker for å trekke ut mønstre fra bilder. Et naturlig spørsmål oppstår – kan vi bruke et nevralt nettverk som er trent på ett datasett og tilpasse det til å klassifisere andre bilder uten å gjennomføre hele treningsprosessen?\n",
"Opplæring av CNN-er kan ta mye tid, og det kreves mye data for denne oppgaven. Imidlertid brukes mye av tiden til å lære de beste lavnivåfiltrene som et nettverk bruker for å trekke ut mønstre fra bilder. Et naturlig spørsmål oppstår – kan vi bruke et nevralt nettverk trent på ett datasett og tilpasse det til å klassifisere forskjellige bilder uten full opplæringsprosess?\n",
"\n",
"Denne tilnærmingen kalles **transfer learning**, fordi vi overfører noe kunnskap fra én nevralt nettverksmodell til en annen. I transfer learning starter vi vanligvis med en forhåndstrent modell, som er trent på et stort bildedatasett, som for eksempel **ImageNet**. Disse modellene er allerede gode til å trekke ut ulike funksjoner fra generiske bilder, og i mange tilfeller kan det å bygge en klassifiserer på toppen av de uttrukne funksjonene gi gode resultater.\n"
"Denne tilnærmingen kalles **overføringslæring**, fordi vi overfører noe kunnskap fra en nevralt nettverksmodell til en annen. I overføringslæring starter vi vanligvis med en fortrent modell, som er blitt trent på et stort bildedatasett, for eksempel **ImageNet**. Disse modellene kan allerede gjøre en god jobb med å trekke ut forskjellige funksjoner fra generiske bilder, og i mange tilfeller kan det å bare bygge en klassifiserer oppå disse uttrukne funksjonene gi et godt resultat.\n"
]
},
{
@ -31,9 +31,9 @@
"source": [
"## Katter vs. Hunder Datasett\n",
"\n",
"I denne enheten skal vi løse et reelt problem med å klassifisere bilder av katter og hunder. Av den grunn skal vi bruke [Kaggle Cats vs. Dogs Dataset](https://www.kaggle.com/c/dogs-vs-cats), som også kan lastes ned [fra Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n",
"I denne enheten skal vi løse et reelt problem med å klassifisere bilder av katter og hunder. Av denne grunn skal vi bruke [Kaggle Cats vs. Dogs Dataset](https://www.kaggle.com/c/dogs-vs-cats), som også kan lastes ned [fra Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=54765&WT.mc_id=academic-77998-cacaste).\n",
"\n",
"La oss laste ned dette datasettet og pakke det ut i `data`-katalogen (denne prosessen kan ta litt tid!):\n"
"La oss laste ned dette datasettet og pakke det ut i `data`-mappen (denne prosessen kan ta litt tid!):\n"
]
},
{
@ -64,7 +64,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Dessverre er det noen korrupte bildefiler i datasettet. Vi må gjøre en rask opprydding for å sjekke etter korrupte filer. For å unngå å overbelaste denne veiledningen, har vi flyttet koden for å verifisere datasettet inn i en modul.\n"
"Dessverre er det noen ødelagte bildefiler i datasettet. Vi må gjøre en rask opprydding for å sjekke etter korrupte filer. For å ikke ødelegge denne veiledningen, har vi flyttet koden for å verifisere datasettet til en modul.\n"
]
},
{
@ -335,11 +335,11 @@
"source": [
"## Laste inn datasettet\n",
"\n",
"I tidligere eksempler lastet vi inn datasett som er innebygd i Keras. Nå skal vi jobbe med vårt eget datasett, som vi må laste inn fra en katalog med bilder.\n",
"I tidligere eksempler lastet vi inn datasett som er innebygd i Keras. Nå skal vi håndtere vårt eget datasett, som vi må laste inn fra en mappe med bilder.\n",
"\n",
"I virkeligheten kan størrelsen på bildedatasett være ganske stor, og man kan ikke stole på at all data får plass i minnet. Derfor blir datasett ofte representert som **generatorer** som kan returnere data i minibatcher som er egnet for trening.\n",
"I virkeligheten kan bildedatasett være ganske store, og man kan ikke stole på at all data får plass i minnet. Derfor blir datasett ofte representert som **generatorer** som kan returnere data i minibatcher som egner seg for opplæring.\n",
"\n",
"For å håndtere bildeklassifisering inkluderer Keras en spesiell funksjon `image_dataset_from_directory`, som kan laste inn bilder fra underkataloger som tilsvarer forskjellige klasser. Denne funksjonen tar også hånd om skalering av bilder, og den kan også dele datasettet inn i trenings- og testundergrupper:\n"
"For å jobbe med bildeklassifisering, inkluderer Keras en spesiell funksjon `image_dataset_from_directory`, som kan laste bilder fra undermapper som tilsvarer forskjellige klasser. Denne funksjonen tar også seg av skalering av bilder, og kan også dele datasettet i trenings- og testdeler:\n"
]
},
{
@ -383,9 +383,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Det er viktig å sette samme `seed`-verdi for begge kallene, fordi det påvirker fordelingen av bilder mellom trenings- og testdatasettet.\n",
"Det er viktig å sette samme `seed`-verdi for begge kall, fordi det påvirker fordelingen av bilder mellom trenings- og testdatasettet.\n",
"\n",
"Datasettet henter automatisk klassenavn fra katalogene, og du kan få tilgang til dem ved behov ved å kalle:\n"
"Dataset henter automatisk klassenavn fra kataloger, og du kan få tilgang til dem om nødvendig ved å kalle:\n"
]
},
{
@ -412,7 +412,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Datasett som vi har fått tak i kan direkte sendes til `fit`-funksjonen for å trene modellen. De inneholder både tilsvarende bilder og etiketter, som kan itereres over ved hjelp av følgende konstruksjon:\n"
"Datasett som vi har skaffet kan sendes direkte til `fit`-funksjonen for å trene modellen. De inneholder både tilsvarende bilder og etiketter, som kan loopes over ved hjelp av følgende konstruksjon:\n"
]
},
{
@ -453,7 +453,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"> **Merk**: Alle bilder i datasettet er representert som flyttalls-tensorer med rekkevidde 0-255. Før vi sender dem til nevrale nettverk, må vi skalere disse verdiene til rekkevidde 0-1. Når vi plotter bilder, må vi enten gjøre det samme, eller konvertere verdiene til `int`-typen (som vi gjør i koden ovenfor), for å vise `matplotlib` at vi ønsker å plotte det originale uskalede bildet.\n"
"> **Merk**: Alle bildene i datasettet er representert som flyttallspunktstensorer med område 0-255. Før de sendes til det nevrale nettverket, må vi skalere disse verdiene til området 0-1. Når vi plotter bilder, må vi enten gjøre det samme, eller konvertere verdiene til typen `int` (slik vi gjør i koden over), for å vise `matplotlib` at vi ønsker å plotte det originale uskalte bildet.\n"
]
},
{
@ -462,7 +462,7 @@
"source": [
"## Forhåndstrente modeller\n",
"\n",
"For mange oppgaver innen bildeklassifisering kan man finne forhåndstrente nevrale nettverksmodeller. Mange av disse modellene er tilgjengelige innenfor `keras.applications`-navnet, og enda flere modeller kan finnes på Internett. La oss se hvordan den enkleste VGG-16-modellen kan lastes inn og brukes:\n"
"For mange bildeklassifiseringsoppgaver kan man finne forhåndstrente nevrale nettverksmodeller. Mange av disse modellene er tilgjengelige inne i `keras.applications` navnerommet, og enda flere modeller kan finnes på Internett. La oss se hvordan den enkleste VGG-16 modellen kan lastes inn og brukes:\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,11 +520,10 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Det er et par viktige ting å merke seg her:\n",
"\n",
"* Før du sender en input til et forhåndstrent nettverk, må den forhåndsbehandles på en bestemt måte. Dette gjøres ved å kalle den tilsvarende `preprocess_input`-funksjonen, som mottar en batch med bilder og returnerer deres bearbeidede form. I tilfellet med VGG-16 blir bildene normalisert, og en forhåndsdefinert gjennomsnittsverdi for hver kanal blir trukket fra. Dette er fordi VGG-16 opprinnelig ble trent med denne forhåndsbehandlingen.\n",
"* Det nevrale nettverket brukes på input-batchen, og som resultat får vi en batch med 1000-elementers tensorer som viser sannsynligheten for hver klasse. Vi kan finne nummeret på den mest sannsynlige klassen ved å kalle `argmax` på denne tensoren.\n",
"* Resultatet vi får er et [nummer for en `ImageNet`-klasse](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). For å forstå dette resultatet kan vi også bruke `decode_predictions`-funksjonen, som returnerer de n øverste klassene sammen med navnene deres.\n"
"Det er et par viktige ting her:\n",
"* Før man sender et input til et hvilken som helst forhåndstrent nettverk, må det pre-prosesseres på en bestemt måte. Dette gjøres ved å kalle den tilsvarende `preprocess_input`-funksjonen, som mottar en batch med bilder, og returnerer deres bearbeidede form. I tilfelle av VGG-16 blir bildene normalisert, og en forhåndsdefinert gjennomsnittsverdi for hver kanal blir trukket fra. Dette er fordi VGG-16 opprinnelig ble trent med denne pre-prosesseringsmetoden.\n",
"* Nevralt nettverk blir anvendt på input-batchen, og vi mottar som resultat en batch med 1000-element tensorer som viser sannsynligheten for hver klasse. Vi kan finne det mest sannsynlige klassenummeret ved å kalle `argmax` på denne tensoren.\n",
"* Det oppnådde resultatet er et [nummer for en `ImageNet`-klasse](https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a). For å gi mening til dette resultatet kan vi også bruke `decode_predictions`-funksjonen, som returnerer de topp n klassene sammen med deres navn.\n"
]
},
{
@ -600,7 +609,7 @@
"source": [
"## GPU-beregninger\n",
"\n",
"Dype nevrale nettverk, som VGG-16 og andre mer moderne arkitekturer, krever betydelig beregningskraft for å kjøre. Det er fornuftig å bruke GPU-akselerasjon hvis det er tilgjengelig. Heldigvis akselererer Keras automatisk beregningene på GPU hvis den er tilgjengelig. Vi kan sjekke om Tensorflow kan bruke GPU ved å bruke følgende kode:\n"
"Dype nevrale nettverk, slik som VGG-16 og andre mer moderne arkitekturer, krever ganske mye beregningskraft for å kjøre. Det gir mening å bruke GPU-akselerasjon hvis det er tilgjengelig. Heldigvis akselererer Keras automatisk beregningene på GPU-en hvis det er tilgjengelig. Vi kan sjekke om Tensorflow er i stand til å bruke GPU med følgende kode:\n"
]
},
{
@ -627,9 +636,10 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"## Ekstrahere VGG-funksjoner\n",
"\n",
"Hvis vi ønsker å bruke VGG-16 for å ekstrahere funksjoner fra bildene våre, trenger vi modellen uten de siste klassifiseringslagene. Vi kan opprette VGG-16-modellen uten topplagene ved å bruke denne koden:\n"
"Hvis vi ønsker å bruke VGG-16 for å ekstrahere funksjoner fra bildene våre, trenger vi modellen uten de siste klassifiseringslagene. Vi kan opprette en VGG-16-modell uten topp-lag ved å bruke denne koden:\n"
]
},
{
@ -681,9 +691,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Dimensjonen til funksjonstensoren er 7x7x512, men for å visualisere den måtte vi omforme den til en 2D-form.\n",
"Dimensjonen til feature-tensoren er 7x7x512, men for å kunne visualisere den måtte vi omforme den til 2D-form.\n",
"\n",
"La oss nå prøve å se om disse funksjonene kan brukes til å klassifisere bilder. Vi tar manuelt en del av bildene (50 minibatcher, i vårt tilfelle) og forhåndsberegner deres funksjonsvektorer. Vi kan bruke Tensorflow **dataset** API for å gjøre dette. `map`-funksjonen tar et datasett og anvender en gitt lambda-funksjon for å transformere det. Vi bruker denne mekanismen til å konstruere nye datasett, `ds_features_train` og `ds_features_test`, som inneholder VGG-ekstraherte funksjoner i stedet for de originale bildene.\n"
"Nå skal vi prøve å se om disse features kan brukes til å klassifisere bilder. La oss manuelt ta en delvis andel av bilder (50 minibatcher, i vårt tilfelle), og forhåndsberegne deres feature-vektorer. Vi kan bruke Tensorflow **dataset** API for å gjøre det. `map`-funksjonen tar et datasett og anvender en gitt lambda-funksjon for å transformere det. Vi bruker denne mekanismen for å konstruere nye datasett, `ds_features_train` og `ds_features_test`, som inneholder VGG-ekstraherte features i stedet for originale bilder.\n"
]
},
{
@ -713,9 +723,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Vi brukte konstruksjonen `.take(50)` for å begrense datasettstørrelsen, for å gjøre demonstrasjonen raskere. Du kan selvfølgelig utføre dette eksperimentet på hele datasettet.\n",
"Vi brukte konstruksjonen `.take(50)` for å begrense datasettstørrelsen, for å akselerere demonstrasjonen vår. Du kan selvfølgelig utføre dette eksperimentet på hele datasettet.\n",
"\n",
"Nå som vi har et datasett med uttrukne egenskaper, kan vi trene en enkel tett klassifiserer for å skille mellom katter og hunder. Dette nettverket vil ta en egenskapsvektor med formen (7,7,512) og produsere én output som tilsvarer enten en hund eller en katt. Siden det er en binær klassifisering, bruker vi `sigmoid` aktiveringsfunksjon og `binary_crossentropy` tap.\n"
"Nå som vi har et datasett med uttrukne egenskaper, kan vi trene en enkel tett klassifiserer for å skille mellom katter og hunder. Dette nettverket vil ta en egenskapsvektor med formen (7,7,512), og produsere én utgang som tilsvarer enten en hund eller en katt. Fordi det er en binær klassifisering, bruker vi `sigmoid` aktiveringsfunksjon og `binary_crossentropy` tap.\n"
]
},
{
@ -744,13 +754,13 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Resultatet er fantastisk, vi kan skille mellom en katt og en hund med nesten 95% sannsynlighet! Men vi har kun testet denne tilnærmingen på et utvalg av alle bildene, fordi manuell funksjonsuttrekking ser ut til å ta mye tid.\n",
"Resultatet er flott, vi kan skille mellom en katt og en hund med nesten 95 % sannsynlighet! Imidlertid har vi kun testet denne tilnærmingen på et utvalg av alle bildene, fordi manuell funksjonsutvinning ser ut til å ta mye tid.\n",
"\n",
"## Overføringslæring ved bruk av én VGG-nettverk\n",
"## Transfer learning ved bruk av ett VGG-nettverk\n",
"\n",
"Vi kan også unngå å manuelt forhåndsberegne funksjonene ved å bruke det originale VGG-16-nettverket som en helhet under trening, ved å legge til en funksjonsuttrekker som første lag i nettverket vårt.\n",
"Vi kan også unngå manuell forhåndsberegning av funksjonene ved å bruke det originale VGG-16-nettverket som helhet under trening, ved å legge til funksjonsutvinner som det første laget i nettverket vårt. \n",
"\n",
"Det fine med Keras-arkitekturen er at VGG-16-modellen vi har definert ovenfor også kan brukes som et lag i et annet nevralt nettverk! Vi trenger bare å konstruere et nettverk med en tett klassifiserer på toppen av det, og deretter trene hele nettverket ved hjelp av tilbakepropagering.\n"
"Det fine med Keras-arkitekturen er at VGG-16-modellen som vi har definert ovenfor også kan brukes som et lag i et annet nevralt nettverk! Vi trenger bare å bygge et nettverk med en tett klassifiserer oppå dette, og deretter trene hele nettverket ved bruk av backpropagation.\n"
]
},
{
@ -794,13 +804,13 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Denne modellen ser ut som et ende-til-ende klassifiseringsnettverk, som tar et bilde og returnerer klassen. Det vanskelige her er imidlertid at vi ønsker at VGG16 skal fungere som en funksjonsekstraktor, og ikke bli trent på nytt. Derfor må vi **fryse vektene til den konvolusjonelle funksjonsekstraktoren**. Vi kan få tilgang til det første laget i nettverket ved å kalle `model.layers[0]`, og vi trenger bare å sette egenskapen `trainable` til `False`.\n",
"Denne modellen ser ut som et ende-til-ende klassifiseringsnettverk, som tar et bilde og returnerer klassen. Den vanskelige tingen er imidlertid at vi ønsker at VGG16 skal fungere som en funksjonsuttrekker, og ikke trenes på nytt. Derfor må vi **fryse vektene til den konvolusjonelle funksjonsuttrekkeren**. Vi kan få tilgang til det første laget i nettverket ved å kalle `model.layers[0]`, og vi trenger bare å sette `trainable`-egenskapen til `False`.\n",
"\n",
"> **Note**: Frysing av vektene til funksjonsekstraktoren er nødvendig, fordi ellers kan det utrente klassifiseringslaget ødelegge de opprinnelige forhåndstrente vektene til den konvolusjonelle ekstraktoren.\n",
"> **Merk**: Frysning av vektene til funksjonsuttrekkeren er nødvendig, fordi ellers kan det utrente klassifiseringslaget ødelegge de opprinnelige forhåndstrente vektene til konvolusjonsuttrekkeren.\n",
"\n",
"Du kan legge merke til at selv om det totale antallet parametere i nettverket vårt er rundt 15 millioner, trener vi bare 25 000 parametere. Alle andre parametere i de øverste konvolusjonsfiltrene er forhåndstrente. Det er bra, fordi vi kan finjustere et mindre antall parametere med et mindre antall eksempler.\n",
"Du kan legge merke til at selv om det totale antallet parametere i nettverket vårt er rundt 15 millioner, trener vi bare 25k parametere. Alle andre parametere i toppnivåets konvolusjonsfiltre er forhåndstrent. Det er bra, fordi vi kan finjustere et mindre antall parametere med et mindre antall eksempler.\n",
"\n",
"Vi skal nå trene nettverket vårt og se hvor bra vi kan få det til. Forvent ganske lang kjøretid, og ikke bekymre deg hvis det ser ut som om utførelsen har fryst en stund.\n"
"Vi skal nå trene nettverket vårt og se hvor godt vi kan få det til. Forvent en ganske lang kjøretid, og ikke bekymre deg hvis utføringen ser ut til å fryse en stund.\n"
]
},
{
@ -825,11 +835,11 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Det ser ut som vi har fått en ganske nøyaktig klassifiserer for katter vs. hunder!\n",
"Det ser ut som vi har fått en rimelig nøyaktig katter mot hunder-klassifiserer! \n",
"\n",
"## Lagre og laste inn modellen\n",
"## Lagre og laste modellen\n",
"\n",
"Når vi har trent modellen, kan vi lagre modellarkitekturen og de trente vektene til en fil for fremtidig bruk:\n"
"Når vi har trent modellen, kan vi lagre modellarkitektur og trente vekter til en fil for fremtidig bruk:\n"
]
},
{
@ -853,7 +863,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Vi kan deretter laste modellen fra fil når som helst. Du kan finne det nyttig i tilfelle det neste eksperimentet ødelegger modellen - du slipper å starte helt fra begynnelsen.\n"
"Vi kan da laste inn modellen fra fil når som helst. Det kan være nyttig hvis neste eksperiment ødelegger modellen - da slipper du å starte helt på nytt.\n"
]
},
{
@ -869,15 +879,15 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"## Finjustering av overføringslæring\n",
"## Finjustering av transfer learning\n",
"\n",
"I forrige seksjon har vi trent det siste klassifiseringslaget til å klassifisere bilder i vårt eget datasett. Imidlertid har vi ikke trent opp funksjonsekstraktoren på nytt, og modellen vår har basert seg på funksjonene som modellen har lært fra ImageNet-data. Hvis objektene dine visuelt skiller seg fra vanlige ImageNet-bilder, kan denne kombinasjonen av funksjoner kanskje ikke fungere optimalt. Derfor gir det mening å begynne å trene de konvolusjonelle lagene også.\n",
"I forrige seksjon trente vi det siste klassifiseringslaget for å klassifisere bilder i vårt eget datasett. Vi trente derimot ikke om funksjonsuttrekkeren, og modellen vår baserte seg på funksjonene som modellen hadde lært fra ImageNet-data. Hvis objektene dine visuelt skiller seg fra vanlige ImageNet-bilder, kan denne kombinasjonen av funksjoner kanskje ikke fungere best. Derfor gir det mening å starte treningen av konvolusjonslag også.\n",
"\n",
"For å gjøre dette kan vi oppheve frysing av parameterne til de konvolusjonelle filtrene som vi tidligere har fryst.\n",
"For å gjøre det kan vi frigjøre konvolusjonsfilterparameterne som vi tidligere har frosset.\n",
"\n",
"> **Merk:** Det er viktig at du først fryser parameterne og utfører flere epoker med trening for å stabilisere vektene i klassifiseringslaget. Hvis du umiddelbart starter trening av hele nettverket med ufryste parametere, er det stor sannsynlighet for at store feil ødelegger de forhåndstrente vektene i de konvolusjonelle lagene.\n",
"> **Merk:** Det er viktig at du fryser parameterne først og utfører flere trenings-epoker for å stabilisere vektene i klassifiseringslaget. Hvis du umiddelbart begynner å trene hele nettverket med ufryste parametere, er det stor sannsynlighet for at store feil vil ødelegge de forhåndstrente vektene i konvolusjonslagene.\n",
"\n",
"Vår konvolusjonelle VGG-16-modell er plassert i det første laget, og den består av mange lag i seg selv. Vi kan ta en titt på strukturen:\n"
"Vår konvolusjonelle VGG-16-modell er plassert inni det første laget, og den består selv av mange lag. Vi kan ta en titt på strukturen dens:\n"
]
},
{
@ -945,7 +955,9 @@
{
"cell_type": "markdown",
"metadata": {},
"source": []
"source": [
"Vi kan frigjøre alle lag av konvolusjonsbasen:\n"
]
},
{
"cell_type": "code",
@ -960,7 +972,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Men å tine opp alle samtidig er ikke den beste ideen. Vi kan først tine opp bare noen få siste lag med konvolusjoner, fordi de inneholder høyere nivå mønstre som er relevante for bildene våre. For eksempel, til å begynne med, kan vi fryse alle lag unntatt de siste 4:\n"
"Det er imidlertid ikke den beste ideen å tine opp alle på en gang. Vi kan først tine opp bare et par av de siste konvolusjonslagene, fordi de inneholder mer komplekse mønstre som er relevante for bildene våre. For eksempel kan vi begynne med å fryse alle lag bortsett fra de siste 4: \n"
]
},
{
@ -999,11 +1011,11 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Observer at antallet trenbare parametere økte betydelig, men det er fortsatt rundt 50 % av alle parametere.\n",
"Legg merke til at antallet trenbare parametere økte betydelig, men det er fortsatt rundt 50 % av alle parametere.\n",
"\n",
"Etter at vi har låst opp, kan vi kjøre noen få flere epoker med trening (i vårt eksempel vil vi bare kjøre én). Du kan også velge en lavere læringsrate for å minimere påvirkningen på de forhåndstrente vektene. Likevel, selv med lav læringsrate, kan du forvente at nøyaktigheten synker i starten av treningen, før den til slutt når et litt høyere nivå enn i tilfellet med faste vekter.\n",
"Etter å ha frigjort, kan vi kjøre noen flere epoker med trening (i vårt eksempel gjør vi bare én). Du kan også velge lavere læringsrate for å minimere påvirkningen på de forhåndstrente vektene. Selv med lav læringsrate kan du imidlertid forvente at nøyaktigheten faller i begynnelsen av treningen, før den til slutt når et litt høyere nivå enn i tilfellet med faste vekter.\n",
"\n",
"> **Merk:** Denne treningen går mye tregere, fordi vi må propagere gradienter tilbake gjennom mange lag i nettverket!\n"
"> **Merk:** Denne treningen skjer mye tregere, fordi vi må propagere gradienter tilbake gjennom mange lag i nettverket!\n"
]
},
{
@ -1027,18 +1039,18 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Vi vil sannsynligvis oppnå høyere treningsnøyaktighet, fordi vi bruker et mer kraftfullt nettverk med flere parametere, men valideringsnøyaktigheten vil ikke øke like mye.\n",
"Vi vil sannsynligvis oppnå høyere treningsnøyaktighet, fordi vi bruker et kraftigere nettverk med flere parametere, men valideringsnøyaktigheten vil ikke øke like mye.\n",
"\n",
"Du kan gjerne låse opp noen flere lag i nettverket og trene mer, for å se om du klarer å oppnå høyere nøyaktighet!\n"
"Føl deg fri til å låse opp noen flere lag i nettverket og trene mer, for å se om du kan oppnå høyere nøyaktighet!\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Andre modeller for datamaskinsyn\n",
"## Andre datavisjonsmodeller\n",
"\n",
"VGG-16 er en av de enkleste arkitekturene for datamaskinsyn. Keras tilbyr mange flere forhåndstrente nettverk. De mest brukte blant disse er **ResNet**-arkitekturer, utviklet av Microsoft, og **Inception** fra Google. For eksempel, la oss utforske arkitekturen til den enkleste ResNet-50-modellen (ResNet er en familie av modeller med ulik dybde, du kan prøve å eksperimentere med ResNet-152 hvis du vil se hvordan en virkelig dyp modell ser ut):\n"
"VGG-16 er en av de enkleste datavisjonsarkitekturene. Keras tilbyr mange flere forhåndstrente nettverk. De mest brukte blant disse er **ResNet**-arkitekturene, utviklet av Microsoft, og **Inception** av Google. For eksempel, la oss utforske arkitekturen til den enkleste ResNet-50-modellen (ResNet er en familie av modeller med ulik dybde, du kan prøve å eksperimentere med ResNet-152 hvis du vil se hvordan en virkelig dyp modell ser ut):\n"
]
},
{
@ -1440,29 +1452,29 @@
"cell_type": "markdown",
"metadata": {},
"source": [
"Som du kan se, inneholder modellen de samme kjente byggeklossene: konvolusjonslag, pooling-lag og en endelig tett klassifiserer. Vi kan bruke denne modellen på nøyaktig samme måte som vi har brukt VGG-16 for transfer learning. Du kan prøve å eksperimentere med koden ovenfor, ved å bruke forskjellige ResNet-modeller som basismodell, og se hvordan nøyaktigheten endrer seg.\n",
"Som du kan se, inneholder modellen de samme kjente byggeklossene: konvolusjonslag, poolinglag og endelig tett klassifiserer. Vi kan bruke denne modellen på nøyaktig samme måte som vi har brukt VGG-16 for overføringslæring. Du kan prøve å eksperimentere med koden ovenfor, bruke forskjellige ResNet-modeller som basismodell, og se hvordan nøyaktigheten endres.\n",
"\n",
"## Batch Normalisering\n",
"## Batch Normalization\n",
"\n",
"Dette nettverket inneholder enda en type lag: **Batch Normalisering**. Ideen bak batch normalisering er å bringe verdiene som flyter gjennom det nevrale nettverket til riktig intervall. Vanligvis fungerer nevrale nettverk best når alle verdier er i området [-1,1] eller [0,1], og det er grunnen til at vi skalerer/normaliserer våre inngangsdata deretter. Under trening av et dypt nettverk kan det imidlertid skje at verdiene kommer betydelig utenfor dette området, noe som gjør treningen problematisk. Batch normaliseringslaget beregner gjennomsnitt og standardavvik for alle verdiene i den nåværende minibatchen, og bruker dem til å normalisere signalet før det sendes gjennom et nevralt nettverkslag. Dette forbedrer stabiliteten til dype nettverk betydelig.\n"
"Dette nettverket inneholder enda en type lag: **Batch Normalization**. Ideen med batch normalisering er å bringe verdier som flyter gjennom det nevrale nettverket til riktig intervall. Vanligvis fungerer nevrale nettverk best når alle verdier er i området [-1,1] eller [0,1], og det er grunnen til at vi skalerer/normaliserer inngangsdataene våre deretter. Men under trening av et dypt nettverk kan det skje at verdier beveger seg betydelig utenfor dette området, noe som gjør treningen problematisk. Batch normaliseringslaget beregner gjennomsnitt og standardavvik for alle verdiene i det nåværende minibatchen, og bruker dem til å normalisere signalet før det sendes gjennom et nevralt netverkslag. Dette forbedrer stabiliteten til dype nettverk betydelig.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Hovedpoeng\n",
"## Oppsummering\n",
"\n",
"Ved å bruke transfer learning kunne vi raskt sette sammen en klassifiserer for vår tilpassede objektklassifiseringsoppgave og oppnå høy nøyaktighet. Dette eksempelet var imidlertid ikke helt rettferdig, fordi det originale VGG-16-nettverket var forhåndstrent til å gjenkjenne katter og hunder, og vi gjenbrukte derfor de fleste mønstrene som allerede var til stede i nettverket. Du kan forvente lavere nøyaktighet på mer eksotiske, domenespesifikke objekter, som detaljer på produksjonslinjen i en fabrikk eller ulike treblader.\n",
"Ved å bruke transfer learning kunne vi raskt sette sammen en klassifiserer for vår egendefinerte objektklassifiseringsoppgave og oppnå høy nøyaktighet. Dette eksempelet var imidlertid ikke helt rettferdig, fordi det opprinnelige VGG-16-nettverket var forhåndstrent til å gjenkjenne katter og hunder, og dermed gjenbrukte vi bare mesteparten av mønstrene som allerede var til stede i nettverket. Du kan forvente lavere nøyaktighet på mer eksotiske domene-spesifikke objekter, som detaljer på produksjonslinjen i en fabrikk, eller forskjellige tresorter.\n",
"\n",
"Du kan se at mer komplekse oppgaver som vi løser nå krever høyere datakraft og ikke enkelt kan løses på CPU. I neste enhet vil vi prøve å bruke en mer lettvektsimplementasjon for å trene den samme modellen med lavere datakraft, noe som resulterer i bare litt lavere nøyaktighet.\n"
"Du kan se at mer komplekse oppgaver som vi løser nå krever høyere beregningskraft, og ikke enkelt kan løses på CPU. I neste enhet vil vi prøve å bruke en mer lettvekts implementasjon for å trene den samme modellen med lavere beregningsressurser, noe som resulterer i bare litt lavere nøyaktighet.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n---\n\n**Ansvarsfraskrivelse**: \nDette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.\n"
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**Ansvarsfraskrivelse**:\nDette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det opprinnelige dokumentet på originalspråket skal betraktes som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
]
}
],
@ -1483,12 +1495,6 @@
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.10"
},
"coopTranslator": {
"original_hash": "c189abc107848f96051085cc30945129",
"translation_date": "2025-08-28T16:30:57+00:00",
"source_file": "lessons/4-ComputerVision/08-TransferLearning/TransferLearningTF.ipynb",
"language_code": "no"
}
},
"nbformat": 4,

78
translations/no/lessons/5-NLP/README.md
View File

@ -1,51 +1,51 @@
# Naturlig Språkbehandling
![Oppsummering av NLP-oppgaver i en skisse](../../../../translated_images/no/ai-nlp.b22dcb8ca4707cea.webp)
![Oppsummering av NLP-oppgaver i en tegning](../../../../translated_images/no/ai-nlp.b22dcb8ca4707cea.webp)
I denne delen vil vi fokusere på å bruke nevrale nettverk for å håndtere oppgaver relatert til **Naturlig Språkbehandling (NLP)**. Det finnes mange NLP-problemer vi ønsker at datamaskiner skal kunne løse:
I denne seksjonen vil vi fokusere på å bruke nevrale nettverk for å håndtere oppgaver relatert til **Naturlig Språkbehandling (NLP)**. Det finnes mange NLP-problemer vi ønsker at datamaskiner skal kunne løse:
* **Tekstklassifisering** er et typisk klassifiseringsproblem som gjelder tekstsekvenser. Eksempler inkluderer å klassifisere e-postmeldinger som spam eller ikke-spam, eller å kategorisere artikler som sport, økonomi, politikk osv. Når vi utvikler chatboter, må vi ofte forstå hva en bruker ønsker å si – i dette tilfellet håndterer vi **intensjonsklassifisering**. Ofte må vi i intensjonsklassifisering håndtere mange kategorier.
* **Sentimentanalyse** er et typisk regresjonsproblem, der vi må tilordne et tall (et sentiment) som tilsvarer hvor positivt/negativt meningen med en setning er. En mer avansert versjon av sentimentanalyse er **aspektbasert sentimentanalyse** (ABSA), der vi tilordner sentiment ikke til hele setningen, men til ulike deler av den (aspekter), f.eks. *På denne restauranten likte jeg maten, men atmosfæren var forferdelig*.
* **Navngitt enhetsgjenkjenning** (NER) refererer til problemet med å trekke ut visse enheter fra tekst. For eksempel kan vi trenge å forstå at i setningen *Jeg må fly til Paris i morgen* refererer ordet *i morgen* til DATO, og *Paris* er en LOKASJON.
* **Nøkkelorduttrekking** ligner på NER, men vi må automatisk trekke ut ord som er viktige for meningen med setningen, uten forhåndstrening for spesifikke enhetstyper.
* **Tekstklustering** kan være nyttig når vi ønsker å gruppere sammen lignende setninger, for eksempel lignende forespørsler i tekniske support-samtaler.
* **Spørsmål og svar** refererer til en modells evne til å svare på et spesifikt spørsmål. Modellen mottar en tekstpassasje og et spørsmål som input, og den må angi et sted i teksten der svaret på spørsmålet finnes (eller, noen ganger, generere selve svaret).
* **Tekstgenerering** er en modells evne til å generere ny tekst. Det kan betraktes som en klassifiseringsoppgave som forutsier neste bokstav/ord basert på en *tekstprompt*. Avanserte tekstgenereringsmodeller, som GPT-3, kan løse andre NLP-oppgaver som klassifisering ved hjelp av en teknikk kalt [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).
* **Tekstoppsummering** er en teknikk der vi ønsker at en datamaskin skal "lese" lang tekst og oppsummere den i noen få setninger.
* **Maskinoversettelse** kan sees på som en kombinasjon av tekstforståelse på ett språk og tekstgenerering på et annet.
* **Tekstklassifisering** er et typisk klassifiseringsproblem knyttet til tekstsekvenser. Eksempler inkluderer å klassifisere e-postmeldinger som spam vs. ikke-spam, eller kategorisere artikler som sport, næringsliv, politikk, osv. Også når man utvikler chatteboter, trenger man ofte å forstå hva en bruker ønsket å si – i dette tilfellet håndterer vi **intensjonsklassifisering**. Ofte i intensjonsklassifisering må man håndtere mange kategorier.
* **Sentimentanalyse** er et typisk regresjonsproblem, hvor vi må tilordne et tall (et sentiment) som tilsvarer hvor positivt/negativt meningen i en setning er. En mer avansert versjon av sentimentanalyse er **aspektbasert sentimentanalyse** (ABSA), hvor vi tilordner sentiment ikke til hele setningen, men til forskjellige deler av den (aspekter), f.eks. *I denne restauranten likte jeg maten, men atmosfæren var forferdelig*.
* **Navngitt enhetsgjenkjenning** (NER) refererer til problemet med å trekke ut bestemte enheter fra tekst. For eksempel kan vi trenge å forstå at i uttrykket *Jeg må fly til Paris i morgen* refererer ordet *i morgen* til DATO, og *Paris* er et STED.
* **Nøkkelorduttrekk** er likt NER, men vi må automatisk trekke ut ord som er viktige for meningen i setningen, uten forhåndstrening for spesifikke enhetstyper.
* **Tekstgruppering** kan være nyttig når vi ønsker å gruppere sammen lignende setninger, for eksempel lignende forespørsler i teknisk support-konversasjoner.
* **Spørsmål og svar** refererer til en modells evne til å svare på et spesifikt spørsmål. Modellen mottar en tekstpassasje og et spørsmål som input, og må finne et sted i teksten hvor svaret på spørsmålet finnes (eller noen ganger generere svaret som tekst).
* **Tekstgenerering** er evnen til at en modell kan generere ny tekst. Det kan betraktes som en klassifiseringsoppgave som predikerer neste bokstav/ord basert på et *tekstprompt*. Avanserte modeller for tekstgenerering, som GPT-3, kan løse andre NLP-oppgaver som klassifisering ved hjelp av en teknikk kalt [promptprogrammering](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)
* **Tekstoppsummering** er en teknikk hvor vi ønsker at en datamaskin skal "lese" lang tekst og oppsummere den i noen få setninger.
* **Maskinoversettelse** kan sees på som en kombinasjon av tekstforståelse på ett språk og tekstgenerering på et annet språk.
Opprinnelig ble de fleste NLP-oppgaver løst ved hjelp av tradisjonelle metoder som grammatikk. For eksempel ble det i maskinoversettelse brukt parsere for å transformere en opprinnelig setning til et syntakstre, deretter ble høyere nivå semantiske strukturer hentet ut for å representere meningen med setningen, og basert på denne meningen og grammatikken til målspråket ble resultatet generert. I dag løses mange NLP-oppgaver mer effektivt ved hjelp av nevrale nettverk.
I begynnelsen ble de fleste NLP-oppgaver løst ved hjelp av tradisjonelle metoder som grammatikk. For eksempel, i maskinoversettelse ble parser brukt for å omdanne setninger til et syntakstre, deretter ble høyere semantiske strukturer uttrukket for å representere setningens mening, og basert på denne betydningen og målrettsspråkets grammatikk ble resultatet generert. I dag løses mange NLP-oppgaver mer effektivt ved hjelp av nevrale nettverk.
> Mange klassiske NLP-metoder er implementert i Python-biblioteket [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org). Det finnes en flott [NLTK-bok](https://www.nltk.org/book/) tilgjengelig online som dekker hvordan ulike NLP-oppgaver kan løses ved hjelp av NLTK.
> Mange klassiske NLP-metoder er implementert i [Natural Language Processing Toolkit (NLTK)](https://www.nltk.org) Python-biblioteket. Det finnes en flott [NLTK-bok](https://www.nltk.org/book/) tilgjengelig online som dekker hvordan forskjellige NLP-oppgaver kan løses ved hjelp av NLTK.
I dette kurset vil vi hovedsakelig fokusere på å bruke nevrale nettverk for NLP, og vi vil bruke NLTK der det er nødvendig.
I vårt kurs vil vi hovedsakelig fokusere på å bruke nevrale nettverk for NLP, og vi vil bruke NLTK der det er nødvendig.
Vi har allerede lært om å bruke nevrale nettverk for å håndtere tabulardata og bilder. Den største forskjellen mellom disse datatypene og tekst er at tekst er en sekvens med variabel lengde, mens inputstørrelsen i tilfelle bilder er kjent på forhånd. Selv om konvolusjonsnettverk kan trekke ut mønstre fra inputdata, er mønstre i tekst mer komplekse. For eksempel kan negasjon være adskilt fra subjektet med et vilkårlig antall ord (f.eks. *Jeg liker ikke appelsiner* vs. *Jeg liker ikke de store fargerike smakfulle appelsinene*), og det bør fortsatt tolkes som ett mønster. Derfor trenger vi nye typer nevrale nettverk for å håndtere språk, som *rekurrente nettverk* og *transformatorer*.
Vi har allerede lært om bruk av nevrale nettverk for behandling av tabulære data og bilder. Hovedforskjellen mellom disse datatypene og tekst er at tekst er en sekvens med variabel lengde, mens inngangsstørrelsen i tilfelle bilder er kjent på forhånd. Mens konvolusjonsnettverk kan trekke ut mønstre fra inngangsdata, er mønstrene i tekst mer komplekse. For eksempel kan negasjon være atskilt fra subjektet av et vilkårlig antall ord (f.eks. *Jeg liker ikke appelsiner* vs. *Jeg liker ikke de store fargerike smakfulle appelsinene*), og det skal fortsatt tolkes som ett mønster. Derfor trenger vi nye typer nevrale nettverk for å håndtere språk, slik som *rekurrente nettverk* og *transformere*.
## Installere Biblioteker
## Installer biblioteker
Hvis du bruker en lokal Python-installasjon for å kjøre dette kurset, kan det hende du må installere alle nødvendige biblioteker for NLP ved hjelp av følgende kommandoer:
Hvis du bruker lokal Python-installasjon for å kjøre dette kurset, kan det hende du må installere alle nødvendige biblioteker for NLP ved å bruke 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
## GPU-advarsel
I denne delen vil vi i noen av eksemplene trene ganske store modeller.
* **Bruk en datamaskin med GPU**: Det anbefales å kjøre notatbøkene dine på en datamaskin med GPU for å redusere ventetiden når du arbeider med store modeller.
* **Begrensninger i GPU-minne**: Å kjøre på en GPU kan føre til situasjoner der du går tom for GPU-minne, spesielt når du trener store modeller.
* **GPU-minneforbruk**: Mengden GPU-minne som forbrukes under trening avhenger av ulike faktorer, inkludert minibatch-størrelsen.
* **Minimer minibatch-størrelse**: Hvis du opplever problemer med GPU-minne, vurder å redusere minibatch-størrelsen i koden din som en mulig løsning.
* **TensorFlow GPU-minnefrigjøring**: Eldre versjoner av TensorFlow kan ha problemer med å frigjøre GPU-minne riktig når du trener flere modeller i én Python-kjerne. For å håndtere GPU-minnebruk effektivt kan du konfigurere TensorFlow til å allokere GPU-minne kun etter behov.
* **Kodeinkludering**: For å sette opp TensorFlow til å vokse GPU-minneallokering kun når det er nødvendig, inkluder følgende kode i notatbøkene dine:
I denne seksjonen vil vi i noen av eksemplene trene ganske store modeller.
* **Bruk en datamaskin med GPU**: Det anbefales å kjøre notatbøkene dine på en datamaskin med GPU for å redusere ventetider når du jobber med store modeller.
* **GPU-minnebegrensninger**: Kjøring på GPU kan føre til situasjoner hvor du går tom for GPU-minne, spesielt når du trener store modeller.
* **Forbruk av GPU-minne**: Mengden GPU-minne som brukes under trening avhenger av forskjellige faktorer, inkludert minibatch-størrelse.
* **Minimer minibatch-størrelse**: Hvis du opplever problemer med GPU-minne, vurder å redusere minibatch-størrelsen i koden din som en potensiell løsning.
* **Frigjøring av GPU-minne i TensorFlow**: Eldre versjoner av TensorFlow frigjør kanskje ikke GPU-minne korrekt når flere modeller trenes i én Python-kjerne. For å håndtere GPU-minnebruk effektivt kan du konfigurere TensorFlow til å tildele GPU-minne bare etter behov.
* **Inkludering av kode**: For å sette TensorFlow til å gradvis øke GPU-minnetildeling kun etter behov, inkluder følgende kode i notatbøkene dine:
```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 interessert i å lære om NLP fra et klassisk maskinlæringsperspektiv, besøk [denne samlingen av leksjoner](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP).
Hvis du er interessert i å lære om NLP fra et klassisk ML-perspektiv, besøk [dette settet med leksjoner](https://github.com/microsoft/ML-For-Beginners/tree/main/6-NLP)
## I denne delen
I denne delen skal vi lære om:
## I denne seksjonen
I denne seksjonen skal vi lære om:
* [Representere tekst som tensorer](13-TextRep/README.md)
* [Ord-embedding](14-Emdeddings/README.md)
* [Representasjon av tekst som tensorer](13-TextRep/README.md)
* [Ordinnstikk](14-Emdeddings/README.md)
* [Språkmodellering](15-LanguageModeling/README.md)
* [Rekurrente nevrale nettverk](16-RNN/README.md)
* [Generative nettverk](17-GenerativeNetworks/README.md)
* [Transformatorer](18-Transformers/README.md)
* [Transformere](18-Transformers/README.md)
---
**Ansvarsfraskrivelse**:
Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Ansvarsfraskrivelse**:
Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det opprinnelige dokumentet på originalspråket skal betraktes som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->