Merge pull request #860 from microsoft/update-translations
🌐 Update translations via Co-op Translator
pull/861/head
Lee Stott
2 weeks ago
committed by
GitHub
commit
46bad61715
@ -0,0 +1,159 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "69389392fa6346e0dfa30f664b7b6fec",
|
||||
"translation_date": "2025-09-05T21:43:11+00:00",
|
||||
"source_file": "1-Introduction/1-intro-to-ML/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Introduksjon til maskinlæring
|
||||
|
||||
## [Quiz før forelesning](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
---
|
||||
|
||||
[](https://youtu.be/6mSx_KJxcHI "ML for nybegynnere - Introduksjon til maskinlæring for nybegynnere")
|
||||
|
||||
> 🎥 Klikk på bildet over for en kort video som går gjennom denne leksjonen.
|
||||
|
||||
Velkommen til dette kurset om klassisk maskinlæring for nybegynnere! Enten du er helt ny på dette temaet, eller en erfaren ML-praktiker som ønsker å friske opp kunnskapen, er vi glade for å ha deg med! Vi ønsker å skape et vennlig startpunkt for din ML-studie og vil gjerne evaluere, svare på og inkludere din [tilbakemelding](https://github.com/microsoft/ML-For-Beginners/discussions).
|
||||
|
||||
[](https://youtu.be/h0e2HAPTGF4 "Introduksjon til ML")
|
||||
|
||||
> 🎥 Klikk på bildet over for en video: MITs John Guttag introduserer maskinlæring
|
||||
|
||||
---
|
||||
## Komme i gang med maskinlæring
|
||||
|
||||
Før du starter med dette pensumet, må du ha datamaskinen din satt opp og klar til å kjøre notatbøker lokalt.
|
||||
|
||||
- **Konfigurer maskinen din med disse videoene**. Bruk følgende lenker for å lære [hvordan du installerer Python](https://youtu.be/CXZYvNRIAKM) på systemet ditt og [setter opp en teksteditor](https://youtu.be/EU8eayHWoZg) for utvikling.
|
||||
- **Lær Python**. Det anbefales også å ha en grunnleggende forståelse av [Python](https://docs.microsoft.com/learn/paths/python-language/?WT.mc_id=academic-77952-leestott), et programmeringsspråk som er nyttig for dataforskere og som vi bruker i dette kurset.
|
||||
- **Lær Node.js og JavaScript**. Vi bruker også JavaScript noen ganger i dette kurset når vi bygger webapplikasjoner, så du må ha [node](https://nodejs.org) og [npm](https://www.npmjs.com/) installert, samt [Visual Studio Code](https://code.visualstudio.com/) tilgjengelig for både Python- og JavaScript-utvikling.
|
||||
- **Opprett en GitHub-konto**. Siden du fant oss her på [GitHub](https://github.com), har du kanskje allerede en konto, men hvis ikke, opprett en og deretter fork dette pensumet for å bruke det selv. (Gi oss gjerne en stjerne også 😊)
|
||||
- **Utforsk Scikit-learn**. Gjør deg kjent med [Scikit-learn](https://scikit-learn.org/stable/user_guide.html), et sett med ML-biblioteker som vi refererer til i disse leksjonene.
|
||||
|
||||
---
|
||||
## Hva er maskinlæring?
|
||||
|
||||
Begrepet 'maskinlæring' er et av de mest populære og ofte brukte begrepene i dag. Det er en betydelig sannsynlighet for at du har hørt dette begrepet minst én gang hvis du har en viss kjennskap til teknologi, uansett hvilket felt du jobber i. Mekanismene bak maskinlæring er imidlertid en gåte for de fleste. For en nybegynner innen maskinlæring kan emnet noen ganger føles overveldende. Derfor er det viktig å forstå hva maskinlæring faktisk er, og lære om det steg for steg, gjennom praktiske eksempler.
|
||||
|
||||
---
|
||||
## Hypekurven
|
||||
|
||||
|
||||
|
||||
> Google Trends viser den nylige 'hypekurven' for begrepet 'maskinlæring'
|
||||
|
||||
---
|
||||
## Et mystisk univers
|
||||
|
||||
Vi lever i et univers fullt av fascinerende mysterier. Store vitenskapsmenn som Stephen Hawking, Albert Einstein og mange flere har viet sine liv til å søke etter meningsfull informasjon som avdekker mysteriene i verden rundt oss. Dette er den menneskelige tilstanden for læring: et menneskebarn lærer nye ting og avdekker strukturen i sin verden år for år mens de vokser opp.
|
||||
|
||||
---
|
||||
## Barnets hjerne
|
||||
|
||||
Et barns hjerne og sanser oppfatter fakta fra omgivelsene og lærer gradvis de skjulte mønstrene i livet som hjelper barnet med å lage logiske regler for å identifisere lærte mønstre. Læringsprosessen til den menneskelige hjernen gjør mennesker til de mest sofistikerte levende skapningene i denne verden. Å lære kontinuerlig ved å oppdage skjulte mønstre og deretter innovere på disse mønstrene gjør oss i stand til å forbedre oss selv gjennom hele livet. Denne læringsevnen og utviklingskapasiteten er knyttet til et konsept kalt [hjernens plastisitet](https://www.simplypsychology.org/brain-plasticity.html). Overfladisk kan vi trekke noen motiverende likheter mellom læringsprosessen til den menneskelige hjernen og konseptene for maskinlæring.
|
||||
|
||||
---
|
||||
## Den menneskelige hjernen
|
||||
|
||||
Den [menneskelige hjernen](https://www.livescience.com/29365-human-brain.html) oppfatter ting fra den virkelige verden, behandler den oppfattede informasjonen, tar rasjonelle beslutninger og utfører visse handlinger basert på omstendigheter. Dette kaller vi å oppføre seg intelligent. Når vi programmerer en etterligning av den intelligente atferdsprosessen til en maskin, kalles det kunstig intelligens (AI).
|
||||
|
||||
---
|
||||
## Noen begreper
|
||||
|
||||
Selv om begrepene kan forveksles, er maskinlæring (ML) en viktig underkategori av kunstig intelligens. **ML handler om å bruke spesialiserte algoritmer for å avdekke meningsfull informasjon og finne skjulte mønstre fra oppfattet data for å støtte den rasjonelle beslutningsprosessen**.
|
||||
|
||||
---
|
||||
## AI, ML, Deep Learning
|
||||
|
||||
|
||||
|
||||
> Et diagram som viser forholdet mellom AI, ML, deep learning og data science. Infografikk av [Jen Looper](https://twitter.com/jenlooper) inspirert av [denne grafikken](https://softwareengineering.stackexchange.com/questions/366996/distinction-between-ai-ml-neural-networks-deep-learning-and-data-mining)
|
||||
|
||||
---
|
||||
## Konsepter vi skal dekke
|
||||
|
||||
I dette pensumet skal vi dekke kun kjernebegrepene innen maskinlæring som en nybegynner må kjenne til. Vi dekker det vi kaller 'klassisk maskinlæring' hovedsakelig ved bruk av Scikit-learn, et utmerket bibliotek mange studenter bruker for å lære det grunnleggende. For å forstå bredere konsepter innen kunstig intelligens eller deep learning, er en sterk grunnleggende kunnskap om maskinlæring uunnværlig, og det ønsker vi å tilby her.
|
||||
|
||||
---
|
||||
## I dette kurset vil du lære:
|
||||
|
||||
- kjernebegreper innen maskinlæring
|
||||
- historien til ML
|
||||
- ML og rettferdighet
|
||||
- regresjonsteknikker innen ML
|
||||
- klassifiseringsteknikker innen ML
|
||||
- klyngingsteknikker innen ML
|
||||
- naturlig språkbehandlingsteknikker innen ML
|
||||
- tidsserieprognoseteknikker innen ML
|
||||
- forsterkende læring
|
||||
- virkelige applikasjoner for ML
|
||||
|
||||
---
|
||||
## Hva vi ikke vil dekke
|
||||
|
||||
- deep learning
|
||||
- nevrale nettverk
|
||||
- AI
|
||||
|
||||
For å gi en bedre læringsopplevelse, vil vi unngå kompleksiteten til nevrale nettverk, 'deep learning' - modellbygging med mange lag ved bruk av nevrale nettverk - og AI, som vi vil diskutere i et annet pensum. Vi vil også tilby et kommende pensum om data science for å fokusere på den delen av dette større feltet.
|
||||
|
||||
---
|
||||
## Hvorfor studere maskinlæring?
|
||||
|
||||
Maskinlæring, fra et systemperspektiv, defineres som opprettelsen av automatiserte systemer som kan lære skjulte mønstre fra data for å hjelpe til med å ta intelligente beslutninger.
|
||||
|
||||
Denne motivasjonen er løst inspirert av hvordan den menneskelige hjernen lærer visse ting basert på data den oppfatter fra omverdenen.
|
||||
|
||||
✅ Tenk et øyeblikk på hvorfor en bedrift ville ønske å bruke maskinlæringsstrategier i stedet for å lage en hardkodet regelbasert motor.
|
||||
|
||||
---
|
||||
## Applikasjoner av maskinlæring
|
||||
|
||||
Applikasjoner av maskinlæring er nå nesten overalt, og er like utbredt som dataene som flyter rundt i våre samfunn, generert av våre smarttelefoner, tilkoblede enheter og andre systemer. Med tanke på det enorme potensialet til moderne maskinlæringsalgoritmer, har forskere utforsket deres evne til å løse multidimensjonale og tverrfaglige virkelige problemer med svært positive resultater.
|
||||
|
||||
---
|
||||
## Eksempler på anvendt ML
|
||||
|
||||
**Du kan bruke maskinlæring på mange måter**:
|
||||
|
||||
- For å forutsi sannsynligheten for sykdom basert på en pasients medisinske historie eller rapporter.
|
||||
- For å utnytte værdata til å forutsi værhendelser.
|
||||
- For å forstå sentimentet i en tekst.
|
||||
- For å oppdage falske nyheter for å stoppe spredningen av propaganda.
|
||||
|
||||
Finans, økonomi, geovitenskap, romutforskning, biomedisinsk ingeniørkunst, kognitiv vitenskap og til og med humanistiske fag har tilpasset maskinlæring for å løse de krevende, databehandlingsintensive problemene i deres felt.
|
||||
|
||||
---
|
||||
## Konklusjon
|
||||
|
||||
Maskinlæring automatiserer prosessen med mønsteroppdagelse ved å finne meningsfulle innsikter fra virkelige eller genererte data. Det har vist seg å være svært verdifullt i forretnings-, helse- og finansapplikasjoner, blant andre.
|
||||
|
||||
I nær fremtid vil det å forstå det grunnleggende om maskinlæring bli et must for folk fra alle felt på grunn av dens utbredte adopsjon.
|
||||
|
||||
---
|
||||
# 🚀 Utfordring
|
||||
|
||||
Skisser, på papir eller ved bruk av en online app som [Excalidraw](https://excalidraw.com/), din forståelse av forskjellene mellom AI, ML, deep learning og data science. Legg til noen ideer om problemer som hver av disse teknikkene er gode til å løse.
|
||||
|
||||
# [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
---
|
||||
# Gjennomgang & Selvstudie
|
||||
|
||||
For å lære mer om hvordan du kan jobbe med ML-algoritmer i skyen, følg denne [Læringsstien](https://docs.microsoft.com/learn/paths/create-no-code-predictive-models-azure-machine-learning/?WT.mc_id=academic-77952-leestott).
|
||||
|
||||
Ta en [Læringssti](https://docs.microsoft.com/learn/modules/introduction-to-machine-learning/?WT.mc_id=academic-77952-leestott) om det grunnleggende innen ML.
|
||||
|
||||
---
|
||||
# Oppgave
|
||||
|
||||
[Kom i gang](assignment.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.
|
||||
@ -0,0 +1,23 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "4c4698044bb8af52cfb6388a4ee0e53b",
|
||||
"translation_date": "2025-09-05T21:43:45+00:00",
|
||||
"source_file": "1-Introduction/1-intro-to-ML/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Kom i gang
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
I denne oppgaven uten karakter skal du friske opp Python-kunnskapene dine og sette opp miljøet ditt slik at du kan kjøre notebooks.
|
||||
|
||||
Ta denne [Python-læringsstien](https://docs.microsoft.com/learn/paths/python-language/?WT.mc_id=academic-77952-leestott), og sett opp systemene dine ved å gå gjennom disse introduksjonsvideoene:
|
||||
|
||||
https://www.youtube.com/playlist?list=PLlrxD0HtieHhS8VzuMCfQD4uJ9yne1mE6
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,164 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "6a05fec147e734c3e6bfa54505648e2b",
|
||||
"translation_date": "2025-09-05T21:45:17+00:00",
|
||||
"source_file": "1-Introduction/2-history-of-ML/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Historien om maskinlæring
|
||||
|
||||
|
||||
> Sketchnote av [Tomomi Imura](https://www.twitter.com/girlie_mac)
|
||||
|
||||
## [Quiz før forelesning](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
---
|
||||
|
||||
[](https://youtu.be/N6wxM4wZ7V0 "ML for nybegynnere - Historien om maskinlæring")
|
||||
|
||||
> 🎥 Klikk på bildet over for en kort video som går gjennom denne leksjonen.
|
||||
|
||||
I denne leksjonen skal vi gå gjennom de viktigste milepælene i historien om maskinlæring og kunstig intelligens.
|
||||
|
||||
Historien om kunstig intelligens (AI) som et fagfelt er nært knyttet til historien om maskinlæring, ettersom algoritmene og de teknologiske fremskrittene som ligger til grunn for ML har bidratt til utviklingen av AI. Det er nyttig å huske at selv om disse feltene som separate forskningsområder begynte å ta form på 1950-tallet, så fantes det viktige [algoritmiske, statistiske, matematiske, teknologiske og tekniske oppdagelser](https://wikipedia.org/wiki/Timeline_of_machine_learning) som både gikk forut for og overlappet denne perioden. Faktisk har mennesker tenkt på disse spørsmålene i [hundrevis av år](https://wikipedia.org/wiki/History_of_artificial_intelligence): denne artikkelen diskuterer de historiske intellektuelle grunnlagene for ideen om en 'tenkende maskin.'
|
||||
|
||||
---
|
||||
## Viktige oppdagelser
|
||||
|
||||
- 1763, 1812 [Bayes' teorem](https://wikipedia.org/wiki/Bayes%27_theorem) og dets forgjengere. Dette teoremet og dets anvendelser ligger til grunn for inferens og beskriver sannsynligheten for at en hendelse inntreffer basert på tidligere kunnskap.
|
||||
- 1805 [Minste kvadraters metode](https://wikipedia.org/wiki/Least_squares) av den franske matematikeren Adrien-Marie Legendre. Denne teorien, som du vil lære om i vår enhet om regresjon, hjelper med datafitting.
|
||||
- 1913 [Markov-kjeder](https://wikipedia.org/wiki/Markov_chain), oppkalt etter den russiske matematikeren Andrey Markov, brukes til å beskrive en sekvens av mulige hendelser basert på en tidligere tilstand.
|
||||
- 1957 [Perceptron](https://wikipedia.org/wiki/Perceptron) er en type lineær klassifikator oppfunnet av den amerikanske psykologen Frank Rosenblatt som ligger til grunn for fremskritt innen dyp læring.
|
||||
|
||||
---
|
||||
|
||||
- 1967 [Nærmeste nabo](https://wikipedia.org/wiki/Nearest_neighbor) er en algoritme opprinnelig designet for å kartlegge ruter. I en ML-kontekst brukes den til å oppdage mønstre.
|
||||
- 1970 [Backpropagation](https://wikipedia.org/wiki/Backpropagation) brukes til å trene [feedforward-nevrale nettverk](https://wikipedia.org/wiki/Feedforward_neural_network).
|
||||
- 1982 [Rekurrente nevrale nettverk](https://wikipedia.org/wiki/Recurrent_neural_network) er kunstige nevrale nettverk avledet fra feedforward-nevrale nettverk som skaper temporale grafer.
|
||||
|
||||
✅ Gjør litt research. Hvilke andre datoer skiller seg ut som avgjørende i historien om ML og AI?
|
||||
|
||||
---
|
||||
## 1950: Maskiner som tenker
|
||||
|
||||
Alan Turing, en virkelig bemerkelsesverdig person som ble kåret [av publikum i 2019](https://wikipedia.org/wiki/Icons:_The_Greatest_Person_of_the_20th_Century) til den største vitenskapsmannen i det 20. århundre, er kreditert for å ha bidratt til å legge grunnlaget for konseptet om en 'maskin som kan tenke.' Han tok opp kampen med skeptikere og sitt eget behov for empirisk bevis for dette konseptet, blant annet ved å skape [Turing-testen](https://www.bbc.com/news/technology-18475646), som du vil utforske i våre NLP-leksjoner.
|
||||
|
||||
---
|
||||
## 1956: Dartmouth Summer Research Project
|
||||
|
||||
"Dartmouth Summer Research Project on artificial intelligence var en banebrytende begivenhet for kunstig intelligens som et fagfelt," og det var her begrepet 'kunstig intelligens' ble introdusert ([kilde](https://250.dartmouth.edu/highlights/artificial-intelligence-ai-coined-dartmouth)).
|
||||
|
||||
> Hvert aspekt av læring eller enhver annen egenskap ved intelligens kan i prinsippet beskrives så presist at en maskin kan lages for å simulere det.
|
||||
|
||||
---
|
||||
|
||||
Lederforskeren, matematikkprofessor John McCarthy, håpet "å gå videre basert på antagelsen om at hvert aspekt av læring eller enhver annen egenskap ved intelligens kan i prinsippet beskrives så presist at en maskin kan lages for å simulere det." Deltakerne inkluderte en annen pioner innen feltet, Marvin Minsky.
|
||||
|
||||
Workshoppen er kreditert for å ha initiert og oppmuntret til flere diskusjoner, inkludert "fremveksten av symbolske metoder, systemer fokusert på begrensede domener (tidlige ekspert-systemer), og deduktive systemer versus induktive systemer." ([kilde](https://wikipedia.org/wiki/Dartmouth_workshop)).
|
||||
|
||||
---
|
||||
## 1956 - 1974: "De gylne årene"
|
||||
|
||||
Fra 1950-tallet til midten av 70-tallet var optimismen høy med håp om at AI kunne løse mange problemer. I 1967 uttalte Marvin Minsky selvsikkert at "Innen en generasjon ... vil problemet med å skape 'kunstig intelligens' i stor grad være løst." (Minsky, Marvin (1967), Computation: Finite and Infinite Machines, Englewood Cliffs, N.J.: Prentice-Hall)
|
||||
|
||||
Forskning på naturlig språkprosessering blomstret, søk ble raffinert og gjort mer kraftfullt, og konseptet med 'mikroverdener' ble skapt, hvor enkle oppgaver ble utført ved hjelp av instruksjoner i vanlig språk.
|
||||
|
||||
---
|
||||
|
||||
Forskning ble godt finansiert av statlige organer, fremskritt ble gjort innen beregning og algoritmer, og prototyper av intelligente maskiner ble bygget. Noen av disse maskinene inkluderer:
|
||||
|
||||
* [Shakey-roboten](https://wikipedia.org/wiki/Shakey_the_robot), som kunne manøvrere og bestemme hvordan oppgaver skulle utføres 'intelligent'.
|
||||
|
||||
|
||||
> Shakey i 1972
|
||||
|
||||
---
|
||||
|
||||
* Eliza, en tidlig 'chatterbot', kunne samtale med mennesker og fungere som en primitiv 'terapeut'. Du vil lære mer om Eliza i NLP-leksjonene.
|
||||
|
||||
|
||||
> En versjon av Eliza, en chatbot
|
||||
|
||||
---
|
||||
|
||||
* "Blocks world" var et eksempel på en mikroverden hvor blokker kunne stables og sorteres, og eksperimenter med å lære maskiner å ta beslutninger kunne testes. Fremskritt bygget med biblioteker som [SHRDLU](https://wikipedia.org/wiki/SHRDLU) hjalp til med å drive språkprosessering fremover.
|
||||
|
||||
[](https://www.youtube.com/watch?v=QAJz4YKUwqw "blocks world med SHRDLU")
|
||||
|
||||
> 🎥 Klikk på bildet over for en video: Blocks world med SHRDLU
|
||||
|
||||
---
|
||||
## 1974 - 1980: "AI-vinter"
|
||||
|
||||
På midten av 1970-tallet ble det klart at kompleksiteten ved å lage 'intelligente maskiner' hadde blitt undervurdert og at løftene, gitt den tilgjengelige beregningskraften, hadde blitt overdrevet. Finansiering tørket opp, og tilliten til feltet avtok. Noen problemer som påvirket tilliten inkluderte:
|
||||
---
|
||||
- **Begrensninger**. Beregningskraften var for begrenset.
|
||||
- **Kombinatorisk eksplosjon**. Antallet parametere som måtte trenes vokste eksponentielt etter hvert som mer ble forventet av datamaskiner, uten en parallell utvikling av beregningskraft og kapasitet.
|
||||
- **Mangel på data**. Det var mangel på data som hindret prosessen med å teste, utvikle og forbedre algoritmer.
|
||||
- **Spør vi de riktige spørsmålene?**. Selve spørsmålene som ble stilt begynte å bli stilt spørsmål ved. Forskere begynte å møte kritikk for sine tilnærminger:
|
||||
- Turing-tester ble utfordret, blant annet gjennom 'kinesisk rom-teorien' som hevdet at "programmering av en digital datamaskin kan få den til å fremstå som om den forstår språk, men kunne ikke produsere ekte forståelse." ([kilde](https://plato.stanford.edu/entries/chinese-room/))
|
||||
- Etikken ved å introdusere kunstige intelligenser som "terapeuten" ELIZA i samfunnet ble utfordret.
|
||||
|
||||
---
|
||||
|
||||
Samtidig begynte ulike AI-skoler å dannes. En dikotomi ble etablert mellom ["scruffy" vs. "neat AI"](https://wikipedia.org/wiki/Neats_and_scruffies)-praksiser. _Scruffy_-laboratorier justerte programmer i timevis til de oppnådde ønskede resultater. _Neat_-laboratorier "fokuserte på logikk og formell problemløsning". ELIZA og SHRDLU var velkjente _scruffy_-systemer. På 1980-tallet, da etterspørselen etter å gjøre ML-systemer reproduserbare økte, tok _neat_-tilnærmingen gradvis ledelsen ettersom dens resultater er mer forklarbare.
|
||||
|
||||
---
|
||||
## 1980-tallet: Ekspertsystemer
|
||||
|
||||
Etter hvert som feltet vokste, ble dets nytte for næringslivet tydeligere, og på 1980-tallet økte også spredningen av 'ekspertsystemer'. "Ekspertsystemer var blant de første virkelig vellykkede formene for kunstig intelligens (AI)-programvare." ([kilde](https://wikipedia.org/wiki/Expert_system)).
|
||||
|
||||
Denne typen system er faktisk _hybrid_, bestående delvis av en regelmotor som definerer forretningskrav, og en inferensmotor som utnyttet reglesystemet for å utlede nye fakta.
|
||||
|
||||
Denne perioden så også økende oppmerksomhet rettet mot nevrale nettverk.
|
||||
|
||||
---
|
||||
## 1987 - 1993: AI 'Chill'
|
||||
|
||||
Spredningen av spesialisert maskinvare for ekspertsystemer hadde den uheldige effekten av å bli for spesialisert. Fremveksten av personlige datamaskiner konkurrerte også med disse store, spesialiserte, sentraliserte systemene. Demokratifiseringen av databehandling hadde begynt, og den banet til slutt vei for den moderne eksplosjonen av big data.
|
||||
|
||||
---
|
||||
## 1993 - 2011
|
||||
|
||||
Denne epoken markerte en ny æra for ML og AI, hvor noen av problemene som tidligere hadde vært forårsaket av mangel på data og beregningskraft kunne løses. Mengden data begynte å øke raskt og bli mer tilgjengelig, på godt og vondt, spesielt med introduksjonen av smarttelefonen rundt 2007. Beregningskraften utvidet seg eksponentielt, og algoritmer utviklet seg parallelt. Feltet begynte å modnes etter hvert som de frie og eksperimentelle dagene fra fortiden begynte å krystallisere seg til en ekte disiplin.
|
||||
|
||||
---
|
||||
## Nå
|
||||
|
||||
I dag berører maskinlæring og AI nesten alle deler av livene våre. Denne perioden krever nøye forståelse av risikoene og de potensielle effektene av disse algoritmene på menneskeliv. Som Microsofts Brad Smith har uttalt: "Informasjonsteknologi reiser spørsmål som går til kjernen av grunnleggende menneskerettighetsbeskyttelser som personvern og ytringsfrihet. Disse spørsmålene øker ansvaret for teknologiselskaper som skaper disse produktene. Etter vår mening krever de også gjennomtenkt statlig regulering og utvikling av normer rundt akseptabel bruk" ([kilde](https://www.technologyreview.com/2019/12/18/102365/the-future-of-ais-impact-on-society/)).
|
||||
|
||||
---
|
||||
|
||||
Det gjenstår å se hva fremtiden bringer, men det er viktig å forstå disse datasystemene og programvaren og algoritmene de kjører. Vi håper at dette pensumet vil hjelpe deg med å få en bedre forståelse slik at du kan ta dine egne beslutninger.
|
||||
|
||||
[](https://www.youtube.com/watch?v=mTtDfKgLm54 "Historien om dyp læring")
|
||||
> 🎥 Klikk på bildet over for en video: Yann LeCun diskuterer historien om dyp læring i denne forelesningen
|
||||
|
||||
---
|
||||
## 🚀Utfordring
|
||||
|
||||
Fordyp deg i et av disse historiske øyeblikkene og lær mer om menneskene bak dem. Det finnes fascinerende karakterer, og ingen vitenskapelig oppdagelse ble noen gang skapt i et kulturelt vakuum. Hva oppdager du?
|
||||
|
||||
## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
---
|
||||
## Gjennomgang og selvstudium
|
||||
|
||||
Her er ting du kan se og lytte til:
|
||||
|
||||
[Denne podcasten hvor Amy Boyd diskuterer utviklingen av AI](http://runasradio.com/Shows/Show/739)
|
||||
|
||||
[](https://www.youtube.com/watch?v=EJt3_bFYKss "Historien om AI av Amy Boyd")
|
||||
|
||||
---
|
||||
|
||||
## Oppgave
|
||||
|
||||
[Lag en tidslinje](assignment.md)
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,25 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "eb6e4d5afd1b21a57d2b9e6d0aac3969",
|
||||
"translation_date": "2025-09-05T21:46:00+00:00",
|
||||
"source_file": "1-Introduction/2-history-of-ML/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Lag en tidslinje
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
Ved å bruke [dette repoet](https://github.com/Digital-Humanities-Toolkit/timeline-builder), lag en tidslinje over et aspekt av historien til algoritmer, matematikk, statistikk, AI eller ML, eller en kombinasjon av disse. Du kan fokusere på én person, én idé, eller en lang tidsperiode med tanker. Sørg for å legge til multimedieelementer.
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Eksemplarisk | Tilfredsstillende | Trenger forbedring |
|
||||
| --------- | ------------------------------------------------- | -------------------------------------- | --------------------------------------------------------------- |
|
||||
| | En publisert tidslinje presenteres som en GitHub-side | Koden er ufullstendig og ikke publisert | Tidslinjen er ufullstendig, dårlig undersøkt og ikke publisert |
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,25 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "dbda60e7b1fe5f18974e7858eff0004e",
|
||||
"translation_date": "2025-09-05T21:40:15+00:00",
|
||||
"source_file": "1-Introduction/3-fairness/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Utforsk Responsible AI Toolbox
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
I denne leksjonen lærte du om Responsible AI Toolbox, et "åpen kildekode, samfunnsdrevet prosjekt for å hjelpe dataforskere med å analysere og forbedre AI-systemer." For denne oppgaven, utforsk en av RAI Toolbox sine [notebooks](https://github.com/microsoft/responsible-ai-toolbox/blob/main/notebooks/responsibleaidashboard/getting-started.ipynb) og rapporter funnene dine i et papir eller en presentasjon.
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Fremragende | Tilfredsstillende | Trenger forbedring |
|
||||
| --------- | ----------- | ----------------- | ------------------ |
|
||||
| | Et papir eller PowerPoint-presentasjon blir levert som diskuterer Fairlearns systemer, notebooken som ble kjørt, og konklusjonene som ble trukket fra den | Et papir blir levert uten konklusjoner | Ingen papir blir levert |
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,132 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "9d91f3af3758fdd4569fb410575995ef",
|
||||
"translation_date": "2025-09-05T21:41:24+00:00",
|
||||
"source_file": "1-Introduction/4-techniques-of-ML/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Teknikker for maskinlæring
|
||||
|
||||
Prosessen med å bygge, bruke og vedlikeholde maskinlæringsmodeller og dataene de bruker, er svært forskjellig fra mange andre utviklingsarbeidsflyter. I denne leksjonen vil vi avmystifisere prosessen og skissere de viktigste teknikkene du trenger å kjenne til. Du vil:
|
||||
|
||||
- Forstå prosessene som ligger til grunn for maskinlæring på et overordnet nivå.
|
||||
- Utforske grunnleggende konsepter som 'modeller', 'prediksjoner' og 'treningsdata'.
|
||||
|
||||
## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
[](https://youtu.be/4NGM0U2ZSHU "ML for nybegynnere - Teknikker for maskinlæring")
|
||||
|
||||
> 🎥 Klikk på bildet over for en kort video som går gjennom denne leksjonen.
|
||||
|
||||
## Introduksjon
|
||||
|
||||
På et overordnet nivå består håndverket med å lage maskinlæringsprosesser (ML) av flere steg:
|
||||
|
||||
1. **Bestem spørsmålet**. De fleste ML-prosesser starter med å stille et spørsmål som ikke kan besvares med et enkelt betingelsesbasert program eller regelbasert motor. Disse spørsmålene dreier seg ofte om prediksjoner basert på en samling data.
|
||||
2. **Samle og forbered data**. For å kunne besvare spørsmålet ditt trenger du data. Kvaliteten og, noen ganger, mengden av dataene dine vil avgjøre hvor godt du kan besvare det opprinnelige spørsmålet. Visualisering av data er en viktig del av denne fasen. Denne fasen inkluderer også å dele dataene inn i en trenings- og testgruppe for å bygge en modell.
|
||||
3. **Velg en treningsmetode**. Avhengig av spørsmålet ditt og naturen til dataene dine, må du velge hvordan du vil trene en modell for best å reflektere dataene og lage nøyaktige prediksjoner basert på dem. Dette er den delen av ML-prosessen som krever spesifikk ekspertise og ofte en betydelig mengde eksperimentering.
|
||||
4. **Tren modellen**. Ved hjelp av treningsdataene dine bruker du ulike algoritmer for å trene en modell til å gjenkjenne mønstre i dataene. Modellen kan bruke interne vekter som kan justeres for å prioritere visse deler av dataene over andre for å bygge en bedre modell.
|
||||
5. **Evaluer modellen**. Du bruker data som modellen aldri har sett før (testdataene dine) fra den innsamlede samlingen for å se hvordan modellen presterer.
|
||||
6. **Parameterjustering**. Basert på modellens ytelse kan du gjenta prosessen med forskjellige parametere eller variabler som styrer oppførselen til algoritmene som brukes til å trene modellen.
|
||||
7. **Prediksjon**. Bruk nye input for å teste modellens nøyaktighet.
|
||||
|
||||
## Hvilket spørsmål skal du stille?
|
||||
|
||||
Datamaskiner er spesielt dyktige til å oppdage skjulte mønstre i data. Denne egenskapen er svært nyttig for forskere som har spørsmål om et gitt område som ikke enkelt kan besvares ved å lage en betingelsesbasert regelmotor. Gitt en aktuariell oppgave, for eksempel, kan en dataforsker være i stand til å konstruere håndlagde regler rundt dødeligheten til røykere vs. ikke-røykere.
|
||||
|
||||
Når mange andre variabler tas med i ligningen, kan imidlertid en ML-modell vise seg å være mer effektiv til å forutsi fremtidige dødelighetsrater basert på tidligere helsehistorikk. Et mer oppløftende eksempel kan være å lage værprediksjoner for april måned på et gitt sted basert på data som inkluderer breddegrad, lengdegrad, klimaendringer, nærhet til havet, mønstre i jetstrømmen og mer.
|
||||
|
||||
✅ Denne [presentasjonen](https://www2.cisl.ucar.edu/sites/default/files/2021-10/0900%20June%2024%20Haupt_0.pdf) om værmodeller gir et historisk perspektiv på bruk av ML i væranalyse.
|
||||
|
||||
## Oppgaver før bygging
|
||||
|
||||
Før du begynner å bygge modellen din, er det flere oppgaver du må fullføre. For å teste spørsmålet ditt og danne en hypotese basert på modellens prediksjoner, må du identifisere og konfigurere flere elementer.
|
||||
|
||||
### Data
|
||||
|
||||
For å kunne besvare spørsmålet ditt med en viss grad av sikkerhet, trenger du en god mengde data av riktig type. Det er to ting du må gjøre på dette tidspunktet:
|
||||
|
||||
- **Samle data**. Med tanke på den forrige leksjonen om rettferdighet i dataanalyse, samle dataene dine med omhu. Vær oppmerksom på kildene til disse dataene, eventuelle iboende skjevheter de kan ha, og dokumenter opprinnelsen.
|
||||
- **Forbered data**. Det er flere steg i prosessen med databehandling. Du kan trenge å samle data og normalisere dem hvis de kommer fra ulike kilder. Du kan forbedre kvaliteten og mengden av dataene gjennom ulike metoder, som å konvertere strenger til tall (som vi gjør i [Clustering](../../5-Clustering/1-Visualize/README.md)). Du kan også generere nye data basert på de opprinnelige (som vi gjør i [Classification](../../4-Classification/1-Introduction/README.md)). Du kan rense og redigere dataene (som vi gjør før [Web App](../../3-Web-App/README.md)-leksjonen). Til slutt kan det hende du må randomisere og blande dem, avhengig av treningsmetodene dine.
|
||||
|
||||
✅ Etter å ha samlet og behandlet dataene dine, ta et øyeblikk for å se om formen deres vil tillate deg å adressere det tiltenkte spørsmålet. Det kan være at dataene ikke vil fungere godt for den gitte oppgaven, som vi oppdager i våre [Clustering](../../5-Clustering/1-Visualize/README.md)-leksjoner!
|
||||
|
||||
### Funksjoner og mål
|
||||
|
||||
En [funksjon](https://www.datasciencecentral.com/profiles/blogs/an-introduction-to-variable-and-feature-selection) er en målbar egenskap ved dataene dine. I mange datasett uttrykkes det som en kolonneoverskrift som 'dato', 'størrelse' eller 'farge'. Funksjonsvariabelen din, vanligvis representert som `X` i kode, representerer inputvariabelen som vil bli brukt til å trene modellen.
|
||||
|
||||
Et mål er det du prøver å forutsi. Målet, vanligvis representert som `y` i kode, representerer svaret på spørsmålet du prøver å stille til dataene dine: i desember, hvilken **farge** vil gresskar være billigst? I San Francisco, hvilke nabolag vil ha de beste eiendoms**prisene**? Noen ganger refereres målet også til som etikettattributt.
|
||||
|
||||
### Velge funksjonsvariabelen din
|
||||
|
||||
🎓 **Funksjonsvalg og funksjonsekstraksjon** Hvordan vet du hvilken variabel du skal velge når du bygger en modell? Du vil sannsynligvis gå gjennom en prosess med funksjonsvalg eller funksjonsekstraksjon for å velge de riktige variablene for den mest effektive modellen. De er imidlertid ikke det samme: "Funksjonsekstraksjon lager nye funksjoner fra funksjoner av de opprinnelige funksjonene, mens funksjonsvalg returnerer et delsett av funksjonene." ([kilde](https://wikipedia.org/wiki/Feature_selection))
|
||||
|
||||
### Visualiser dataene dine
|
||||
|
||||
En viktig del av verktøysettet til en dataforsker er evnen til å visualisere data ved hjelp av flere utmerkede biblioteker som Seaborn eller MatPlotLib. Å representere dataene dine visuelt kan hjelpe deg med å avdekke skjulte korrelasjoner som du kan utnytte. Visualiseringene dine kan også hjelpe deg med å avdekke skjevheter eller ubalanserte data (som vi oppdager i [Classification](../../4-Classification/2-Classifiers-1/README.md)).
|
||||
|
||||
### Del opp datasettet ditt
|
||||
|
||||
Før trening må du dele datasettet ditt inn i to eller flere deler av ulik størrelse som fortsatt representerer dataene godt.
|
||||
|
||||
- **Trening**. Denne delen av datasettet tilpasses modellen din for å trene den. Dette settet utgjør majoriteten av det opprinnelige datasettet.
|
||||
- **Testing**. Et testdatasett er en uavhengig gruppe data, ofte hentet fra de opprinnelige dataene, som du bruker for å bekrefte ytelsen til den bygde modellen.
|
||||
- **Validering**. Et valideringssett er en mindre uavhengig gruppe eksempler som du bruker for å finjustere modellens hyperparametere eller arkitektur for å forbedre modellen. Avhengig av størrelsen på dataene dine og spørsmålet du stiller, trenger du kanskje ikke å bygge dette tredje settet (som vi bemerker i [Time Series Forecasting](../../7-TimeSeries/1-Introduction/README.md)).
|
||||
|
||||
## Bygge en modell
|
||||
|
||||
Ved hjelp av treningsdataene dine er målet ditt å bygge en modell, eller en statistisk representasjon av dataene dine, ved hjelp av ulike algoritmer for å **trene** den. Å trene en modell eksponerer den for data og lar den gjøre antakelser om oppdagede mønstre, validere dem og akseptere eller avvise dem.
|
||||
|
||||
### Bestem treningsmetoden
|
||||
|
||||
Avhengig av spørsmålet ditt og naturen til dataene dine, vil du velge en metode for å trene dem. Ved å gå gjennom [Scikit-learn's dokumentasjon](https://scikit-learn.org/stable/user_guide.html) - som vi bruker i dette kurset - kan du utforske mange måter å trene en modell på. Avhengig av erfaringen din, kan det hende du må prøve flere forskjellige metoder for å bygge den beste modellen. Du vil sannsynligvis gå gjennom en prosess der dataforskere evaluerer ytelsen til en modell ved å mate den med ukjente data, sjekke for nøyaktighet, skjevhet og andre kvalitetsreduserende problemer, og velge den mest passende treningsmetoden for oppgaven.
|
||||
|
||||
### Tren en modell
|
||||
|
||||
Med treningsdataene dine er du klar til å 'tilpasse' dem for å lage en modell. Du vil legge merke til at i mange ML-biblioteker finner du koden 'model.fit' - det er på dette tidspunktet du sender inn funksjonsvariabelen din som en matrise av verdier (vanligvis 'X') og en målvariabel (vanligvis 'y').
|
||||
|
||||
### Evaluer modellen
|
||||
|
||||
Når treningsprosessen er fullført (det kan ta mange iterasjoner, eller 'epoker', å trene en stor modell), vil du kunne evaluere modellens kvalitet ved å bruke testdata for å måle ytelsen. Disse dataene er et delsett av de opprinnelige dataene som modellen ikke tidligere har analysert. Du kan skrive ut en tabell med metrikker om modellens kvalitet.
|
||||
|
||||
🎓 **Modelltilpasning**
|
||||
|
||||
I sammenheng med maskinlæring refererer modelltilpasning til nøyaktigheten av modellens underliggende funksjon når den forsøker å analysere data den ikke er kjent med.
|
||||
|
||||
🎓 **Undertilpasning** og **overtilpasning** er vanlige problemer som reduserer modellens kvalitet, ettersom modellen enten tilpasser seg for dårlig eller for godt. Dette fører til at modellen lager prediksjoner som enten er for tett knyttet til eller for løst knyttet til treningsdataene. En overtilpasset modell forutsier treningsdataene for godt fordi den har lært detaljene og støyen i dataene for godt. En undertilpasset modell er ikke nøyaktig, da den verken kan analysere treningsdataene eller data den ikke har 'sett' på en korrekt måte.
|
||||
|
||||
|
||||
> Infografikk av [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
## Parameterjustering
|
||||
|
||||
Når den første treningen er fullført, observer kvaliteten på modellen og vurder å forbedre den ved å justere dens 'hyperparametere'. Les mer om prosessen [i dokumentasjonen](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-tune-hyperparameters?WT.mc_id=academic-77952-leestott).
|
||||
|
||||
## Prediksjon
|
||||
|
||||
Dette er øyeblikket hvor du kan bruke helt nye data for å teste modellens nøyaktighet. I en 'anvendt' ML-setting, der du bygger nettressurser for å bruke modellen i produksjon, kan denne prosessen innebære å samle brukerinput (for eksempel et knappetrykk) for å sette en variabel og sende den til modellen for inferens eller evaluering.
|
||||
|
||||
I disse leksjonene vil du oppdage hvordan du bruker disse stegene til å forberede, bygge, teste, evaluere og forutsi - alle oppgavene til en dataforsker og mer, mens du utvikler deg på reisen til å bli en 'full stack' ML-ingeniør.
|
||||
|
||||
---
|
||||
|
||||
## 🚀Utfordring
|
||||
|
||||
Lag et flytskjema som reflekterer stegene til en ML-praktiker. Hvor ser du deg selv akkurat nå i prosessen? Hvor tror du at du vil møte vanskeligheter? Hva virker enkelt for deg?
|
||||
|
||||
## [Quiz etter leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Gjennomgang og selvstudium
|
||||
|
||||
Søk på nettet etter intervjuer med dataforskere som diskuterer sitt daglige arbeid. Her er [et](https://www.youtube.com/watch?v=Z3IjgbbCEfs).
|
||||
|
||||
## Oppgave
|
||||
|
||||
[Intervju en dataforsker](assignment.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.
|
||||
@ -0,0 +1,25 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "70d65aeddc06170bc1aed5b27805f930",
|
||||
"translation_date": "2025-09-05T21:42:07+00:00",
|
||||
"source_file": "1-Introduction/4-techniques-of-ML/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Intervju en data scientist
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
I din bedrift, i en brukergruppe, eller blant vennene dine eller medstudenter, snakk med noen som jobber profesjonelt som data scientist. Skriv en kort oppgave (500 ord) om deres daglige arbeidsoppgaver. Er de spesialister, eller jobber de 'full stack'?
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Fremragende | Tilfredsstillende | Trenger forbedring |
|
||||
| --------- | ----------------------------------------------------------------------------------- | ------------------------------------------------------------------ | --------------------- |
|
||||
| | En oppgave med korrekt lengde, med tilskrevne kilder, presentert som en .doc-fil | Oppgaven er dårlig tilskrevet eller kortere enn den påkrevde lengden | Ingen oppgave er levert |
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,36 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "cf8ecc83f28e5b98051d2179eca08e08",
|
||||
"translation_date": "2025-09-05T21:37:38+00:00",
|
||||
"source_file": "1-Introduction/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Introduksjon til maskinlæring
|
||||
|
||||
I denne delen av læreplanen vil du bli introdusert til de grunnleggende konseptene som ligger til grunn for feltet maskinlæring, hva det er, og lære om historien og teknikkene forskere bruker for å arbeide med det. La oss utforske denne nye verdenen av ML sammen!
|
||||
|
||||
|
||||
> Foto av <a href="https://unsplash.com/@bill_oxford?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Bill Oxford</a> på <a href="https://unsplash.com/s/photos/globe?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
|
||||
|
||||
### Leksjoner
|
||||
|
||||
1. [Introduksjon til maskinlæring](1-intro-to-ML/README.md)
|
||||
1. [Historien til maskinlæring og AI](2-history-of-ML/README.md)
|
||||
1. [Rettferdighet og maskinlæring](3-fairness/README.md)
|
||||
1. [Teknikker innen maskinlæring](4-techniques-of-ML/README.md)
|
||||
### Krediteringer
|
||||
|
||||
"Introduksjon til maskinlæring" ble skrevet med ♥️ av et team av folk inkludert [Muhammad Sakib Khan Inan](https://twitter.com/Sakibinan), [Ornella Altunyan](https://twitter.com/ornelladotcom) og [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
"Historien til maskinlæring" ble skrevet med ♥️ av [Jen Looper](https://twitter.com/jenlooper) og [Amy Boyd](https://twitter.com/AmyKateNicho)
|
||||
|
||||
"Rettferdighet og maskinlæring" ble skrevet med ♥️ av [Tomomi Imura](https://twitter.com/girliemac)
|
||||
|
||||
"Teknikker innen maskinlæring" ble skrevet med ♥️ av [Jen Looper](https://twitter.com/jenlooper) og [Chris Noring](https://twitter.com/softchris)
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,238 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "fa81d226c71d5af7a2cade31c1c92b88",
|
||||
"translation_date": "2025-09-05T21:13:58+00:00",
|
||||
"source_file": "2-Regression/1-Tools/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Kom i gang med Python og Scikit-learn for regresjonsmodeller
|
||||
|
||||
|
||||
|
||||
> Sketchnote av [Tomomi Imura](https://www.twitter.com/girlie_mac)
|
||||
|
||||
## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
> ### [Denne leksjonen er også tilgjengelig i R!](../../../../2-Regression/1-Tools/solution/R/lesson_1.html)
|
||||
|
||||
## Introduksjon
|
||||
|
||||
I disse fire leksjonene vil du lære hvordan du bygger regresjonsmodeller. Vi skal snart diskutere hva disse brukes til. Men før du gjør noe som helst, sørg for at du har de riktige verktøyene på plass for å starte prosessen!
|
||||
|
||||
I denne leksjonen vil du lære å:
|
||||
|
||||
- Konfigurere datamaskinen din for lokale maskinlæringsoppgaver.
|
||||
- Jobbe med Jupyter-notatbøker.
|
||||
- Bruke Scikit-learn, inkludert installasjon.
|
||||
- Utforske lineær regresjon gjennom en praktisk øvelse.
|
||||
|
||||
## Installasjoner og konfigurasjoner
|
||||
|
||||
[](https://youtu.be/-DfeD2k2Kj0 "ML for nybegynnere - Sett opp verktøyene dine for å bygge maskinlæringsmodeller")
|
||||
|
||||
> 🎥 Klikk på bildet over for en kort video som viser hvordan du konfigurerer datamaskinen din for maskinlæring.
|
||||
|
||||
1. **Installer Python**. Sørg for at [Python](https://www.python.org/downloads/) er installert på datamaskinen din. Du vil bruke Python til mange oppgaver innen datavitenskap og maskinlæring. De fleste datamaskiner har allerede en Python-installasjon. Det finnes også nyttige [Python Coding Packs](https://code.visualstudio.com/learn/educators/installers?WT.mc_id=academic-77952-leestott) som kan gjøre oppsettet enklere for noen brukere.
|
||||
|
||||
Noen bruksområder for Python krever én versjon av programvaren, mens andre krever en annen versjon. Derfor er det nyttig å jobbe i et [virtuelt miljø](https://docs.python.org/3/library/venv.html).
|
||||
|
||||
2. **Installer Visual Studio Code**. Sørg for at Visual Studio Code er installert på datamaskinen din. Følg disse instruksjonene for å [installere Visual Studio Code](https://code.visualstudio.com/) for grunnleggende installasjon. Du skal bruke Python i Visual Studio Code i dette kurset, så det kan være lurt å friske opp hvordan du [konfigurerer Visual Studio Code](https://docs.microsoft.com/learn/modules/python-install-vscode?WT.mc_id=academic-77952-leestott) for Python-utvikling.
|
||||
|
||||
> Bli komfortabel med Python ved å jobbe gjennom denne samlingen av [Learn-moduler](https://docs.microsoft.com/users/jenlooper-2911/collections/mp1pagggd5qrq7?WT.mc_id=academic-77952-leestott)
|
||||
>
|
||||
> [](https://youtu.be/yyQM70vi7V8 "Sett opp Python med Visual Studio Code")
|
||||
>
|
||||
> 🎥 Klikk på bildet over for en video: bruk Python i VS Code.
|
||||
|
||||
3. **Installer Scikit-learn** ved å følge [disse instruksjonene](https://scikit-learn.org/stable/install.html). Siden du må sørge for at du bruker Python 3, anbefales det at du bruker et virtuelt miljø. Merk at hvis du installerer dette biblioteket på en M1 Mac, finnes det spesielle instruksjoner på siden som er lenket over.
|
||||
|
||||
4. **Installer Jupyter Notebook**. Du må [installere Jupyter-pakken](https://pypi.org/project/jupyter/).
|
||||
|
||||
## Ditt ML-utviklingsmiljø
|
||||
|
||||
Du skal bruke **notatbøker** for å utvikle Python-koden din og lage maskinlæringsmodeller. Denne typen filer er et vanlig verktøy for dataforskere, og de kan identifiseres ved suffikset eller filtypen `.ipynb`.
|
||||
|
||||
Notatbøker er et interaktivt miljø som lar utvikleren både kode og legge til notater og skrive dokumentasjon rundt koden, noe som er ganske nyttig for eksperimentelle eller forskningsorienterte prosjekter.
|
||||
|
||||
[](https://youtu.be/7E-jC8FLA2E "ML for nybegynnere - Sett opp Jupyter-notatbøker for å begynne å bygge regresjonsmodeller")
|
||||
|
||||
> 🎥 Klikk på bildet over for en kort video som viser denne øvelsen.
|
||||
|
||||
### Øvelse - jobb med en notatbok
|
||||
|
||||
I denne mappen finner du filen _notebook.ipynb_.
|
||||
|
||||
1. Åpne _notebook.ipynb_ i Visual Studio Code.
|
||||
|
||||
En Jupyter-server vil starte med Python 3+. Du vil finne områder i notatboken som kan `kjøres`, altså kodeblokker. Du kan kjøre en kodeblokk ved å velge ikonet som ser ut som en avspillingsknapp.
|
||||
|
||||
2. Velg `md`-ikonet og legg til litt markdown, og følgende tekst: **# Velkommen til din notatbok**.
|
||||
|
||||
Deretter legger du til litt Python-kode.
|
||||
|
||||
3. Skriv **print('hello notebook')** i kodeblokken.
|
||||
4. Velg pilen for å kjøre koden.
|
||||
|
||||
Du bør se den utskrevne meldingen:
|
||||
|
||||
```output
|
||||
hello notebook
|
||||
```
|
||||
|
||||
|
||||
|
||||
Du kan blande koden din med kommentarer for å selv-dokumentere notatboken.
|
||||
|
||||
✅ Tenk et øyeblikk på hvor forskjellig arbeidsmiljøet til en webutvikler er sammenlignet med en dataforsker.
|
||||
|
||||
## Kom i gang med Scikit-learn
|
||||
|
||||
Nå som Python er satt opp i ditt lokale miljø, og du er komfortabel med Jupyter-notatbøker, la oss bli like komfortable med Scikit-learn (uttales `sci` som i `science`). Scikit-learn tilbyr en [omfattende API](https://scikit-learn.org/stable/modules/classes.html#api-ref) for å hjelpe deg med å utføre ML-oppgaver.
|
||||
|
||||
Ifølge deres [nettsted](https://scikit-learn.org/stable/getting_started.html), "Scikit-learn er et åpen kildekode-bibliotek for maskinlæring som støtter både overvåket og ikke-overvåket læring. Det tilbyr også ulike verktøy for modelltilpasning, dataprosessering, modellvalg og evaluering, samt mange andre nyttige funksjoner."
|
||||
|
||||
I dette kurset vil du bruke Scikit-learn og andre verktøy for å bygge maskinlæringsmodeller for å utføre det vi kaller 'tradisjonelle maskinlæringsoppgaver'. Vi har bevisst unngått nevrale nettverk og dyp læring, da disse dekkes bedre i vårt kommende 'AI for nybegynnere'-pensum.
|
||||
|
||||
Scikit-learn gjør det enkelt å bygge modeller og evaluere dem for bruk. Det fokuserer primært på bruk av numeriske data og inneholder flere ferdiglagde datasett som kan brukes som læringsverktøy. Det inkluderer også forhåndsbygde modeller som studenter kan prøve. La oss utforske prosessen med å laste inn forhåndspakkede data og bruke en innebygd estimator for å lage vår første ML-modell med Scikit-learn ved hjelp av noen grunnleggende data.
|
||||
|
||||
## Øvelse - din første Scikit-learn-notatbok
|
||||
|
||||
> Denne opplæringen er inspirert av [eksempelet på lineær regresjon](https://scikit-learn.org/stable/auto_examples/linear_model/plot_ols.html#sphx-glr-auto-examples-linear-model-plot-ols-py) på Scikit-learns nettsted.
|
||||
|
||||
[](https://youtu.be/2xkXL5EUpS0 "ML for nybegynnere - Ditt første lineære regresjonsprosjekt i Python")
|
||||
|
||||
> 🎥 Klikk på bildet over for en kort video som viser denne øvelsen.
|
||||
|
||||
I _notebook.ipynb_-filen som er tilknyttet denne leksjonen, tøm alle cellene ved å trykke på 'søppelbøtte'-ikonet.
|
||||
|
||||
I denne delen skal du jobbe med et lite datasett om diabetes som er innebygd i Scikit-learn for læringsformål. Tenk deg at du ønsket å teste en behandling for diabetikere. Maskinlæringsmodeller kan hjelpe deg med å avgjøre hvilke pasienter som vil respondere bedre på behandlingen, basert på kombinasjoner av variabler. Selv en veldig grunnleggende regresjonsmodell, når den visualiseres, kan vise informasjon om variabler som kan hjelpe deg med å organisere dine teoretiske kliniske studier.
|
||||
|
||||
✅ Det finnes mange typer regresjonsmetoder, og hvilken du velger avhenger av spørsmålet du ønsker å besvare. Hvis du vil forutsi sannsynlig høyde for en person med en gitt alder, vil du bruke lineær regresjon, siden du søker en **numerisk verdi**. Hvis du er interessert i å finne ut om en type mat skal anses som vegansk eller ikke, ser du etter en **kategoriinndeling**, og da vil du bruke logistisk regresjon. Du vil lære mer om logistisk regresjon senere. Tenk litt på noen spørsmål du kan stille til data, og hvilken av disse metodene som ville være mest passende.
|
||||
|
||||
La oss komme i gang med denne oppgaven.
|
||||
|
||||
### Importer biblioteker
|
||||
|
||||
For denne oppgaven skal vi importere noen biblioteker:
|
||||
|
||||
- **matplotlib**. Et nyttig [verktøy for grafer](https://matplotlib.org/) som vi skal bruke til å lage en linjediagram.
|
||||
- **numpy**. [numpy](https://numpy.org/doc/stable/user/whatisnumpy.html) er et nyttig bibliotek for håndtering av numeriske data i Python.
|
||||
- **sklearn**. Dette er [Scikit-learn](https://scikit-learn.org/stable/user_guide.html)-biblioteket.
|
||||
|
||||
Importer noen biblioteker for å hjelpe med oppgavene dine.
|
||||
|
||||
1. Legg til imports ved å skrive følgende kode:
|
||||
|
||||
```python
|
||||
import matplotlib.pyplot as plt
|
||||
import numpy as np
|
||||
from sklearn import datasets, linear_model, model_selection
|
||||
```
|
||||
|
||||
Over importerer du `matplotlib`, `numpy`, og du importerer `datasets`, `linear_model` og `model_selection` fra `sklearn`. `model_selection` brukes til å dele data i trenings- og testsett.
|
||||
|
||||
### Diabetes-datasettet
|
||||
|
||||
Det innebygde [diabetes-datasettet](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) inkluderer 442 datasettprøver om diabetes, med 10 funksjonsvariabler, inkludert:
|
||||
|
||||
- age: alder i år
|
||||
- bmi: kroppsmasseindeks
|
||||
- bp: gjennomsnittlig blodtrykk
|
||||
- s1 tc: T-celler (en type hvite blodceller)
|
||||
|
||||
✅ Dette datasettet inkluderer konseptet 'kjønn' som en funksjonsvariabel viktig for forskning på diabetes. Mange medisinske datasett inkluderer denne typen binær klassifisering. Tenk litt på hvordan slike kategoriseringer kan ekskludere visse deler av befolkningen fra behandlinger.
|
||||
|
||||
Nå, last inn X- og y-dataene.
|
||||
|
||||
> 🎓 Husk, dette er overvåket læring, og vi trenger et navngitt 'y'-mål.
|
||||
|
||||
I en ny kodecelle, last inn diabetes-datasettet ved å kalle `load_diabetes()`. Inputen `return_X_y=True` signaliserer at `X` vil være en datamatrise, og `y` vil være regresjonsmålet.
|
||||
|
||||
1. Legg til noen print-kommandoer for å vise formen på datamatrisen og dens første element:
|
||||
|
||||
```python
|
||||
X, y = datasets.load_diabetes(return_X_y=True)
|
||||
print(X.shape)
|
||||
print(X[0])
|
||||
```
|
||||
|
||||
Det du får tilbake som svar, er en tuple. Det du gjør, er å tilordne de to første verdiene i tuplen til henholdsvis `X` og `y`. Lær mer [om tupler](https://wikipedia.org/wiki/Tuple).
|
||||
|
||||
Du kan se at disse dataene har 442 elementer formet i matriser med 10 elementer:
|
||||
|
||||
```text
|
||||
(442, 10)
|
||||
[ 0.03807591 0.05068012 0.06169621 0.02187235 -0.0442235 -0.03482076
|
||||
-0.04340085 -0.00259226 0.01990842 -0.01764613]
|
||||
```
|
||||
|
||||
✅ Tenk litt på forholdet mellom dataene og regresjonsmålet. Lineær regresjon forutsier forholdet mellom funksjonen X og målvariabelen y. Kan du finne [målet](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) for diabetes-datasettet i dokumentasjonen? Hva demonstrerer dette datasettet, gitt målet?
|
||||
|
||||
2. Velg deretter en del av dette datasettet for å plotte ved å velge den tredje kolonnen i datasettet. Du kan gjøre dette ved å bruke `:`-operatoren for å velge alle rader, og deretter velge den tredje kolonnen ved hjelp av indeksen (2). Du kan også omforme dataene til å være en 2D-matrise - som kreves for plotting - ved å bruke `reshape(n_rows, n_columns)`. Hvis en av parameterne er -1, beregnes den tilsvarende dimensjonen automatisk.
|
||||
|
||||
```python
|
||||
X = X[:, 2]
|
||||
X = X.reshape((-1,1))
|
||||
```
|
||||
|
||||
✅ Når som helst, skriv ut dataene for å sjekke formen.
|
||||
|
||||
3. Nå som du har data klare til å bli plottet, kan du se om en maskin kan hjelpe med å bestemme en logisk inndeling mellom tallene i dette datasettet. For å gjøre dette, må du dele både dataene (X) og målet (y) i test- og treningssett. Scikit-learn har en enkel måte å gjøre dette på; du kan dele testdataene dine på et gitt punkt.
|
||||
|
||||
```python
|
||||
X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.33)
|
||||
```
|
||||
|
||||
4. Nå er du klar til å trene modellen din! Last inn den lineære regresjonsmodellen og tren den med X- og y-treningssettene dine ved å bruke `model.fit()`:
|
||||
|
||||
```python
|
||||
model = linear_model.LinearRegression()
|
||||
model.fit(X_train, y_train)
|
||||
```
|
||||
|
||||
✅ `model.fit()` er en funksjon du vil se i mange ML-biblioteker som TensorFlow.
|
||||
|
||||
5. Deretter lager du en prediksjon ved hjelp av testdataene, ved å bruke funksjonen `predict()`. Dette vil brukes til å tegne linjen mellom datagruppene.
|
||||
|
||||
```python
|
||||
y_pred = model.predict(X_test)
|
||||
```
|
||||
|
||||
6. Nå er det på tide å vise dataene i et diagram. Matplotlib er et veldig nyttig verktøy for denne oppgaven. Lag et spredningsdiagram av alle X- og y-testdataene, og bruk prediksjonen til å tegne en linje på det mest passende stedet mellom modellens datagrupper.
|
||||
|
||||
```python
|
||||
plt.scatter(X_test, y_test, color='black')
|
||||
plt.plot(X_test, y_pred, color='blue', linewidth=3)
|
||||
plt.xlabel('Scaled BMIs')
|
||||
plt.ylabel('Disease Progression')
|
||||
plt.title('A Graph Plot Showing Diabetes Progression Against BMI')
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
✅ Tenk litt over hva som skjer her. En rett linje går gjennom mange små datapunkter, men hva gjør den egentlig? Kan du se hvordan du bør kunne bruke denne linjen til å forutsi hvor et nytt, ukjent datapunkt bør passe i forhold til y-aksen i plottet? Prøv å sette ord på den praktiske bruken av denne modellen.
|
||||
|
||||
Gratulerer, du har bygget din første lineære regresjonsmodell, laget en prediksjon med den, og vist den i et plott!
|
||||
|
||||
---
|
||||
## 🚀Utfordring
|
||||
|
||||
Plott en annen variabel fra dette datasettet. Hint: rediger denne linjen: `X = X[:,2]`. Gitt målet for dette datasettet, hva kan du oppdage om utviklingen av diabetes som sykdom?
|
||||
## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Gjennomgang & Selvstudium
|
||||
|
||||
I denne opplæringen jobbet du med enkel lineær regresjon, i stedet for univariat eller multippel lineær regresjon. Les litt om forskjellene mellom disse metodene, eller ta en titt på [denne videoen](https://www.coursera.org/lecture/quantifying-relationships-regression-models/linear-vs-nonlinear-categorical-variables-ai2Ef).
|
||||
|
||||
Les mer om konseptet regresjon og tenk over hvilke typer spørsmål som kan besvares med denne teknikken. Ta denne [opplæringen](https://docs.microsoft.com/learn/modules/train-evaluate-regression-models?WT.mc_id=academic-77952-leestott) for å utdype forståelsen din.
|
||||
|
||||
## Oppgave
|
||||
|
||||
[Et annet datasett](assignment.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.
|
||||
@ -0,0 +1,27 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "74a5cf83e4ebc302afbcbc4f418afd0a",
|
||||
"translation_date": "2025-09-05T21:15:00+00:00",
|
||||
"source_file": "2-Regression/1-Tools/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Regressjon med Scikit-learn
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
Ta en titt på [Linnerud-datasettet](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_linnerud.html#sklearn.datasets.load_linnerud) i Scikit-learn. Dette datasettet har flere [målvariabler](https://scikit-learn.org/stable/datasets/toy_dataset.html#linnerrud-dataset): 'Det består av tre treningsvariabler (data) og tre fysiologiske variabler (mål) samlet inn fra tjue middelaldrende menn på et treningssenter'.
|
||||
|
||||
Med egne ord, beskriv hvordan man kan lage en regresjonsmodell som viser sammenhengen mellom midjemål og hvor mange situps som utføres. Gjør det samme for de andre datapunktene i dette datasettet.
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Eksemplarisk | Tilfredsstillende | Trenger forbedring |
|
||||
| ----------------------------- | ----------------------------------- | ----------------------------- | -------------------------- |
|
||||
| Send inn en beskrivende paragraf | En godt skrevet paragraf er sendt inn | Noen få setninger er sendt inn | Ingen beskrivelse er sendt inn |
|
||||
|
||||
---
|
||||
|
||||
**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 automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør 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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
|
||||
"translation_date": "2025-09-05T21:15:14+00:00",
|
||||
"source_file": "2-Regression/1-Tools/solution/Julia/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,226 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "7c077988328ebfe33b24d07945f16eca",
|
||||
"translation_date": "2025-09-05T21:16:31+00:00",
|
||||
"source_file": "2-Regression/2-Data/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Bygg en regresjonsmodell med Scikit-learn: forbered og visualiser data
|
||||
|
||||
|
||||
|
||||
Infografikk av [Dasani Madipalli](https://twitter.com/dasani_decoded)
|
||||
|
||||
## [Quiz før forelesning](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
> ### [Denne leksjonen er tilgjengelig i R!](../../../../2-Regression/2-Data/solution/R/lesson_2.html)
|
||||
|
||||
## Introduksjon
|
||||
|
||||
Nå som du har satt opp verktøyene du trenger for å begynne å bygge maskinlæringsmodeller med Scikit-learn, er du klar til å begynne å stille spørsmål til dataene dine. Når du jobber med data og bruker ML-løsninger, er det svært viktig å forstå hvordan du stiller de riktige spørsmålene for å utnytte potensialet i datasettet ditt.
|
||||
|
||||
I denne leksjonen vil du lære:
|
||||
|
||||
- Hvordan forberede dataene dine for modellbygging.
|
||||
- Hvordan bruke Matplotlib til datavisualisering.
|
||||
|
||||
## Stille de riktige spørsmålene til dataene dine
|
||||
|
||||
Spørsmålet du ønsker svar på vil avgjøre hvilken type ML-algoritmer du vil bruke. Og kvaliteten på svaret du får tilbake vil være sterkt avhengig av kvaliteten på dataene dine.
|
||||
|
||||
Ta en titt på [dataene](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) som er gitt for denne leksjonen. Du kan åpne denne .csv-filen i VS Code. Et raskt blikk viser umiddelbart at det finnes tomme felter og en blanding av tekst og numeriske data. Det er også en merkelig kolonne kalt 'Package' hvor dataene er en blanding av 'sacks', 'bins' og andre verdier. Dataene er faktisk litt rotete.
|
||||
|
||||
[](https://youtu.be/5qGjczWTrDQ "ML for nybegynnere - Hvordan analysere og rense et datasett")
|
||||
|
||||
> 🎥 Klikk på bildet over for en kort video som viser hvordan du forbereder dataene for denne leksjonen.
|
||||
|
||||
Det er faktisk ikke veldig vanlig å få et datasett som er helt klart til bruk for å lage en ML-modell rett ut av boksen. I denne leksjonen vil du lære hvordan du forbereder et rådatasett ved hjelp av standard Python-biblioteker. Du vil også lære ulike teknikker for å visualisere dataene.
|
||||
|
||||
## Case-studie: 'gresskarmarkedet'
|
||||
|
||||
I denne mappen finner du en .csv-fil i rotmappen `data` kalt [US-pumpkins.csv](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) som inneholder 1757 linjer med data om markedet for gresskar, sortert i grupper etter by. Dette er rådata hentet fra [Specialty Crops Terminal Markets Standard Reports](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) distribuert av United States Department of Agriculture.
|
||||
|
||||
### Forberede data
|
||||
|
||||
Disse dataene er i det offentlige domene. De kan lastes ned i mange separate filer, per by, fra USDA-nettstedet. For å unngå for mange separate filer har vi slått sammen alle bydataene til ett regneark, så vi har allerede _forberedt_ dataene litt. La oss nå ta en nærmere titt på dataene.
|
||||
|
||||
### Gresskardata - tidlige konklusjoner
|
||||
|
||||
Hva legger du merke til med disse dataene? Du har allerede sett at det er en blanding av tekst, tall, tomme felter og merkelige verdier som du må forstå.
|
||||
|
||||
Hvilket spørsmål kan du stille til disse dataene ved hjelp av en regresjonsteknikk? Hva med "Forutsi prisen på et gresskar som selges i løpet av en gitt måned". Når du ser på dataene igjen, er det noen endringer du må gjøre for å skape den datastrukturen som er nødvendig for oppgaven.
|
||||
|
||||
## Øvelse - analyser gresskardataene
|
||||
|
||||
La oss bruke [Pandas](https://pandas.pydata.org/), (navnet står for `Python Data Analysis`) et verktøy som er svært nyttig for å forme data, til å analysere og forberede disse gresskardataene.
|
||||
|
||||
### Først, sjekk for manglende datoer
|
||||
|
||||
Du må først ta steg for å sjekke for manglende datoer:
|
||||
|
||||
1. Konverter datoene til et månedsformat (disse er amerikanske datoer, så formatet er `MM/DD/YYYY`).
|
||||
2. Ekstraher måneden til en ny kolonne.
|
||||
|
||||
Åpne _notebook.ipynb_-filen i Visual Studio Code og importer regnearket til en ny Pandas dataframe.
|
||||
|
||||
1. Bruk funksjonen `head()` for å se de første fem radene.
|
||||
|
||||
```python
|
||||
import pandas as pd
|
||||
pumpkins = pd.read_csv('../data/US-pumpkins.csv')
|
||||
pumpkins.head()
|
||||
```
|
||||
|
||||
✅ Hvilken funksjon ville du brukt for å se de siste fem radene?
|
||||
|
||||
1. Sjekk om det er manglende data i den nåværende dataframen:
|
||||
|
||||
```python
|
||||
pumpkins.isnull().sum()
|
||||
```
|
||||
|
||||
Det er manglende data, men kanskje det ikke vil ha betydning for oppgaven.
|
||||
|
||||
1. For å gjøre dataframen din enklere å jobbe med, velg kun de kolonnene du trenger, ved å bruke funksjonen `loc` som henter ut en gruppe rader (gitt som første parameter) og kolonner (gitt som andre parameter) fra den originale dataframen. Uttrykket `:` i eksempelet nedenfor betyr "alle rader".
|
||||
|
||||
```python
|
||||
columns_to_select = ['Package', 'Low Price', 'High Price', 'Date']
|
||||
pumpkins = pumpkins.loc[:, columns_to_select]
|
||||
```
|
||||
|
||||
### Deretter, bestem gjennomsnittsprisen på gresskar
|
||||
|
||||
Tenk på hvordan du kan bestemme gjennomsnittsprisen på et gresskar i en gitt måned. Hvilke kolonner ville du valgt for denne oppgaven? Hint: du trenger 3 kolonner.
|
||||
|
||||
Løsning: ta gjennomsnittet av kolonnene `Low Price` og `High Price` for å fylle den nye kolonnen Price, og konverter Date-kolonnen til kun å vise måneden. Heldigvis, ifølge sjekken ovenfor, er det ingen manglende data for datoer eller priser.
|
||||
|
||||
1. For å beregne gjennomsnittet, legg til følgende kode:
|
||||
|
||||
```python
|
||||
price = (pumpkins['Low Price'] + pumpkins['High Price']) / 2
|
||||
|
||||
month = pd.DatetimeIndex(pumpkins['Date']).month
|
||||
|
||||
```
|
||||
|
||||
✅ Du kan gjerne skrive ut data du ønsker å sjekke ved å bruke `print(month)`.
|
||||
|
||||
2. Kopier deretter de konverterte dataene til en ny Pandas dataframe:
|
||||
|
||||
```python
|
||||
new_pumpkins = pd.DataFrame({'Month': month, 'Package': pumpkins['Package'], 'Low Price': pumpkins['Low Price'],'High Price': pumpkins['High Price'], 'Price': price})
|
||||
```
|
||||
|
||||
Hvis du skriver ut dataframen din, vil du se et rent og ryddig datasett som du kan bruke til å bygge din nye regresjonsmodell.
|
||||
|
||||
### Men vent! Det er noe merkelig her
|
||||
|
||||
Hvis du ser på kolonnen `Package`, blir gresskar solgt i mange forskjellige konfigurasjoner. Noen blir solgt i '1 1/9 bushel'-mål, og noen i '1/2 bushel'-mål, noen per gresskar, noen per pund, og noen i store bokser med varierende bredder.
|
||||
|
||||
> Gresskar virker veldig vanskelig å veie konsekvent
|
||||
|
||||
Når du graver i de originale dataene, er det interessant at alt med `Unit of Sale` lik 'EACH' eller 'PER BIN' også har `Package`-typen per tomme, per bin, eller 'each'. Gresskar virker veldig vanskelig å veie konsekvent, så la oss filtrere dem ved å velge kun gresskar med strengen 'bushel' i kolonnen `Package`.
|
||||
|
||||
1. Legg til et filter øverst i filen, under den opprinnelige .csv-importen:
|
||||
|
||||
```python
|
||||
pumpkins = pumpkins[pumpkins['Package'].str.contains('bushel', case=True, regex=True)]
|
||||
```
|
||||
|
||||
Hvis du skriver ut dataene nå, kan du se at du kun får de 415 eller så radene med data som inneholder gresskar per bushel.
|
||||
|
||||
### Men vent! Det er én ting til å gjøre
|
||||
|
||||
La du merke til at bushel-mengden varierer per rad? Du må normalisere prisingen slik at du viser prisen per bushel, så gjør litt matematikk for å standardisere det.
|
||||
|
||||
1. Legg til disse linjene etter blokken som oppretter new_pumpkins-dataframen:
|
||||
|
||||
```python
|
||||
new_pumpkins.loc[new_pumpkins['Package'].str.contains('1 1/9'), 'Price'] = price/(1 + 1/9)
|
||||
|
||||
new_pumpkins.loc[new_pumpkins['Package'].str.contains('1/2'), 'Price'] = price/(1/2)
|
||||
```
|
||||
|
||||
✅ Ifølge [The Spruce Eats](https://www.thespruceeats.com/how-much-is-a-bushel-1389308), avhenger vekten av en bushel av typen produkt, siden det er et volummål. "En bushel med tomater, for eksempel, skal veie 56 pund... Blader og grønnsaker tar opp mer plass med mindre vekt, så en bushel med spinat er bare 20 pund." Det er ganske komplisert! La oss ikke bry oss med å gjøre en bushel-til-pund-konvertering, og i stedet prise per bushel. All denne studien av bushels med gresskar viser imidlertid hvor viktig det er å forstå naturen til dataene dine!
|
||||
|
||||
Nå kan du analysere prisingen per enhet basert på deres bushel-mål. Hvis du skriver ut dataene en gang til, kan du se hvordan det er standardisert.
|
||||
|
||||
✅ La du merke til at gresskar som selges per halv-bushel er veldig dyre? Kan du finne ut hvorfor? Hint: små gresskar er mye dyrere enn store, sannsynligvis fordi det er så mange flere av dem per bushel, gitt det ubrukte rommet som tas opp av ett stort hullete pai-gresskar.
|
||||
|
||||
## Visualiseringsstrategier
|
||||
|
||||
En del av rollen til en dataforsker er å demonstrere kvaliteten og naturen til dataene de jobber med. For å gjøre dette lager de ofte interessante visualiseringer, eller diagrammer, grafer og tabeller, som viser ulike aspekter av dataene. På denne måten kan de visuelt vise relasjoner og mangler som ellers er vanskelig å avdekke.
|
||||
|
||||
[](https://youtu.be/SbUkxH6IJo0 "ML for nybegynnere - Hvordan visualisere data med Matplotlib")
|
||||
|
||||
> 🎥 Klikk på bildet over for en kort video som viser hvordan du visualiserer dataene for denne leksjonen.
|
||||
|
||||
Visualiseringer kan også hjelpe med å avgjøre hvilken maskinlæringsteknikk som er mest passende for dataene. Et spredningsdiagram som ser ut til å følge en linje, for eksempel, indikerer at dataene er en god kandidat for en lineær regresjonsøvelse.
|
||||
|
||||
Et datavisualiseringsbibliotek som fungerer godt i Jupyter-notebooks er [Matplotlib](https://matplotlib.org/) (som du også så i forrige leksjon).
|
||||
|
||||
> Få mer erfaring med datavisualisering i [disse opplæringene](https://docs.microsoft.com/learn/modules/explore-analyze-data-with-python?WT.mc_id=academic-77952-leestott).
|
||||
|
||||
## Øvelse - eksperimenter med Matplotlib
|
||||
|
||||
Prøv å lage noen grunnleggende diagrammer for å vise den nye dataframen du nettopp opprettet. Hva ville et grunnleggende linjediagram vise?
|
||||
|
||||
1. Importer Matplotlib øverst i filen, under Pandas-importen:
|
||||
|
||||
```python
|
||||
import matplotlib.pyplot as plt
|
||||
```
|
||||
|
||||
1. Kjør hele notebooken på nytt for å oppdatere.
|
||||
1. Nederst i notebooken, legg til en celle for å plotte dataene som en boks:
|
||||
|
||||
```python
|
||||
price = new_pumpkins.Price
|
||||
month = new_pumpkins.Month
|
||||
plt.scatter(price, month)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Er dette et nyttig diagram? Overrasker noe ved det deg?
|
||||
|
||||
Det er ikke spesielt nyttig, da alt det gjør er å vise dataene dine som en spredning av punkter i en gitt måned.
|
||||
|
||||
### Gjør det nyttig
|
||||
|
||||
For å få diagrammer til å vise nyttige data, må du vanligvis gruppere dataene på en eller annen måte. La oss prøve å lage et diagram hvor y-aksen viser månedene og dataene demonstrerer distribusjonen av data.
|
||||
|
||||
1. Legg til en celle for å lage et gruppert stolpediagram:
|
||||
|
||||
```python
|
||||
new_pumpkins.groupby(['Month'])['Price'].mean().plot(kind='bar')
|
||||
plt.ylabel("Pumpkin Price")
|
||||
```
|
||||
|
||||
|
||||
|
||||
Dette er en mer nyttig datavisualisering! Det ser ut til å indikere at den høyeste prisen for gresskar forekommer i september og oktober. Stemmer det med forventningene dine? Hvorfor eller hvorfor ikke?
|
||||
|
||||
---
|
||||
|
||||
## 🚀Utfordring
|
||||
|
||||
Utforsk de forskjellige typene visualiseringer som Matplotlib tilbyr. Hvilke typer er mest passende for regresjonsproblemer?
|
||||
|
||||
## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Gjennomgang & Selvstudium
|
||||
|
||||
Ta en titt på de mange måtene å visualisere data på. Lag en liste over de ulike bibliotekene som er tilgjengelige og noter hvilke som er best for gitte typer oppgaver, for eksempel 2D-visualiseringer vs. 3D-visualiseringer. Hva oppdager du?
|
||||
|
||||
## Oppgave
|
||||
|
||||
[Utforsk visualisering](assignment.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.
|
||||
@ -0,0 +1,23 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "4485a1ed4dd1b5647365e3d87456515d",
|
||||
"translation_date": "2025-09-05T21:17:12+00:00",
|
||||
"source_file": "2-Regression/2-Data/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Utforske Visualiseringer
|
||||
|
||||
Det finnes flere forskjellige biblioteker tilgjengelige for datavisualisering. Lag noen visualiseringer ved hjelp av Gresskar-dataene i denne leksjonen med matplotlib og seaborn i en eksempel-notatbok. Hvilke biblioteker er enklest å jobbe med?
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Eksemplarisk | Tilfredsstillende | Trenger Forbedring |
|
||||
| --------- | ------------ | ----------------- | ------------------- |
|
||||
| | En notatbok er levert med to utforskninger/visualiseringer | En notatbok er levert med én utforskning/visualisering | En notatbok er ikke levert |
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
|
||||
"translation_date": "2025-09-05T21:17:24+00:00",
|
||||
"source_file": "2-Regression/2-Data/solution/Julia/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,25 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "cc471fa89c293bc735dd3a9a0fb79b1b",
|
||||
"translation_date": "2025-09-05T21:08:34+00:00",
|
||||
"source_file": "2-Regression/3-Linear/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Lag en regresjonsmodell
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
I denne leksjonen lærte du hvordan du bygger en modell ved hjelp av både lineær og polynomisk regresjon. Bruk denne kunnskapen til å finne et datasett eller bruk ett av Scikit-learns innebygde datasett for å lage en ny modell. Forklar i notatboken din hvorfor du valgte teknikken du gjorde, og demonstrer modellens nøyaktighet. Hvis den ikke er nøyaktig, forklar hvorfor.
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Eksemplarisk | Tilfredsstillende | Trenger forbedring |
|
||||
| --------- | ---------------------------------------------------------- | -------------------------- | ------------------------------ |
|
||||
| | presenterer en fullstendig notatbok med en godt dokumentert løsning | løsningen er ufullstendig | løsningen er mangelfull eller feilaktig |
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
|
||||
"translation_date": "2025-09-05T21:08:45+00:00",
|
||||
"source_file": "2-Regression/3-Linear/solution/Julia/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,408 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "abf86d845c84330bce205a46b382ec88",
|
||||
"translation_date": "2025-09-05T21:11:16+00:00",
|
||||
"source_file": "2-Regression/4-Logistic/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Logistisk regresjon for å forutsi kategorier
|
||||
|
||||
|
||||
|
||||
## [Quiz før forelesning](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
> ### [Denne leksjonen er tilgjengelig i R!](../../../../2-Regression/4-Logistic/solution/R/lesson_4.html)
|
||||
|
||||
## Introduksjon
|
||||
|
||||
I denne siste leksjonen om regresjon, en av de grunnleggende _klassiske_ ML-teknikkene, skal vi se nærmere på logistisk regresjon. Du kan bruke denne teknikken til å oppdage mønstre for å forutsi binære kategorier. Er dette godteri sjokolade eller ikke? Er denne sykdommen smittsom eller ikke? Vil denne kunden velge dette produktet eller ikke?
|
||||
|
||||
I denne leksjonen vil du lære:
|
||||
|
||||
- Et nytt bibliotek for datavisualisering
|
||||
- Teknikker for logistisk regresjon
|
||||
|
||||
✅ Fordyp deg i å arbeide med denne typen regresjon i dette [Learn-modulet](https://docs.microsoft.com/learn/modules/train-evaluate-classification-models?WT.mc_id=academic-77952-leestott)
|
||||
|
||||
## Forutsetning
|
||||
|
||||
Etter å ha jobbet med gresskar-dataene, er vi nå kjent nok med dem til å innse at det finnes én binær kategori vi kan jobbe med: `Color`.
|
||||
|
||||
La oss bygge en logistisk regresjonsmodell for å forutsi, gitt noen variabler, _hvilken farge et gitt gresskar sannsynligvis har_ (oransje 🎃 eller hvit 👻).
|
||||
|
||||
> Hvorfor snakker vi om binær klassifisering i en leksjon om regresjon? Bare av språklig bekvemmelighet, siden logistisk regresjon [egentlig er en klassifiseringsmetode](https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression), om enn en lineær-basert en. Lær om andre måter å klassifisere data på i neste leksjonsgruppe.
|
||||
|
||||
## Definer spørsmålet
|
||||
|
||||
For vårt formål vil vi uttrykke dette som en binær: 'Hvit' eller 'Ikke hvit'. Det finnes også en 'stripet' kategori i datasettet vårt, men det er få forekomster av den, så vi vil ikke bruke den. Den forsvinner uansett når vi fjerner nullverdier fra datasettet.
|
||||
|
||||
> 🎃 Fun fact: Vi kaller noen ganger hvite gresskar for 'spøkelsesgresskar'. De er ikke veldig lette å skjære ut, så de er ikke like populære som de oransje, men de ser kule ut! Så vi kunne også formulert spørsmålet vårt som: 'Spøkelse' eller 'Ikke spøkelse'. 👻
|
||||
|
||||
## Om logistisk regresjon
|
||||
|
||||
Logistisk regresjon skiller seg fra lineær regresjon, som du lærte om tidligere, på noen viktige måter.
|
||||
|
||||
[](https://youtu.be/KpeCT6nEpBY "ML for nybegynnere - Forstå logistisk regresjon for maskinlæringsklassifisering")
|
||||
|
||||
> 🎥 Klikk på bildet ovenfor for en kort videooversikt over logistisk regresjon.
|
||||
|
||||
### Binær klassifisering
|
||||
|
||||
Logistisk regresjon tilbyr ikke de samme funksjonene som lineær regresjon. Den førstnevnte gir en prediksjon om en binær kategori ("hvit eller ikke hvit"), mens den sistnevnte er i stand til å forutsi kontinuerlige verdier, for eksempel gitt opprinnelsen til et gresskar og tidspunktet for innhøstingen, _hvor mye prisen vil stige_.
|
||||
|
||||
|
||||
> Infografikk av [Dasani Madipalli](https://twitter.com/dasani_decoded)
|
||||
|
||||
### Andre klassifiseringer
|
||||
|
||||
Det finnes andre typer logistisk regresjon, inkludert multinomial og ordinal:
|
||||
|
||||
- **Multinomial**, som innebærer å ha mer enn én kategori - "Oransje, Hvit og Stripet".
|
||||
- **Ordinal**, som innebærer ordnede kategorier, nyttig hvis vi ønsket å ordne resultatene våre logisk, som våre gresskar som er ordnet etter et begrenset antall størrelser (mini, sm, med, lg, xl, xxl).
|
||||
|
||||
|
||||
|
||||
### Variabler trenger IKKE å korrelere
|
||||
|
||||
Husker du hvordan lineær regresjon fungerte bedre med mer korrelerte variabler? Logistisk regresjon er det motsatte - variablene trenger ikke å samsvare. Dette fungerer for disse dataene som har noe svake korrelasjoner.
|
||||
|
||||
### Du trenger mye rene data
|
||||
|
||||
Logistisk regresjon gir mer nøyaktige resultater hvis du bruker mer data; vårt lille datasett er ikke optimalt for denne oppgaven, så husk det.
|
||||
|
||||
[](https://youtu.be/B2X4H9vcXTs "ML for nybegynnere - Dataanalyse og forberedelse for logistisk regresjon")
|
||||
|
||||
> 🎥 Klikk på bildet ovenfor for en kort videooversikt over forberedelse av data for lineær regresjon
|
||||
|
||||
✅ Tenk på hvilke typer data som egner seg godt for logistisk regresjon
|
||||
|
||||
## Øvelse - rydd opp i dataene
|
||||
|
||||
Først, rydd opp i dataene litt, fjern nullverdier og velg bare noen av kolonnene:
|
||||
|
||||
1. Legg til følgende kode:
|
||||
|
||||
```python
|
||||
|
||||
columns_to_select = ['City Name','Package','Variety', 'Origin','Item Size', 'Color']
|
||||
pumpkins = full_pumpkins.loc[:, columns_to_select]
|
||||
|
||||
pumpkins.dropna(inplace=True)
|
||||
```
|
||||
|
||||
Du kan alltid ta en titt på din nye dataframe:
|
||||
|
||||
```python
|
||||
pumpkins.info
|
||||
```
|
||||
|
||||
### Visualisering - kategorisk plott
|
||||
|
||||
Nå har du lastet opp [startnotatboken](../../../../2-Regression/4-Logistic/notebook.ipynb) med gresskar-data igjen og ryddet den slik at du har et datasett som inneholder noen få variabler, inkludert `Color`. La oss visualisere dataene i notatboken ved hjelp av et annet bibliotek: [Seaborn](https://seaborn.pydata.org/index.html), som er bygget på Matplotlib som vi brukte tidligere.
|
||||
|
||||
Seaborn tilbyr noen smarte måter å visualisere dataene dine på. For eksempel kan du sammenligne distribusjoner av dataene for hver `Variety` og `Color` i et kategorisk plott.
|
||||
|
||||
1. Lag et slikt plott ved å bruke funksjonen `catplot`, med gresskar-dataene `pumpkins`, og spesifisere en fargekartlegging for hver gresskarkategori (oransje eller hvit):
|
||||
|
||||
```python
|
||||
import seaborn as sns
|
||||
|
||||
palette = {
|
||||
'ORANGE': 'orange',
|
||||
'WHITE': 'wheat',
|
||||
}
|
||||
|
||||
sns.catplot(
|
||||
data=pumpkins, y="Variety", hue="Color", kind="count",
|
||||
palette=palette,
|
||||
)
|
||||
```
|
||||
|
||||
|
||||
|
||||
Ved å observere dataene kan du se hvordan `Color`-dataene relaterer seg til `Variety`.
|
||||
|
||||
✅ Gitt dette kategoriske plottet, hvilke interessante utforskninger kan du forestille deg?
|
||||
|
||||
### Datapreprosessering: funksjons- og etikettkoding
|
||||
Datasettet vårt inneholder strengverdier for alle kolonnene. Å jobbe med kategoriske data er intuitivt for mennesker, men ikke for maskiner. Maskinlæringsalgoritmer fungerer godt med tall. Derfor er koding et veldig viktig steg i datapreprosesseringen, siden det lar oss gjøre kategoriske data om til numeriske data, uten å miste informasjon. God koding fører til å bygge en god modell.
|
||||
|
||||
For funksjonskoding finnes det to hovedtyper av kodere:
|
||||
|
||||
1. Ordinal koder: passer godt for ordinale variabler, som er kategoriske variabler der dataene følger en logisk rekkefølge, som kolonnen `Item Size` i datasettet vårt. Den lager en kartlegging slik at hver kategori representeres av et tall, som er rekkefølgen til kategorien i kolonnen.
|
||||
|
||||
```python
|
||||
from sklearn.preprocessing import OrdinalEncoder
|
||||
|
||||
item_size_categories = [['sml', 'med', 'med-lge', 'lge', 'xlge', 'jbo', 'exjbo']]
|
||||
ordinal_features = ['Item Size']
|
||||
ordinal_encoder = OrdinalEncoder(categories=item_size_categories)
|
||||
```
|
||||
|
||||
2. Kategorisk koder: passer godt for nominelle variabler, som er kategoriske variabler der dataene ikke følger en logisk rekkefølge, som alle funksjonene bortsett fra `Item Size` i datasettet vårt. Det er en one-hot encoding, som betyr at hver kategori representeres av en binær kolonne: den kodede variabelen er lik 1 hvis gresskaret tilhører den `Variety` og 0 ellers.
|
||||
|
||||
```python
|
||||
from sklearn.preprocessing import OneHotEncoder
|
||||
|
||||
categorical_features = ['City Name', 'Package', 'Variety', 'Origin']
|
||||
categorical_encoder = OneHotEncoder(sparse_output=False)
|
||||
```
|
||||
Deretter brukes `ColumnTransformer` til å kombinere flere kodere i ett enkelt steg og anvende dem på de riktige kolonnene.
|
||||
|
||||
```python
|
||||
from sklearn.compose import ColumnTransformer
|
||||
|
||||
ct = ColumnTransformer(transformers=[
|
||||
('ord', ordinal_encoder, ordinal_features),
|
||||
('cat', categorical_encoder, categorical_features)
|
||||
])
|
||||
|
||||
ct.set_output(transform='pandas')
|
||||
encoded_features = ct.fit_transform(pumpkins)
|
||||
```
|
||||
For å kode etiketten bruker vi scikit-learn-klassen `LabelEncoder`, som er en hjelpeklasse for å normalisere etiketter slik at de bare inneholder verdier mellom 0 og n_classes-1 (her, 0 og 1).
|
||||
|
||||
```python
|
||||
from sklearn.preprocessing import LabelEncoder
|
||||
|
||||
label_encoder = LabelEncoder()
|
||||
encoded_label = label_encoder.fit_transform(pumpkins['Color'])
|
||||
```
|
||||
Når vi har kodet funksjonene og etiketten, kan vi slå dem sammen til en ny dataframe `encoded_pumpkins`.
|
||||
|
||||
```python
|
||||
encoded_pumpkins = encoded_features.assign(Color=encoded_label)
|
||||
```
|
||||
✅ Hva er fordelene med å bruke en ordinal koder for kolonnen `Item Size`?
|
||||
|
||||
### Analyser forholdet mellom variabler
|
||||
|
||||
Nå som vi har forhåndsprosesserte dataene, kan vi analysere forholdet mellom funksjonene og etiketten for å få en idé om hvor godt modellen vil kunne forutsi etiketten gitt funksjonene.
|
||||
Den beste måten å utføre denne typen analyse på er å plotte dataene. Vi bruker igjen Seaborn-funksjonen `catplot` for å visualisere forholdet mellom `Item Size`, `Variety` og `Color` i et kategorisk plott. For å bedre plotte dataene bruker vi den kodede kolonnen `Item Size` og den ukodede kolonnen `Variety`.
|
||||
|
||||
```python
|
||||
palette = {
|
||||
'ORANGE': 'orange',
|
||||
'WHITE': 'wheat',
|
||||
}
|
||||
pumpkins['Item Size'] = encoded_pumpkins['ord__Item Size']
|
||||
|
||||
g = sns.catplot(
|
||||
data=pumpkins,
|
||||
x="Item Size", y="Color", row='Variety',
|
||||
kind="box", orient="h",
|
||||
sharex=False, margin_titles=True,
|
||||
height=1.8, aspect=4, palette=palette,
|
||||
)
|
||||
g.set(xlabel="Item Size", ylabel="").set(xlim=(0,6))
|
||||
g.set_titles(row_template="{row_name}")
|
||||
```
|
||||
|
||||
|
||||
### Bruk et swarm-plott
|
||||
|
||||
Siden `Color` er en binær kategori (Hvit eller Ikke), trenger den 'en [spesialisert tilnærming](https://seaborn.pydata.org/tutorial/categorical.html?highlight=bar) til visualisering'. Det finnes andre måter å visualisere forholdet mellom denne kategorien og andre variabler.
|
||||
|
||||
Du kan visualisere variabler side om side med Seaborn-plott.
|
||||
|
||||
1. Prøv et 'swarm'-plott for å vise distribusjonen av verdier:
|
||||
|
||||
```python
|
||||
palette = {
|
||||
0: 'orange',
|
||||
1: 'wheat'
|
||||
}
|
||||
sns.swarmplot(x="Color", y="ord__Item Size", data=encoded_pumpkins, palette=palette)
|
||||
```
|
||||
|
||||
|
||||
|
||||
**Vær oppmerksom**: koden ovenfor kan generere en advarsel, siden Seaborn har problemer med å representere så mange datapunkter i et swarm-plott. En mulig løsning er å redusere størrelsen på markøren ved å bruke parameteren 'size'. Vær imidlertid oppmerksom på at dette påvirker lesbarheten til plottet.
|
||||
|
||||
> **🧮 Vis meg matematikken**
|
||||
>
|
||||
> Logistisk regresjon baserer seg på konseptet 'maksimal sannsynlighet' ved bruk av [sigmoid-funksjoner](https://wikipedia.org/wiki/Sigmoid_function). En 'Sigmoid-funksjon' på et plott ser ut som en 'S'-form. Den tar en verdi og kartlegger den til et sted mellom 0 og 1. Kurven kalles også en 'logistisk kurve'. Formelen ser slik ut:
|
||||
>
|
||||
> 
|
||||
>
|
||||
> der sigmoids midtpunkt befinner seg ved x's 0-punkt, L er kurvens maksimumsverdi, og k er kurvens bratthet. Hvis resultatet av funksjonen er mer enn 0.5, vil etiketten i spørsmålet bli gitt klassen '1' av det binære valget. Hvis ikke, vil den bli klassifisert som '0'.
|
||||
|
||||
## Bygg modellen din
|
||||
|
||||
Å bygge en modell for å finne disse binære klassifiseringene er overraskende enkelt i Scikit-learn.
|
||||
|
||||
[](https://youtu.be/MmZS2otPrQ8 "ML for nybegynnere - Logistisk regresjon for klassifisering av data")
|
||||
|
||||
> 🎥 Klikk på bildet ovenfor for en kort videooversikt over å bygge en lineær regresjonsmodell
|
||||
|
||||
1. Velg variablene du vil bruke i klassifiseringsmodellen din og del opp trenings- og testsett ved å kalle `train_test_split()`:
|
||||
|
||||
```python
|
||||
from sklearn.model_selection import train_test_split
|
||||
|
||||
X = encoded_pumpkins[encoded_pumpkins.columns.difference(['Color'])]
|
||||
y = encoded_pumpkins['Color']
|
||||
|
||||
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
|
||||
|
||||
```
|
||||
|
||||
2. Nå kan du trene modellen din ved å kalle `fit()` med treningsdataene dine, og skrive ut resultatet:
|
||||
|
||||
```python
|
||||
from sklearn.metrics import f1_score, classification_report
|
||||
from sklearn.linear_model import LogisticRegression
|
||||
|
||||
model = LogisticRegression()
|
||||
model.fit(X_train, y_train)
|
||||
predictions = model.predict(X_test)
|
||||
|
||||
print(classification_report(y_test, predictions))
|
||||
print('Predicted labels: ', predictions)
|
||||
print('F1-score: ', f1_score(y_test, predictions))
|
||||
```
|
||||
|
||||
Ta en titt på modellens resultattavle. Det er ikke dårlig, med tanke på at du bare har rundt 1000 rader med data:
|
||||
|
||||
```output
|
||||
precision recall f1-score support
|
||||
|
||||
0 0.94 0.98 0.96 166
|
||||
1 0.85 0.67 0.75 33
|
||||
|
||||
accuracy 0.92 199
|
||||
macro avg 0.89 0.82 0.85 199
|
||||
weighted avg 0.92 0.92 0.92 199
|
||||
|
||||
Predicted labels: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0
|
||||
0 0 0 0 0 1 0 1 0 0 1 0 0 0 0 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
|
||||
1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0
|
||||
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0
|
||||
0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
|
||||
0 0 0 1 0 0 0 0 0 0 0 0 1 1]
|
||||
F1-score: 0.7457627118644068
|
||||
```
|
||||
|
||||
## Bedre forståelse via en forvirringsmatrise
|
||||
|
||||
Mens du kan få en resultattavlerapport [termer](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html?highlight=classification_report#sklearn.metrics.classification_report) ved å skrive ut elementene ovenfor, kan du kanskje forstå modellen din bedre ved å bruke en [forvirringsmatrise](https://scikit-learn.org/stable/modules/model_evaluation.html#confusion-matrix) for å hjelpe oss med å forstå hvordan modellen presterer.
|
||||
|
||||
> 🎓 En '[forvirringsmatrise](https://wikipedia.org/wiki/Confusion_matrix)' (eller 'feilmatrise') er en tabell som uttrykker modellens sanne vs. falske positive og negative, og dermed måler nøyaktigheten av prediksjonene.
|
||||
|
||||
1. For å bruke en forvirringsmatrise, kall `confusion_matrix()`:
|
||||
|
||||
```python
|
||||
from sklearn.metrics import confusion_matrix
|
||||
confusion_matrix(y_test, predictions)
|
||||
```
|
||||
|
||||
Ta en titt på modellens forvirringsmatrise:
|
||||
|
||||
```output
|
||||
array([[162, 4],
|
||||
[ 11, 22]])
|
||||
```
|
||||
|
||||
I Scikit-learn er rader (akse 0) faktiske etiketter og kolonner (akse 1) predikerte etiketter.
|
||||
|
||||
| | 0 | 1 |
|
||||
| :---: | :---: | :---: |
|
||||
| 0 | TN | FP |
|
||||
| 1 | FN | TP |
|
||||
|
||||
Hva skjer her? La oss si at modellen vår blir bedt om å klassifisere gresskar mellom to binære kategorier, kategori 'hvit' og kategori 'ikke-hvit'.
|
||||
|
||||
- Hvis modellen din forutsier et gresskar som ikke hvitt og det faktisk tilhører kategorien 'ikke-hvit', kaller vi det en sann negativ, vist av det øverste venstre tallet.
|
||||
- Hvis modellen din forutsier et gresskar som hvitt og det faktisk tilhører kategorien 'ikke-hvit', kaller vi det en falsk negativ, vist av det nederste venstre tallet.
|
||||
- Hvis modellen din forutsier et gresskar som ikke hvitt og det faktisk tilhører kategorien 'hvit', kaller vi det en falsk positiv, vist av det øverste høyre tallet.
|
||||
- Hvis modellen din forutsier et gresskar som hvitt og det faktisk tilhører kategorien 'hvit', kaller vi det en sann positiv, vist av det nederste høyre tallet.
|
||||
|
||||
Som du kanskje har gjettet, er det å foretrekke å ha et større antall sanne positive og sanne negative og et lavere antall falske positive og falske negative, noe som innebærer at modellen presterer bedre.
|
||||
Hvordan henger forvirringsmatrisen sammen med presisjon og tilbakekalling? Husk, klassifiseringsrapporten som ble skrevet ut ovenfor viste presisjon (0.85) og tilbakekalling (0.67).
|
||||
|
||||
Presisjon = tp / (tp + fp) = 22 / (22 + 4) = 0.8461538461538461
|
||||
|
||||
Tilbakekalling = tp / (tp + fn) = 22 / (22 + 11) = 0.6666666666666666
|
||||
|
||||
✅ Spørsmål: Ifølge forvirringsmatrisen, hvordan gjorde modellen det? Svar: Ikke dårlig; det er et godt antall sanne negative, men også noen få falske negative.
|
||||
|
||||
La oss gå tilbake til begrepene vi så tidligere ved hjelp av forvirringsmatrisens kartlegging av TP/TN og FP/FN:
|
||||
|
||||
🎓 Presisjon: TP/(TP + FP) Andelen relevante instanser blant de hentede instansene (f.eks. hvilke etiketter som ble godt merket)
|
||||
|
||||
🎓 Tilbakekalling: TP/(TP + FN) Andelen relevante instanser som ble hentet, enten de var godt merket eller ikke
|
||||
|
||||
🎓 f1-score: (2 * presisjon * tilbakekalling)/(presisjon + tilbakekalling) Et vektet gjennomsnitt av presisjon og tilbakekalling, der det beste er 1 og det verste er 0
|
||||
|
||||
🎓 Støtte: Antall forekomster av hver etikett som ble hentet
|
||||
|
||||
🎓 Nøyaktighet: (TP + TN)/(TP + TN + FP + FN) Prosentandelen av etiketter som ble korrekt forutsagt for et utvalg.
|
||||
|
||||
🎓 Makro Gjennomsnitt: Beregningen av det uvektede gjennomsnittet av metrikker for hver etikett, uten å ta hensyn til ubalanse i etiketter.
|
||||
|
||||
🎓 Vektet Gjennomsnitt: Beregningen av gjennomsnittet av metrikker for hver etikett, som tar hensyn til ubalanse i etiketter ved å vekte dem etter deres støtte (antall sanne instanser for hver etikett).
|
||||
|
||||
✅ Kan du tenke deg hvilken metrikk du bør følge med på hvis du vil at modellen din skal redusere antall falske negative?
|
||||
|
||||
## Visualiser ROC-kurven for denne modellen
|
||||
|
||||
[](https://youtu.be/GApO575jTA0 "ML for nybegynnere - Analyse av logistisk regresjonsytelse med ROC-kurver")
|
||||
|
||||
|
||||
> 🎥 Klikk på bildet ovenfor for en kort videooversikt over ROC-kurver
|
||||
|
||||
La oss gjøre én visualisering til for å se den såkalte 'ROC'-kurven:
|
||||
|
||||
```python
|
||||
from sklearn.metrics import roc_curve, roc_auc_score
|
||||
import matplotlib
|
||||
import matplotlib.pyplot as plt
|
||||
%matplotlib inline
|
||||
|
||||
y_scores = model.predict_proba(X_test)
|
||||
fpr, tpr, thresholds = roc_curve(y_test, y_scores[:,1])
|
||||
|
||||
fig = plt.figure(figsize=(6, 6))
|
||||
plt.plot([0, 1], [0, 1], 'k--')
|
||||
plt.plot(fpr, tpr)
|
||||
plt.xlabel('False Positive Rate')
|
||||
plt.ylabel('True Positive Rate')
|
||||
plt.title('ROC Curve')
|
||||
plt.show()
|
||||
```
|
||||
|
||||
Ved hjelp av Matplotlib, plott modellens [Receiving Operating Characteristic](https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html?highlight=roc) eller ROC. ROC-kurver brukes ofte for å få en oversikt over utdataene fra en klassifiserer i form av sanne vs. falske positive. "ROC-kurver har vanligvis sanne positive på Y-aksen, og falske positive på X-aksen." Dermed er brattheten på kurven og avstanden mellom midtlinjen og kurven viktig: du vil ha en kurve som raskt går opp og over linjen. I vårt tilfelle er det falske positive i starten, og deretter går linjen opp og over riktig:
|
||||
|
||||
|
||||
|
||||
Til slutt, bruk Scikit-learns [`roc_auc_score` API](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_auc_score.html?highlight=roc_auc#sklearn.metrics.roc_auc_score) for å beregne den faktiske 'Area Under the Curve' (AUC):
|
||||
|
||||
```python
|
||||
auc = roc_auc_score(y_test,y_scores[:,1])
|
||||
print(auc)
|
||||
```
|
||||
Resultatet er `0.9749908725812341`. Siden AUC varierer fra 0 til 1, ønsker du en høy score, ettersom en modell som er 100 % korrekt i sine prediksjoner vil ha en AUC på 1; i dette tilfellet er modellen _ganske god_.
|
||||
|
||||
I fremtidige leksjoner om klassifiseringer vil du lære hvordan du kan iterere for å forbedre modellens resultater. Men for nå, gratulerer! Du har fullført disse regresjonsleksjonene!
|
||||
|
||||
---
|
||||
## 🚀Utfordring
|
||||
|
||||
Det er mye mer å utforske når det gjelder logistisk regresjon! Men den beste måten å lære på er å eksperimentere. Finn et datasett som egner seg til denne typen analyse og bygg en modell med det. Hva lærer du? tips: prøv [Kaggle](https://www.kaggle.com/search?q=logistic+regression+datasets) for interessante datasett.
|
||||
|
||||
## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Gjennomgang & Selvstudium
|
||||
|
||||
Les de første sidene av [denne artikkelen fra Stanford](https://web.stanford.edu/~jurafsky/slp3/5.pdf) om noen praktiske bruksområder for logistisk regresjon. Tenk på oppgaver som egner seg bedre for den ene eller den andre typen regresjonsoppgaver som vi har studert så langt. Hva ville fungert best?
|
||||
|
||||
## Oppgave
|
||||
|
||||
[Prøv denne regresjonen på nytt](assignment.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.
|
||||
@ -0,0 +1,25 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "8af40209a41494068c1f42b14c0b450d",
|
||||
"translation_date": "2025-09-05T21:12:13+00:00",
|
||||
"source_file": "2-Regression/4-Logistic/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Prøve på nytt med regresjon
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
I leksjonen brukte du et utvalg av gresskar-dataene. Nå skal du gå tilbake til de originale dataene og prøve å bruke alt, renset og standardisert, for å bygge en logistisk regresjonsmodell.
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Fremragende | Tilfredsstillende | Trenger forbedring |
|
||||
| --------- | ---------------------------------------------------------------------- | ------------------------------------------------------------ | ----------------------------------------------------------- |
|
||||
| | En notebook presenteres med en godt forklart og velfungerende modell | En notebook presenteres med en modell som fungerer minimalt | En notebook presenteres med en modell som fungerer dårlig eller ingen modell |
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
|
||||
"translation_date": "2025-09-05T21:12:24+00:00",
|
||||
"source_file": "2-Regression/4-Logistic/solution/Julia/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,54 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "508582278dbb8edd2a8a80ac96ef416c",
|
||||
"translation_date": "2025-09-05T21:05:04+00:00",
|
||||
"source_file": "2-Regression/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Regresjonsmodeller for maskinlæring
|
||||
## Regionalt tema: Regresjonsmodeller for gresskarpriser i Nord-Amerika 🎃
|
||||
|
||||
I Nord-Amerika blir gresskar ofte skåret ut til skumle ansikter for Halloween. La oss utforske mer om disse fascinerende grønnsakene!
|
||||
|
||||
|
||||
> Foto av <a href="https://unsplash.com/@teutschmann?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Beth Teutschmann</a> på <a href="https://unsplash.com/s/photos/jack-o-lanterns?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
|
||||
|
||||
## Hva du vil lære
|
||||
|
||||
[](https://youtu.be/5QnJtDad4iQ "Introduksjonsvideo om regresjon - Klikk for å se!")
|
||||
> 🎥 Klikk på bildet over for en rask introduksjonsvideo til denne leksjonen
|
||||
|
||||
Leksjonene i denne delen dekker typer regresjon i konteksten av maskinlæring. Regresjonsmodeller kan hjelpe med å bestemme _forholdet_ mellom variabler. Denne typen modell kan forutsi verdier som lengde, temperatur eller alder, og dermed avdekke sammenhenger mellom variabler mens den analyserer datapunkter.
|
||||
|
||||
I denne serien av leksjoner vil du oppdage forskjellene mellom lineær og logistisk regresjon, og når du bør velge den ene fremfor den andre.
|
||||
|
||||
[](https://youtu.be/XA3OaoW86R8 "ML for nybegynnere - Introduksjon til regresjonsmodeller for maskinlæring")
|
||||
|
||||
> 🎥 Klikk på bildet over for en kort video som introduserer regresjonsmodeller.
|
||||
|
||||
I denne gruppen av leksjoner vil du bli satt opp for å begynne med maskinlæringsoppgaver, inkludert konfigurering av Visual Studio Code for å administrere notebooks, det vanlige miljøet for dataforskere. Du vil oppdage Scikit-learn, et bibliotek for maskinlæring, og du vil bygge dine første modeller, med fokus på regresjonsmodeller i dette kapittelet.
|
||||
|
||||
> Det finnes nyttige lavkodeverktøy som kan hjelpe deg med å lære om arbeid med regresjonsmodeller. Prøv [Azure ML for denne oppgaven](https://docs.microsoft.com/learn/modules/create-regression-model-azure-machine-learning-designer/?WT.mc_id=academic-77952-leestott)
|
||||
|
||||
### Leksjoner
|
||||
|
||||
1. [Verktøyene du trenger](1-Tools/README.md)
|
||||
2. [Administrere data](2-Data/README.md)
|
||||
3. [Lineær og polynomisk regresjon](3-Linear/README.md)
|
||||
4. [Logistisk regresjon](4-Logistic/README.md)
|
||||
|
||||
---
|
||||
### Krediteringer
|
||||
|
||||
"ML med regresjon" ble skrevet med ♥️ av [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
♥️ Quiz-bidragsytere inkluderer: [Muhammad Sakib Khan Inan](https://twitter.com/Sakibinan) og [Ornella Altunyan](https://twitter.com/ornelladotcom)
|
||||
|
||||
Gresskardatasettet er foreslått av [dette prosjektet på Kaggle](https://www.kaggle.com/usda/a-year-of-pumpkin-prices), og dets data er hentet fra [Specialty Crops Terminal Markets Standard Reports](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) distribuert av United States Department of Agriculture. Vi har lagt til noen punkter rundt farge basert på variasjon for å normalisere distribusjonen. Disse dataene er i det offentlige domene.
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,359 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "e0b75f73e4a90d45181dc5581fe2ef5c",
|
||||
"translation_date": "2025-09-05T21:47:31+00:00",
|
||||
"source_file": "3-Web-App/1-Web-App/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Bygg en webapplikasjon for å bruke en ML-modell
|
||||
|
||||
I denne leksjonen skal du trene en ML-modell på et datasett som er helt utenomjordisk: _UFO-observasjoner fra det siste århundret_, hentet fra NUFORCs database.
|
||||
|
||||
Du vil lære:
|
||||
|
||||
- Hvordan 'pickle' en trent modell
|
||||
- Hvordan bruke den modellen i en Flask-applikasjon
|
||||
|
||||
Vi fortsetter å bruke notebooks for å rense data og trene modellen vår, men du kan ta prosessen et steg videre ved å utforske hvordan man bruker en modell "ute i det fri", så å si: i en webapplikasjon.
|
||||
|
||||
For å gjøre dette må du bygge en webapplikasjon ved hjelp av Flask.
|
||||
|
||||
## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Bygge en applikasjon
|
||||
|
||||
Det finnes flere måter å bygge webapplikasjoner som kan bruke maskinlæringsmodeller. Din webarkitektur kan påvirke hvordan modellen din blir trent. Tenk deg at du jobber i en bedrift der data science-gruppen har trent en modell som de vil at du skal bruke i en applikasjon.
|
||||
|
||||
### Vurderinger
|
||||
|
||||
Det er mange spørsmål du må stille:
|
||||
|
||||
- **Er det en webapplikasjon eller en mobilapplikasjon?** Hvis du bygger en mobilapplikasjon eller trenger å bruke modellen i en IoT-sammenheng, kan du bruke [TensorFlow Lite](https://www.tensorflow.org/lite/) og bruke modellen i en Android- eller iOS-applikasjon.
|
||||
- **Hvor skal modellen ligge?** I skyen eller lokalt?
|
||||
- **Støtte for offline bruk.** Må applikasjonen fungere offline?
|
||||
- **Hvilken teknologi ble brukt til å trene modellen?** Den valgte teknologien kan påvirke verktøyene du må bruke.
|
||||
- **Bruke TensorFlow.** Hvis du trener en modell med TensorFlow, for eksempel, gir det økosystemet muligheten til å konvertere en TensorFlow-modell for bruk i en webapplikasjon ved hjelp av [TensorFlow.js](https://www.tensorflow.org/js/).
|
||||
- **Bruke PyTorch.** Hvis du bygger en modell med et bibliotek som [PyTorch](https://pytorch.org/), har du muligheten til å eksportere den i [ONNX](https://onnx.ai/) (Open Neural Network Exchange)-format for bruk i JavaScript-webapplikasjoner som kan bruke [Onnx Runtime](https://www.onnxruntime.ai/). Denne muligheten vil bli utforsket i en fremtidig leksjon for en Scikit-learn-trent modell.
|
||||
- **Bruke Lobe.ai eller Azure Custom Vision.** Hvis du bruker et ML SaaS (Software as a Service)-system som [Lobe.ai](https://lobe.ai/) eller [Azure Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77952-leestott) for å trene en modell, gir denne typen programvare måter å eksportere modellen for mange plattformer, inkludert å bygge en skreddersydd API som kan forespørres i skyen av din online-applikasjon.
|
||||
|
||||
Du har også muligheten til å bygge en hel Flask-webapplikasjon som kan trene modellen selv i en nettleser. Dette kan også gjøres ved hjelp av TensorFlow.js i en JavaScript-sammenheng.
|
||||
|
||||
For vårt formål, siden vi har jobbet med Python-baserte notebooks, la oss utforske trinnene du må ta for å eksportere en trent modell fra en slik notebook til et format som kan leses av en Python-bygget webapplikasjon.
|
||||
|
||||
## Verktøy
|
||||
|
||||
For denne oppgaven trenger du to verktøy: Flask og Pickle, begge som kjører på Python.
|
||||
|
||||
✅ Hva er [Flask](https://palletsprojects.com/p/flask/)? Definert som et 'mikro-rammeverk' av sine skapere, gir Flask de grunnleggende funksjonene til webrammeverk ved bruk av Python og en templatemotor for å bygge nettsider. Ta en titt på [denne læringsmodulen](https://docs.microsoft.com/learn/modules/python-flask-build-ai-web-app?WT.mc_id=academic-77952-leestott) for å øve på å bygge med Flask.
|
||||
|
||||
✅ Hva er [Pickle](https://docs.python.org/3/library/pickle.html)? Pickle 🥒 er et Python-modul som serialiserer og de-serialiserer en Python-objektstruktur. Når du 'pickler' en modell, serialiserer eller flater du ut strukturen dens for bruk på nettet. Vær forsiktig: pickle er ikke iboende sikkert, så vær forsiktig hvis du blir bedt om å 'un-pickle' en fil. En picklet fil har suffikset `.pkl`.
|
||||
|
||||
## Øvelse - rense dataene dine
|
||||
|
||||
I denne leksjonen skal du bruke data fra 80,000 UFO-observasjoner, samlet av [NUFORC](https://nuforc.org) (The National UFO Reporting Center). Disse dataene har noen interessante beskrivelser av UFO-observasjoner, for eksempel:
|
||||
|
||||
- **Lang beskrivelse.** "En mann kommer ut fra en lysstråle som skinner på en gresslette om natten, og han løper mot Texas Instruments parkeringsplass".
|
||||
- **Kort beskrivelse.** "lysene jaget oss".
|
||||
|
||||
Regnearket [ufos.csv](../../../../3-Web-App/1-Web-App/data/ufos.csv) inkluderer kolonner om `city`, `state` og `country` der observasjonen fant sted, objektets `shape` og dets `latitude` og `longitude`.
|
||||
|
||||
I den tomme [notebook](../../../../3-Web-App/1-Web-App/notebook.ipynb) som er inkludert i denne leksjonen:
|
||||
|
||||
1. importer `pandas`, `matplotlib` og `numpy` som du gjorde i tidligere leksjoner, og importer UFO-regnearket. Du kan ta en titt på et eksempel på datasettet:
|
||||
|
||||
```python
|
||||
import pandas as pd
|
||||
import numpy as np
|
||||
|
||||
ufos = pd.read_csv('./data/ufos.csv')
|
||||
ufos.head()
|
||||
```
|
||||
|
||||
1. Konverter UFO-dataene til en liten dataframe med nye titler. Sjekk de unike verdiene i `Country`-feltet.
|
||||
|
||||
```python
|
||||
ufos = pd.DataFrame({'Seconds': ufos['duration (seconds)'], 'Country': ufos['country'],'Latitude': ufos['latitude'],'Longitude': ufos['longitude']})
|
||||
|
||||
ufos.Country.unique()
|
||||
```
|
||||
|
||||
1. Nå kan du redusere mengden data vi trenger å håndtere ved å fjerne eventuelle nullverdier og kun importere observasjoner mellom 1-60 sekunder:
|
||||
|
||||
```python
|
||||
ufos.dropna(inplace=True)
|
||||
|
||||
ufos = ufos[(ufos['Seconds'] >= 1) & (ufos['Seconds'] <= 60)]
|
||||
|
||||
ufos.info()
|
||||
```
|
||||
|
||||
1. Importer Scikit-learns `LabelEncoder`-bibliotek for å konvertere tekstverdier for land til et tall:
|
||||
|
||||
✅ LabelEncoder koder data alfabetisk
|
||||
|
||||
```python
|
||||
from sklearn.preprocessing import LabelEncoder
|
||||
|
||||
ufos['Country'] = LabelEncoder().fit_transform(ufos['Country'])
|
||||
|
||||
ufos.head()
|
||||
```
|
||||
|
||||
Dataene dine bør se slik ut:
|
||||
|
||||
```output
|
||||
Seconds Country Latitude Longitude
|
||||
2 20.0 3 53.200000 -2.916667
|
||||
3 20.0 4 28.978333 -96.645833
|
||||
14 30.0 4 35.823889 -80.253611
|
||||
23 60.0 4 45.582778 -122.352222
|
||||
24 3.0 3 51.783333 -0.783333
|
||||
```
|
||||
|
||||
## Øvelse - bygg modellen din
|
||||
|
||||
Nå kan du gjøre deg klar til å trene en modell ved å dele dataene inn i trenings- og testgrupper.
|
||||
|
||||
1. Velg de tre funksjonene du vil trene på som din X-vektor, og y-vektoren vil være `Country`. Du vil kunne legge inn `Seconds`, `Latitude` og `Longitude` og få en land-ID tilbake.
|
||||
|
||||
```python
|
||||
from sklearn.model_selection import train_test_split
|
||||
|
||||
Selected_features = ['Seconds','Latitude','Longitude']
|
||||
|
||||
X = ufos[Selected_features]
|
||||
y = ufos['Country']
|
||||
|
||||
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
|
||||
```
|
||||
|
||||
1. Tren modellen din ved hjelp av logistisk regresjon:
|
||||
|
||||
```python
|
||||
from sklearn.metrics import accuracy_score, classification_report
|
||||
from sklearn.linear_model import LogisticRegression
|
||||
model = LogisticRegression()
|
||||
model.fit(X_train, y_train)
|
||||
predictions = model.predict(X_test)
|
||||
|
||||
print(classification_report(y_test, predictions))
|
||||
print('Predicted labels: ', predictions)
|
||||
print('Accuracy: ', accuracy_score(y_test, predictions))
|
||||
```
|
||||
|
||||
Nøyaktigheten er ikke dårlig **(rundt 95%)**, ikke overraskende, siden `Country` og `Latitude/Longitude` korrelerer.
|
||||
|
||||
Modellen du opprettet er ikke veldig revolusjonerende, siden du burde kunne utlede et `Country` fra dets `Latitude` og `Longitude`, men det er en god øvelse å prøve å trene fra rådata som du renset, eksporterte, og deretter bruke denne modellen i en webapplikasjon.
|
||||
|
||||
## Øvelse - 'pickle' modellen din
|
||||
|
||||
Nå er det på tide å _pickle_ modellen din! Du kan gjøre det med noen få linjer kode. Når den er _picklet_, last inn den picklete modellen og test den mot et eksempeldataarray som inneholder verdier for sekunder, breddegrad og lengdegrad.
|
||||
|
||||
```python
|
||||
import pickle
|
||||
model_filename = 'ufo-model.pkl'
|
||||
pickle.dump(model, open(model_filename,'wb'))
|
||||
|
||||
model = pickle.load(open('ufo-model.pkl','rb'))
|
||||
print(model.predict([[50,44,-12]]))
|
||||
```
|
||||
|
||||
Modellen returnerer **'3'**, som er landkoden for Storbritannia. Utrolig! 👽
|
||||
|
||||
## Øvelse - bygg en Flask-applikasjon
|
||||
|
||||
Nå kan du bygge en Flask-applikasjon for å kalle modellen din og returnere lignende resultater, men på en mer visuelt tiltalende måte.
|
||||
|
||||
1. Start med å opprette en mappe kalt **web-app** ved siden av _notebook.ipynb_-filen der _ufo-model.pkl_-filen ligger.
|
||||
|
||||
1. I den mappen opprett tre flere mapper: **static**, med en mappe **css** inni, og **templates**. Du bør nå ha følgende filer og kataloger:
|
||||
|
||||
```output
|
||||
web-app/
|
||||
static/
|
||||
css/
|
||||
templates/
|
||||
notebook.ipynb
|
||||
ufo-model.pkl
|
||||
```
|
||||
|
||||
✅ Se løsningsmappen for en visning av den ferdige applikasjonen
|
||||
|
||||
1. Den første filen du oppretter i _web-app_-mappen er **requirements.txt**-filen. Som _package.json_ i en JavaScript-applikasjon, lister denne filen opp avhengigheter som kreves av applikasjonen. I **requirements.txt** legg til linjene:
|
||||
|
||||
```text
|
||||
scikit-learn
|
||||
pandas
|
||||
numpy
|
||||
flask
|
||||
```
|
||||
|
||||
1. Nå, kjør denne filen ved å navigere til _web-app_:
|
||||
|
||||
```bash
|
||||
cd web-app
|
||||
```
|
||||
|
||||
1. I terminalen din, skriv `pip install` for å installere bibliotekene som er oppført i _requirements.txt_:
|
||||
|
||||
```bash
|
||||
pip install -r requirements.txt
|
||||
```
|
||||
|
||||
1. Nå er du klar til å opprette tre flere filer for å fullføre applikasjonen:
|
||||
|
||||
1. Opprett **app.py** i roten.
|
||||
2. Opprett **index.html** i _templates_-katalogen.
|
||||
3. Opprett **styles.css** i _static/css_-katalogen.
|
||||
|
||||
1. Bygg ut _styles.css_-filen med noen få stiler:
|
||||
|
||||
```css
|
||||
body {
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
font-family: 'Helvetica';
|
||||
background: black;
|
||||
color: #fff;
|
||||
text-align: center;
|
||||
letter-spacing: 1.4px;
|
||||
font-size: 30px;
|
||||
}
|
||||
|
||||
input {
|
||||
min-width: 150px;
|
||||
}
|
||||
|
||||
.grid {
|
||||
width: 300px;
|
||||
border: 1px solid #2d2d2d;
|
||||
display: grid;
|
||||
justify-content: center;
|
||||
margin: 20px auto;
|
||||
}
|
||||
|
||||
.box {
|
||||
color: #fff;
|
||||
background: #2d2d2d;
|
||||
padding: 12px;
|
||||
display: inline-block;
|
||||
}
|
||||
```
|
||||
|
||||
1. Deretter bygger du ut _index.html_-filen:
|
||||
|
||||
```html
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<title>🛸 UFO Appearance Prediction! 👽</title>
|
||||
<link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
|
||||
</head>
|
||||
|
||||
<body>
|
||||
<div class="grid">
|
||||
|
||||
<div class="box">
|
||||
|
||||
<p>According to the number of seconds, latitude and longitude, which country is likely to have reported seeing a UFO?</p>
|
||||
|
||||
<form action="{{ url_for('predict')}}" method="post">
|
||||
<input type="number" name="seconds" placeholder="Seconds" required="required" min="0" max="60" />
|
||||
<input type="text" name="latitude" placeholder="Latitude" required="required" />
|
||||
<input type="text" name="longitude" placeholder="Longitude" required="required" />
|
||||
<button type="submit" class="btn">Predict country where the UFO is seen</button>
|
||||
</form>
|
||||
|
||||
<p>{{ prediction_text }}</p>
|
||||
|
||||
</div>
|
||||
|
||||
</div>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
```
|
||||
|
||||
Ta en titt på templatingen i denne filen. Legg merke til 'mustache'-syntaksen rundt variabler som vil bli levert av applikasjonen, som prediksjonsteksten: `{{}}`. Det er også et skjema som sender en prediksjon til `/predict`-ruten.
|
||||
|
||||
Til slutt er du klar til å bygge Python-filen som driver forbruket av modellen og visningen av prediksjoner:
|
||||
|
||||
1. I `app.py` legg til:
|
||||
|
||||
```python
|
||||
import numpy as np
|
||||
from flask import Flask, request, render_template
|
||||
import pickle
|
||||
|
||||
app = Flask(__name__)
|
||||
|
||||
model = pickle.load(open("./ufo-model.pkl", "rb"))
|
||||
|
||||
|
||||
@app.route("/")
|
||||
def home():
|
||||
return render_template("index.html")
|
||||
|
||||
|
||||
@app.route("/predict", methods=["POST"])
|
||||
def predict():
|
||||
|
||||
int_features = [int(x) for x in request.form.values()]
|
||||
final_features = [np.array(int_features)]
|
||||
prediction = model.predict(final_features)
|
||||
|
||||
output = prediction[0]
|
||||
|
||||
countries = ["Australia", "Canada", "Germany", "UK", "US"]
|
||||
|
||||
return render_template(
|
||||
"index.html", prediction_text="Likely country: {}".format(countries[output])
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
app.run(debug=True)
|
||||
```
|
||||
|
||||
> 💡 Tips: når du legger til [`debug=True`](https://www.askpython.com/python-modules/flask/flask-debug-mode) mens du kjører webapplikasjonen ved hjelp av Flask, vil eventuelle endringer du gjør i applikasjonen bli reflektert umiddelbart uten behov for å starte serveren på nytt. Vær oppmerksom! Ikke aktiver denne modusen i en produksjonsapplikasjon.
|
||||
|
||||
Hvis du kjører `python app.py` eller `python3 app.py` - starter webserveren din opp lokalt, og du kan fylle ut et kort skjema for å få svar på ditt brennende spørsmål om hvor UFO-er har blitt observert!
|
||||
|
||||
Før du gjør det, ta en titt på delene av `app.py`:
|
||||
|
||||
1. Først lastes avhengighetene og applikasjonen starter.
|
||||
1. Deretter importeres modellen.
|
||||
1. Deretter rendres index.html på hjemmeruten.
|
||||
|
||||
På `/predict`-ruten skjer flere ting når skjemaet sendes inn:
|
||||
|
||||
1. Skjemavariablene samles og konverteres til et numpy-array. De sendes deretter til modellen, og en prediksjon returneres.
|
||||
2. Landene som vi ønsker skal vises, rendres på nytt som lesbar tekst fra deres predikerte landkode, og den verdien sendes tilbake til index.html for å bli rendret i templaten.
|
||||
|
||||
Å bruke en modell på denne måten, med Flask og en picklet modell, er relativt enkelt. Det vanskeligste er å forstå hvilken form dataene må ha for å bli sendt til modellen for å få en prediksjon. Det avhenger helt av hvordan modellen ble trent. Denne har tre datapunkter som må legges inn for å få en prediksjon.
|
||||
|
||||
I en profesjonell setting kan du se hvor viktig god kommunikasjon er mellom de som trener modellen og de som bruker den i en web- eller mobilapplikasjon. I vårt tilfelle er det bare én person, deg!
|
||||
|
||||
---
|
||||
|
||||
## 🚀 Utfordring
|
||||
|
||||
I stedet for å jobbe i en notebook og importere modellen til Flask-applikasjonen, kan du trene modellen direkte i Flask-applikasjonen! Prøv å konvertere Python-koden din i notebooken, kanskje etter at dataene dine er renset, for å trene modellen fra applikasjonen på en rute kalt `train`. Hva er fordeler og ulemper med å bruke denne metoden?
|
||||
|
||||
## [Quiz etter leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Gjennomgang og selvstudium
|
||||
|
||||
Det finnes mange måter å bygge en webapplikasjon for å bruke ML-modeller. Lag en liste over måtene du kan bruke JavaScript eller Python til å bygge en webapplikasjon som utnytter maskinlæring. Tenk på arkitektur: bør modellen bli værende i applikasjonen eller ligge i skyen? Hvis det siste, hvordan ville du få tilgang til den? Tegn opp en arkitekturmodell for en anvendt ML-webløsning.
|
||||
|
||||
## Oppgave
|
||||
|
||||
[Prøv en annen modell](assignment.md)
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,25 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "a8e8ae10be335cbc745b75ee552317ff",
|
||||
"translation_date": "2025-09-05T21:48:15+00:00",
|
||||
"source_file": "3-Web-App/1-Web-App/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Prøv en annen modell
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
Nå som du har bygget en webapplikasjon ved hjelp av en trent regresjonsmodell, bruk en av modellene fra en tidligere leksjon om regresjon for å lage denne webapplikasjonen på nytt. Du kan beholde stilen eller designe den annerledes for å reflektere gresskar-dataene. Vær nøye med å endre inputene slik at de samsvarer med treningsmetoden til modellen din.
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Fremragende | Tilfredsstillende | Trenger forbedring |
|
||||
| -------------------------- | ------------------------------------------------------- | ------------------------------------------------------- | ------------------------------------ |
|
||||
| | Webapplikasjonen fungerer som forventet og er distribuert i skyen | Webapplikasjonen har feil eller gir uventede resultater | Webapplikasjonen fungerer ikke som den skal |
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,35 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "9836ff53cfef716ddfd70e06c5f43436",
|
||||
"translation_date": "2025-09-05T21:46:21+00:00",
|
||||
"source_file": "3-Web-App/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Bygg en nettapp for å bruke din ML-modell
|
||||
|
||||
I denne delen av læreplanen vil du bli introdusert til et praktisk ML-tema: hvordan du lagrer din Scikit-learn-modell som en fil som kan brukes til å gjøre prediksjoner i en nettapplikasjon. Når modellen er lagret, vil du lære hvordan du bruker den i en nettapp bygget med Flask. Du vil først lage en modell ved hjelp av data som handler om UFO-observasjoner! Deretter vil du bygge en nettapp som lar deg skrive inn et antall sekunder sammen med en breddegrad og en lengdegrad for å forutsi hvilket land som rapporterte å ha sett en UFO.
|
||||
|
||||
|
||||
|
||||
Foto av <a href="https://unsplash.com/@mdherren?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Michael Herren</a> på <a href="https://unsplash.com/s/photos/ufo?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
|
||||
|
||||
## Leksjoner
|
||||
|
||||
1. [Bygg en nettapp](1-Web-App/README.md)
|
||||
|
||||
## Krediteringer
|
||||
|
||||
"Bygg en nettapp" ble skrevet med ♥️ av [Jen Looper](https://twitter.com/jenlooper).
|
||||
|
||||
♥️ Quizene ble skrevet av Rohan Raj.
|
||||
|
||||
Datasettet er hentet fra [Kaggle](https://www.kaggle.com/NUFORC/ufo-sightings).
|
||||
|
||||
Arkitekturen for nettappen ble delvis foreslått av [denne artikkelen](https://towardsdatascience.com/how-to-easily-deploy-machine-learning-models-using-flask-b95af8fe34d4) og [denne repoen](https://github.com/abhinavsagar/machine-learning-deployment) av Abhinav Sagar.
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,313 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "aaf391d922bd6de5efba871d514c6d47",
|
||||
"translation_date": "2025-09-05T21:55:45+00:00",
|
||||
"source_file": "4-Classification/1-Introduction/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Introduksjon til klassifisering
|
||||
|
||||
I disse fire leksjonene skal du utforske et grunnleggende fokusområde innen klassisk maskinlæring - _klassifisering_. Vi skal gå gjennom bruken av ulike klassifiseringsalgoritmer med et datasett om alle de fantastiske kjøkkenene i Asia og India. Håper du er sulten!
|
||||
|
||||
|
||||
|
||||
> Feir pan-asiatiske kjøkken i disse leksjonene! Bilde av [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
Klassifisering er en form for [supervised learning](https://wikipedia.org/wiki/Supervised_learning) som har mye til felles med regresjonsteknikker. Hvis maskinlæring handler om å forutsi verdier eller navn på ting ved hjelp av datasett, faller klassifisering generelt inn i to grupper: _binær klassifisering_ og _multiklasse klassifisering_.
|
||||
|
||||
[](https://youtu.be/eg8DJYwdMyg "Introduksjon til klassifisering")
|
||||
|
||||
> 🎥 Klikk på bildet over for en video: MITs John Guttag introduserer klassifisering
|
||||
|
||||
Husk:
|
||||
|
||||
- **Lineær regresjon** hjalp deg med å forutsi forholdet mellom variabler og lage nøyaktige spådommer om hvor et nytt datapunkt ville falle i forhold til den linjen. For eksempel kunne du forutsi _hva prisen på et gresskar ville være i september vs. desember_.
|
||||
- **Logistisk regresjon** hjalp deg med å oppdage "binære kategorier": ved dette prisnivået, _er dette gresskaret oransje eller ikke-oransje_?
|
||||
|
||||
Klassifisering bruker ulike algoritmer for å bestemme andre måter å avgjøre en datapunktopps etikett eller klasse. La oss jobbe med dette matlagingsdatasettet for å se om vi, ved å observere en gruppe ingredienser, kan avgjøre hvilket kjøkken de tilhører.
|
||||
|
||||
## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
> ### [Denne leksjonen er tilgjengelig i R!](../../../../4-Classification/1-Introduction/solution/R/lesson_10.html)
|
||||
|
||||
### Introduksjon
|
||||
|
||||
Klassifisering er en av de grunnleggende aktivitetene for maskinlæringsforskere og dataforskere. Fra enkel klassifisering av en binær verdi ("er denne e-posten spam eller ikke?"), til kompleks bildeklassifisering og segmentering ved hjelp av datamaskinsyn, er det alltid nyttig å kunne sortere data i klasser og stille spørsmål om det.
|
||||
|
||||
For å formulere prosessen på en mer vitenskapelig måte, skaper klassifiseringsmetoden din en prediktiv modell som gjør det mulig å kartlegge forholdet mellom inputvariabler og outputvariabler.
|
||||
|
||||
|
||||
|
||||
> Binære vs. multiklasse problemer for klassifiseringsalgoritmer å håndtere. Infografikk av [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
Før vi starter prosessen med å rense dataene våre, visualisere dem og forberede dem for våre ML-oppgaver, la oss lære litt om de ulike måtene maskinlæring kan brukes til å klassifisere data.
|
||||
|
||||
Avledet fra [statistikk](https://wikipedia.org/wiki/Statistical_classification), bruker klassifisering med klassisk maskinlæring funksjoner som `smoker`, `weight` og `age` for å avgjøre _sannsynligheten for å utvikle X sykdom_. Som en supervised learning-teknikk, lik de regresjonsøvelsene du utførte tidligere, er dataene dine merket, og ML-algoritmene bruker disse merkene til å klassifisere og forutsi klasser (eller 'funksjoner') i et datasett og tilordne dem til en gruppe eller et utfall.
|
||||
|
||||
✅ Ta et øyeblikk til å forestille deg et datasett om matretter. Hva ville en multiklassemodell kunne svare på? Hva ville en binær modell kunne svare på? Hva om du ville avgjøre om en gitt matrett sannsynligvis bruker bukkehornkløver? Hva om du ville se om du, gitt en pose med stjerneanis, artisjokker, blomkål og pepperrot, kunne lage en typisk indisk rett?
|
||||
|
||||
[](https://youtu.be/GuTeDbaNoEU "Gale mysteriekurver")
|
||||
|
||||
> 🎥 Klikk på bildet over for en video. Hele premisset for showet 'Chopped' er 'mystery basket', der kokker må lage en rett ut av et tilfeldig utvalg ingredienser. Sikkert en ML-modell ville ha hjulpet!
|
||||
|
||||
## Hei 'klassifiserer'
|
||||
|
||||
Spørsmålet vi ønsker å stille til dette matlagingsdatasettet er faktisk et **multiklasse-spørsmål**, siden vi har flere potensielle nasjonale kjøkken å jobbe med. Gitt en gruppe ingredienser, hvilken av disse mange klassene passer dataene inn i?
|
||||
|
||||
Scikit-learn tilbyr flere forskjellige algoritmer for å klassifisere data, avhengig av hvilken type problem du vil løse. I de neste to leksjonene skal du lære om flere av disse algoritmene.
|
||||
|
||||
## Øvelse - rens og balanser dataene dine
|
||||
|
||||
Den første oppgaven, før du starter dette prosjektet, er å rense og **balansere** dataene dine for å få bedre resultater. Start med den tomme _notebook.ipynb_-filen i roten av denne mappen.
|
||||
|
||||
Det første du må installere er [imblearn](https://imbalanced-learn.org/stable/). Dette er en Scikit-learn-pakke som lar deg bedre balansere dataene (du vil lære mer om denne oppgaven om et øyeblikk).
|
||||
|
||||
1. For å installere `imblearn`, kjør `pip install`, slik:
|
||||
|
||||
```python
|
||||
pip install imblearn
|
||||
```
|
||||
|
||||
1. Importer pakkene du trenger for å importere dataene dine og visualisere dem, og importer også `SMOTE` fra `imblearn`.
|
||||
|
||||
```python
|
||||
import pandas as pd
|
||||
import matplotlib.pyplot as plt
|
||||
import matplotlib as mpl
|
||||
import numpy as np
|
||||
from imblearn.over_sampling import SMOTE
|
||||
```
|
||||
|
||||
Nå er du klar til å lese og importere dataene.
|
||||
|
||||
1. Den neste oppgaven vil være å importere dataene:
|
||||
|
||||
```python
|
||||
df = pd.read_csv('../data/cuisines.csv')
|
||||
```
|
||||
|
||||
Ved å bruke `read_csv()` vil innholdet i csv-filen _cusines.csv_ bli lest og plassert i variabelen `df`.
|
||||
|
||||
1. Sjekk formen på dataene:
|
||||
|
||||
```python
|
||||
df.head()
|
||||
```
|
||||
|
||||
De første fem radene ser slik ut:
|
||||
|
||||
```output
|
||||
| | Unnamed: 0 | cuisine | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood | yam | yeast | yogurt | zucchini |
|
||||
| --- | ---------- | ------- | ------ | -------- | ----- | ---------- | ----- | ------------ | ------- | -------- | --- | ------- | ----------- | ---------- | ----------------------- | ---- | ---- | --- | ----- | ------ | -------- |
|
||||
| 0 | 65 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 1 | 66 | indian | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 2 | 67 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 3 | 68 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 4 | 69 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
|
||||
```
|
||||
|
||||
1. Få informasjon om disse dataene ved å kalle `info()`:
|
||||
|
||||
```python
|
||||
df.info()
|
||||
```
|
||||
|
||||
Utdataene dine ligner:
|
||||
|
||||
```output
|
||||
<class 'pandas.core.frame.DataFrame'>
|
||||
RangeIndex: 2448 entries, 0 to 2447
|
||||
Columns: 385 entries, Unnamed: 0 to zucchini
|
||||
dtypes: int64(384), object(1)
|
||||
memory usage: 7.2+ MB
|
||||
```
|
||||
|
||||
## Øvelse - lære om matretter
|
||||
|
||||
Nå begynner arbeidet å bli mer interessant. La oss oppdage fordelingen av data per kjøkken.
|
||||
|
||||
1. Plott dataene som stolper ved å kalle `barh()`:
|
||||
|
||||
```python
|
||||
df.cuisine.value_counts().plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Det er et begrenset antall kjøkken, men fordelingen av data er ujevn. Du kan fikse det! Før du gjør det, utforsk litt mer.
|
||||
|
||||
1. Finn ut hvor mye data som er tilgjengelig per kjøkken og skriv det ut:
|
||||
|
||||
```python
|
||||
thai_df = df[(df.cuisine == "thai")]
|
||||
japanese_df = df[(df.cuisine == "japanese")]
|
||||
chinese_df = df[(df.cuisine == "chinese")]
|
||||
indian_df = df[(df.cuisine == "indian")]
|
||||
korean_df = df[(df.cuisine == "korean")]
|
||||
|
||||
print(f'thai df: {thai_df.shape}')
|
||||
print(f'japanese df: {japanese_df.shape}')
|
||||
print(f'chinese df: {chinese_df.shape}')
|
||||
print(f'indian df: {indian_df.shape}')
|
||||
print(f'korean df: {korean_df.shape}')
|
||||
```
|
||||
|
||||
Utdataene ser slik ut:
|
||||
|
||||
```output
|
||||
thai df: (289, 385)
|
||||
japanese df: (320, 385)
|
||||
chinese df: (442, 385)
|
||||
indian df: (598, 385)
|
||||
korean df: (799, 385)
|
||||
```
|
||||
|
||||
## Oppdage ingredienser
|
||||
|
||||
Nå kan du grave dypere i dataene og lære hva som er de typiske ingrediensene per kjøkken. Du bør rense ut gjentakende data som skaper forvirring mellom kjøkken, så la oss lære om dette problemet.
|
||||
|
||||
1. Lag en funksjon `create_ingredient()` i Python for å lage en ingrediens-datasett. Denne funksjonen vil starte med å fjerne en unyttig kolonne og sortere ingredienser etter antall:
|
||||
|
||||
```python
|
||||
def create_ingredient_df(df):
|
||||
ingredient_df = df.T.drop(['cuisine','Unnamed: 0']).sum(axis=1).to_frame('value')
|
||||
ingredient_df = ingredient_df[(ingredient_df.T != 0).any()]
|
||||
ingredient_df = ingredient_df.sort_values(by='value', ascending=False,
|
||||
inplace=False)
|
||||
return ingredient_df
|
||||
```
|
||||
|
||||
Nå kan du bruke den funksjonen til å få en idé om de ti mest populære ingrediensene per kjøkken.
|
||||
|
||||
1. Kall `create_ingredient()` og plott det ved å kalle `barh()`:
|
||||
|
||||
```python
|
||||
thai_ingredient_df = create_ingredient_df(thai_df)
|
||||
thai_ingredient_df.head(10).plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
1. Gjør det samme for de japanske dataene:
|
||||
|
||||
```python
|
||||
japanese_ingredient_df = create_ingredient_df(japanese_df)
|
||||
japanese_ingredient_df.head(10).plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
1. Nå for de kinesiske ingrediensene:
|
||||
|
||||
```python
|
||||
chinese_ingredient_df = create_ingredient_df(chinese_df)
|
||||
chinese_ingredient_df.head(10).plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
1. Plott de indiske ingrediensene:
|
||||
|
||||
```python
|
||||
indian_ingredient_df = create_ingredient_df(indian_df)
|
||||
indian_ingredient_df.head(10).plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
1. Til slutt, plott de koreanske ingrediensene:
|
||||
|
||||
```python
|
||||
korean_ingredient_df = create_ingredient_df(korean_df)
|
||||
korean_ingredient_df.head(10).plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
1. Nå, fjern de vanligste ingrediensene som skaper forvirring mellom ulike kjøkken, ved å kalle `drop()`:
|
||||
|
||||
Alle elsker ris, hvitløk og ingefær!
|
||||
|
||||
```python
|
||||
feature_df= df.drop(['cuisine','Unnamed: 0','rice','garlic','ginger'], axis=1)
|
||||
labels_df = df.cuisine #.unique()
|
||||
feature_df.head()
|
||||
```
|
||||
|
||||
## Balanser datasettet
|
||||
|
||||
Nå som du har renset dataene, bruk [SMOTE](https://imbalanced-learn.org/dev/references/generated/imblearn.over_sampling.SMOTE.html) - "Synthetic Minority Over-sampling Technique" - for å balansere det.
|
||||
|
||||
1. Kall `fit_resample()`, denne strategien genererer nye prøver ved interpolasjon.
|
||||
|
||||
```python
|
||||
oversample = SMOTE()
|
||||
transformed_feature_df, transformed_label_df = oversample.fit_resample(feature_df, labels_df)
|
||||
```
|
||||
|
||||
Ved å balansere dataene dine, vil du få bedre resultater når du klassifiserer dem. Tenk på en binær klassifisering. Hvis mesteparten av dataene dine er én klasse, vil en ML-modell forutsi den klassen oftere, bare fordi det er mer data for den. Å balansere dataene tar skjeve data og hjelper med å fjerne denne ubalansen.
|
||||
|
||||
1. Nå kan du sjekke antall etiketter per ingrediens:
|
||||
|
||||
```python
|
||||
print(f'new label count: {transformed_label_df.value_counts()}')
|
||||
print(f'old label count: {df.cuisine.value_counts()}')
|
||||
```
|
||||
|
||||
Utdataene dine ser slik ut:
|
||||
|
||||
```output
|
||||
new label count: korean 799
|
||||
chinese 799
|
||||
indian 799
|
||||
japanese 799
|
||||
thai 799
|
||||
Name: cuisine, dtype: int64
|
||||
old label count: korean 799
|
||||
indian 598
|
||||
chinese 442
|
||||
japanese 320
|
||||
thai 289
|
||||
Name: cuisine, dtype: int64
|
||||
```
|
||||
|
||||
Dataene er fine og rene, balanserte og veldig delikate!
|
||||
|
||||
1. Det siste trinnet er å lagre de balanserte dataene, inkludert etiketter og funksjoner, i et nytt datasett som kan eksporteres til en fil:
|
||||
|
||||
```python
|
||||
transformed_df = pd.concat([transformed_label_df,transformed_feature_df],axis=1, join='outer')
|
||||
```
|
||||
|
||||
1. Du kan ta en siste titt på dataene ved å bruke `transformed_df.head()` og `transformed_df.info()`. Lagre en kopi av disse dataene for bruk i fremtidige leksjoner:
|
||||
|
||||
```python
|
||||
transformed_df.head()
|
||||
transformed_df.info()
|
||||
transformed_df.to_csv("../data/cleaned_cuisines.csv")
|
||||
```
|
||||
|
||||
Denne ferske CSV-filen kan nå finnes i rotdata-mappen.
|
||||
|
||||
---
|
||||
|
||||
## 🚀Utfordring
|
||||
|
||||
Dette pensumet inneholder flere interessante datasett. Grav gjennom `data`-mappene og se om noen inneholder datasett som ville være passende for binær eller multiklasse klassifisering? Hvilke spørsmål ville du stille til dette datasettet?
|
||||
|
||||
## [Quiz etter leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Gjennomgang og selvstudium
|
||||
|
||||
Utforsk SMOTEs API. Hvilke bruksområder er det best egnet for? Hvilke problemer løser det?
|
||||
|
||||
## Oppgave
|
||||
|
||||
[Utforsk klassifiseringsmetoder](assignment.md)
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,25 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "b2a01912beb24cfb0007f83594dba801",
|
||||
"translation_date": "2025-09-05T21:56:25+00:00",
|
||||
"source_file": "4-Classification/1-Introduction/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Utforsk klassifiseringsmetoder
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
I [Scikit-learn dokumentasjonen](https://scikit-learn.org/stable/supervised_learning.html) finner du en omfattende liste over måter å klassifisere data på. Gjør en liten skattejakt i disse dokumentene: målet ditt er å finne klassifiseringsmetoder og matche et datasett fra dette pensumet, et spørsmål du kan stille om det, og en klassifiseringsteknikk. Lag et regneark eller en tabell i en .doc-fil og forklar hvordan datasettet kan fungere med klassifiseringsalgoritmen.
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Eksemplarisk | Tilfredsstillende | Trenger forbedring |
|
||||
| --------- | ----------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| | et dokument presenteres som gir en oversikt over 5 algoritmer sammen med en klassifiseringsteknikk. Oversikten er godt forklart og detaljert. | et dokument presenteres som gir en oversikt over 3 algoritmer sammen med en klassifiseringsteknikk. Oversikten er godt forklart og detaljert. | et dokument presenteres som gir en oversikt over færre enn tre algoritmer sammen med en klassifiseringsteknikk, og oversikten er verken godt forklart eller detaljert. |
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
|
||||
"translation_date": "2025-09-05T21:56:38+00:00",
|
||||
"source_file": "4-Classification/1-Introduction/solution/Julia/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,23 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "de6025f96841498b0577e9d1aee18d1f",
|
||||
"translation_date": "2025-09-05T21:51:31+00:00",
|
||||
"source_file": "4-Classification/2-Classifiers-1/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Studer løserne
|
||||
## Instruksjoner
|
||||
|
||||
I denne leksjonen lærte du om de ulike løserne som kombinerer algoritmer med en maskinlæringsprosess for å skape en nøyaktig modell. Gå gjennom løserne som er oppført i leksjonen og velg to. Med dine egne ord, sammenlign og kontraster disse to løserne. Hvilken type problem adresserer de? Hvordan fungerer de med ulike datastrukturer? Hvorfor ville du valgt den ene fremfor den andre?
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Eksemplarisk | Tilfredsstillende | Trenger forbedring |
|
||||
| --------- | --------------------------------------------------------------------------------------------- | ------------------------------------------------ | ---------------------------- |
|
||||
| | En .doc-fil presenteres med to avsnitt, ett om hver løser, som sammenligner dem gjennomtenkt. | En .doc-fil presenteres med kun ett avsnitt | Oppgaven er ufullstendig |
|
||||
|
||||
---
|
||||
|
||||
**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 eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
|
||||
"translation_date": "2025-09-05T21:51:43+00:00",
|
||||
"source_file": "4-Classification/2-Classifiers-1/solution/Julia/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,249 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "49047911108adc49d605cddfb455749c",
|
||||
"translation_date": "2025-09-05T21:54:02+00:00",
|
||||
"source_file": "4-Classification/3-Classifiers-2/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Klassifisering av matretter 2
|
||||
|
||||
I denne andre leksjonen om klassifisering vil du utforske flere måter å klassifisere numeriske data på. Du vil også lære om konsekvensene ved å velge én klassifikator fremfor en annen.
|
||||
|
||||
## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
### Forutsetninger
|
||||
|
||||
Vi antar at du har fullført de tidligere leksjonene og har et renset datasett i `data`-mappen kalt _cleaned_cuisines.csv_ i roten av denne 4-leksjonsmappen.
|
||||
|
||||
### Forberedelse
|
||||
|
||||
Vi har lastet inn filen din _notebook.ipynb_ med det rensede datasettet og har delt det inn i X- og y-dataframes, klare for modellbyggingsprosessen.
|
||||
|
||||
## Et klassifiseringskart
|
||||
|
||||
Tidligere lærte du om de ulike alternativene du har når du klassifiserer data ved hjelp av Microsofts jukselapp. Scikit-learn tilbyr en lignende, men mer detaljert jukselapp som kan hjelpe deg med å snevre inn valget av estimatoren (et annet ord for klassifikator):
|
||||
|
||||
|
||||
> Tips: [besøk dette kartet online](https://scikit-learn.org/stable/tutorial/machine_learning_map/) og klikk langs stien for å lese dokumentasjonen.
|
||||
|
||||
### Planen
|
||||
|
||||
Dette kartet er veldig nyttig når du har en klar forståelse av dataene dine, da du kan 'gå' langs stiene til en beslutning:
|
||||
|
||||
- Vi har >50 prøver
|
||||
- Vi ønsker å forutsi en kategori
|
||||
- Vi har merket data
|
||||
- Vi har færre enn 100K prøver
|
||||
- ✨ Vi kan velge en Linear SVC
|
||||
- Hvis det ikke fungerer, siden vi har numeriske data
|
||||
- Vi kan prøve en ✨ KNeighbors Classifier
|
||||
- Hvis det ikke fungerer, prøv ✨ SVC og ✨ Ensemble Classifiers
|
||||
|
||||
Dette er en veldig nyttig sti å følge.
|
||||
|
||||
## Øvelse - del opp dataene
|
||||
|
||||
Ved å følge denne stien bør vi starte med å importere noen biblioteker vi skal bruke.
|
||||
|
||||
1. Importer de nødvendige bibliotekene:
|
||||
|
||||
```python
|
||||
from sklearn.neighbors import KNeighborsClassifier
|
||||
from sklearn.linear_model import LogisticRegression
|
||||
from sklearn.svm import SVC
|
||||
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
|
||||
from sklearn.model_selection import train_test_split, cross_val_score
|
||||
from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report, precision_recall_curve
|
||||
import numpy as np
|
||||
```
|
||||
|
||||
1. Del opp trenings- og testdataene:
|
||||
|
||||
```python
|
||||
X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)
|
||||
```
|
||||
|
||||
## Linear SVC klassifikator
|
||||
|
||||
Support-Vector clustering (SVC) er en del av Support-Vector-maskiner-familien av ML-teknikker (lær mer om disse nedenfor). I denne metoden kan du velge en 'kernel' for å bestemme hvordan etikettene skal grupperes. Parameteren 'C' refererer til 'regularisering', som regulerer påvirkningen av parametere. Kernel kan være en av [flere](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC); her setter vi den til 'linear' for å sikre at vi bruker lineær SVC. Sannsynlighet er som standard satt til 'false'; her setter vi den til 'true' for å samle sannsynlighetsestimater. Vi setter den tilfeldige tilstanden til '0' for å blande dataene for å få sannsynligheter.
|
||||
|
||||
### Øvelse - bruk en lineær SVC
|
||||
|
||||
Start med å lage en array av klassifikatorer. Du vil legge til gradvis i denne arrayen mens vi tester.
|
||||
|
||||
1. Start med en Linear SVC:
|
||||
|
||||
```python
|
||||
C = 10
|
||||
# Create different classifiers.
|
||||
classifiers = {
|
||||
'Linear SVC': SVC(kernel='linear', C=C, probability=True,random_state=0)
|
||||
}
|
||||
```
|
||||
|
||||
2. Tren modellen din ved hjelp av Linear SVC og skriv ut en rapport:
|
||||
|
||||
```python
|
||||
n_classifiers = len(classifiers)
|
||||
|
||||
for index, (name, classifier) in enumerate(classifiers.items()):
|
||||
classifier.fit(X_train, np.ravel(y_train))
|
||||
|
||||
y_pred = classifier.predict(X_test)
|
||||
accuracy = accuracy_score(y_test, y_pred)
|
||||
print("Accuracy (train) for %s: %0.1f%% " % (name, accuracy * 100))
|
||||
print(classification_report(y_test,y_pred))
|
||||
```
|
||||
|
||||
Resultatet er ganske bra:
|
||||
|
||||
```output
|
||||
Accuracy (train) for Linear SVC: 78.6%
|
||||
precision recall f1-score support
|
||||
|
||||
chinese 0.71 0.67 0.69 242
|
||||
indian 0.88 0.86 0.87 234
|
||||
japanese 0.79 0.74 0.76 254
|
||||
korean 0.85 0.81 0.83 242
|
||||
thai 0.71 0.86 0.78 227
|
||||
|
||||
accuracy 0.79 1199
|
||||
macro avg 0.79 0.79 0.79 1199
|
||||
weighted avg 0.79 0.79 0.79 1199
|
||||
```
|
||||
|
||||
## K-Neighbors klassifikator
|
||||
|
||||
K-Neighbors er en del av "neighbors"-familien av ML-metoder, som kan brukes til både overvåket og ikke-overvåket læring. I denne metoden opprettes et forhåndsdefinert antall punkter, og data samles rundt disse punktene slik at generaliserte etiketter kan forutsies for dataene.
|
||||
|
||||
### Øvelse - bruk K-Neighbors klassifikator
|
||||
|
||||
Den forrige klassifikatoren var god og fungerte bra med dataene, men kanskje vi kan få bedre nøyaktighet. Prøv en K-Neighbors klassifikator.
|
||||
|
||||
1. Legg til en linje i klassifikator-arrayen din (legg til en komma etter Linear SVC-elementet):
|
||||
|
||||
```python
|
||||
'KNN classifier': KNeighborsClassifier(C),
|
||||
```
|
||||
|
||||
Resultatet er litt dårligere:
|
||||
|
||||
```output
|
||||
Accuracy (train) for KNN classifier: 73.8%
|
||||
precision recall f1-score support
|
||||
|
||||
chinese 0.64 0.67 0.66 242
|
||||
indian 0.86 0.78 0.82 234
|
||||
japanese 0.66 0.83 0.74 254
|
||||
korean 0.94 0.58 0.72 242
|
||||
thai 0.71 0.82 0.76 227
|
||||
|
||||
accuracy 0.74 1199
|
||||
macro avg 0.76 0.74 0.74 1199
|
||||
weighted avg 0.76 0.74 0.74 1199
|
||||
```
|
||||
|
||||
✅ Lær om [K-Neighbors](https://scikit-learn.org/stable/modules/neighbors.html#neighbors)
|
||||
|
||||
## Support Vector Classifier
|
||||
|
||||
Support-Vector klassifikatorer er en del av [Support-Vector Machine](https://wikipedia.org/wiki/Support-vector_machine)-familien av ML-metoder som brukes til klassifiserings- og regresjonsoppgaver. SVMs "kartlegger treningsprøver til punkter i rommet" for å maksimere avstanden mellom to kategorier. Påfølgende data kartlegges inn i dette rommet slik at deres kategori kan forutsies.
|
||||
|
||||
### Øvelse - bruk en Support Vector Classifier
|
||||
|
||||
La oss prøve å få litt bedre nøyaktighet med en Support Vector Classifier.
|
||||
|
||||
1. Legg til en komma etter K-Neighbors-elementet, og legg deretter til denne linjen:
|
||||
|
||||
```python
|
||||
'SVC': SVC(),
|
||||
```
|
||||
|
||||
Resultatet er ganske bra!
|
||||
|
||||
```output
|
||||
Accuracy (train) for SVC: 83.2%
|
||||
precision recall f1-score support
|
||||
|
||||
chinese 0.79 0.74 0.76 242
|
||||
indian 0.88 0.90 0.89 234
|
||||
japanese 0.87 0.81 0.84 254
|
||||
korean 0.91 0.82 0.86 242
|
||||
thai 0.74 0.90 0.81 227
|
||||
|
||||
accuracy 0.83 1199
|
||||
macro avg 0.84 0.83 0.83 1199
|
||||
weighted avg 0.84 0.83 0.83 1199
|
||||
```
|
||||
|
||||
✅ Lær om [Support-Vectors](https://scikit-learn.org/stable/modules/svm.html#svm)
|
||||
|
||||
## Ensemble Classifiers
|
||||
|
||||
La oss følge stien helt til slutten, selv om den forrige testen var ganske bra. La oss prøve noen 'Ensemble Classifiers', spesielt Random Forest og AdaBoost:
|
||||
|
||||
```python
|
||||
'RFST': RandomForestClassifier(n_estimators=100),
|
||||
'ADA': AdaBoostClassifier(n_estimators=100)
|
||||
```
|
||||
|
||||
Resultatet er veldig bra, spesielt for Random Forest:
|
||||
|
||||
```output
|
||||
Accuracy (train) for RFST: 84.5%
|
||||
precision recall f1-score support
|
||||
|
||||
chinese 0.80 0.77 0.78 242
|
||||
indian 0.89 0.92 0.90 234
|
||||
japanese 0.86 0.84 0.85 254
|
||||
korean 0.88 0.83 0.85 242
|
||||
thai 0.80 0.87 0.83 227
|
||||
|
||||
accuracy 0.84 1199
|
||||
macro avg 0.85 0.85 0.84 1199
|
||||
weighted avg 0.85 0.84 0.84 1199
|
||||
|
||||
Accuracy (train) for ADA: 72.4%
|
||||
precision recall f1-score support
|
||||
|
||||
chinese 0.64 0.49 0.56 242
|
||||
indian 0.91 0.83 0.87 234
|
||||
japanese 0.68 0.69 0.69 254
|
||||
korean 0.73 0.79 0.76 242
|
||||
thai 0.67 0.83 0.74 227
|
||||
|
||||
accuracy 0.72 1199
|
||||
macro avg 0.73 0.73 0.72 1199
|
||||
weighted avg 0.73 0.72 0.72 1199
|
||||
```
|
||||
|
||||
✅ Lær om [Ensemble Classifiers](https://scikit-learn.org/stable/modules/ensemble.html)
|
||||
|
||||
Denne metoden for maskinlæring "kombinerer prediksjonene fra flere base-estimatorer" for å forbedre modellens kvalitet. I vårt eksempel brukte vi Random Trees og AdaBoost.
|
||||
|
||||
- [Random Forest](https://scikit-learn.org/stable/modules/ensemble.html#forest), en gjennomsnittsmetode, bygger en 'skog' av 'beslutningstrær' med innført tilfeldighet for å unngå overtilpasning. Parameteren n_estimators er satt til antall trær.
|
||||
|
||||
- [AdaBoost](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) tilpasser en klassifikator til et datasett og deretter tilpasser kopier av den klassifikatoren til det samme datasettet. Den fokuserer på vektene til feilklassifiserte elementer og justerer tilpasningen for neste klassifikator for å korrigere.
|
||||
|
||||
---
|
||||
|
||||
## 🚀Utfordring
|
||||
|
||||
Hver av disse teknikkene har et stort antall parametere som du kan justere. Undersøk standardparametrene for hver av dem og tenk på hva justering av disse parameterne vil bety for modellens kvalitet.
|
||||
|
||||
## [Quiz etter leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Gjennomgang og selvstudium
|
||||
|
||||
Det er mye sjargong i disse leksjonene, så ta et øyeblikk til å gå gjennom [denne listen](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) med nyttig terminologi!
|
||||
|
||||
## Oppgave
|
||||
|
||||
[Parameterlek](assignment.md)
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,25 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "58dfdaf79fb73f7d34b22bdbacf57329",
|
||||
"translation_date": "2025-09-05T21:54:33+00:00",
|
||||
"source_file": "4-Classification/3-Classifiers-2/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Parameterlek
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
Det finnes mange parametere som er satt som standard når man jobber med disse klassifiseringsmodellene. Intellisense i VS Code kan hjelpe deg med å utforske dem. Velg en av ML-klassifiseringsteknikkene i denne leksjonen og tren modellene på nytt ved å justere ulike parametere. Lag en notebook som forklarer hvorfor noen endringer forbedrer modellkvaliteten, mens andre forverrer den. Vær detaljert i svaret ditt.
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Eksemplarisk | Tilfredsstillende | Trenger forbedring |
|
||||
| --------- | -------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------- | ---------------------------- |
|
||||
| | En notebook presenteres med en fullt utviklet klassifiseringsmodell, hvor parametere er justert og endringer forklart i tekstbokser | En notebook er delvis presentert eller dårlig forklart | En notebook er feilaktig eller mangelfull |
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
|
||||
"translation_date": "2025-09-05T21:54:45+00:00",
|
||||
"source_file": "4-Classification/3-Classifiers-2/solution/Julia/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,329 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "61bdec27ed2da8b098cd9065405d9bb0",
|
||||
"translation_date": "2025-09-05T21:52:38+00:00",
|
||||
"source_file": "4-Classification/4-Applied/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Bygg en webapp for matanbefalinger
|
||||
|
||||
I denne leksjonen skal du bygge en klassifiseringsmodell ved hjelp av noen av teknikkene du har lært i tidligere leksjoner, samt det deilige matdatasettet som har blitt brukt gjennom denne serien. I tillegg skal du lage en liten webapp for å bruke en lagret modell, ved hjelp av Onnx sin web-runtime.
|
||||
|
||||
En av de mest nyttige praktiske bruksområdene for maskinlæring er å lage anbefalingssystemer, og du kan ta det første steget i den retningen i dag!
|
||||
|
||||
[](https://youtu.be/17wdM9AHMfg "Applied ML")
|
||||
|
||||
> 🎥 Klikk på bildet over for en video: Jen Looper lager en webapp ved hjelp av klassifisert matdata
|
||||
|
||||
## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
I denne leksjonen vil du lære:
|
||||
|
||||
- Hvordan bygge en modell og lagre den som en Onnx-modell
|
||||
- Hvordan bruke Netron for å inspisere modellen
|
||||
- Hvordan bruke modellen din i en webapp for inferens
|
||||
|
||||
## Bygg modellen din
|
||||
|
||||
Å bygge anvendte ML-systemer er en viktig del av å utnytte disse teknologiene for dine forretningssystemer. Du kan bruke modeller i webapplikasjonene dine (og dermed bruke dem i en offline-kontekst om nødvendig) ved hjelp av Onnx.
|
||||
|
||||
I en [tidligere leksjon](../../3-Web-App/1-Web-App/README.md) bygde du en regresjonsmodell om UFO-observasjoner, "picklet" den, og brukte den i en Flask-app. Selv om denne arkitekturen er veldig nyttig å kjenne til, er det en full-stack Python-app, og kravene dine kan inkludere bruk av en JavaScript-applikasjon.
|
||||
|
||||
I denne leksjonen kan du bygge et grunnleggende JavaScript-basert system for inferens. Først må du imidlertid trene en modell og konvertere den for bruk med Onnx.
|
||||
|
||||
## Øvelse - tren klassifiseringsmodell
|
||||
|
||||
Først, tren en klassifiseringsmodell ved hjelp av det rensede matdatasettet vi brukte.
|
||||
|
||||
1. Start med å importere nyttige biblioteker:
|
||||
|
||||
```python
|
||||
!pip install skl2onnx
|
||||
import pandas as pd
|
||||
```
|
||||
|
||||
Du trenger '[skl2onnx](https://onnx.ai/sklearn-onnx/)' for å hjelpe med å konvertere Scikit-learn-modellen din til Onnx-format.
|
||||
|
||||
1. Deretter, arbeid med dataene dine på samme måte som du gjorde i tidligere leksjoner, ved å lese en CSV-fil med `read_csv()`:
|
||||
|
||||
```python
|
||||
data = pd.read_csv('../data/cleaned_cuisines.csv')
|
||||
data.head()
|
||||
```
|
||||
|
||||
1. Fjern de to første unødvendige kolonnene og lagre de gjenværende dataene som 'X':
|
||||
|
||||
```python
|
||||
X = data.iloc[:,2:]
|
||||
X.head()
|
||||
```
|
||||
|
||||
1. Lagre etikettene som 'y':
|
||||
|
||||
```python
|
||||
y = data[['cuisine']]
|
||||
y.head()
|
||||
|
||||
```
|
||||
|
||||
### Start treningsrutinen
|
||||
|
||||
Vi skal bruke 'SVC'-biblioteket som har god nøyaktighet.
|
||||
|
||||
1. Importer de relevante bibliotekene fra Scikit-learn:
|
||||
|
||||
```python
|
||||
from sklearn.model_selection import train_test_split
|
||||
from sklearn.svm import SVC
|
||||
from sklearn.model_selection import cross_val_score
|
||||
from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report
|
||||
```
|
||||
|
||||
1. Del opp trenings- og testsett:
|
||||
|
||||
```python
|
||||
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3)
|
||||
```
|
||||
|
||||
1. Bygg en SVC-klassifiseringsmodell slik du gjorde i den forrige leksjonen:
|
||||
|
||||
```python
|
||||
model = SVC(kernel='linear', C=10, probability=True,random_state=0)
|
||||
model.fit(X_train,y_train.values.ravel())
|
||||
```
|
||||
|
||||
1. Test modellen din ved å kalle `predict()`:
|
||||
|
||||
```python
|
||||
y_pred = model.predict(X_test)
|
||||
```
|
||||
|
||||
1. Skriv ut en klassifiseringsrapport for å sjekke modellens kvalitet:
|
||||
|
||||
```python
|
||||
print(classification_report(y_test,y_pred))
|
||||
```
|
||||
|
||||
Som vi så tidligere, er nøyaktigheten god:
|
||||
|
||||
```output
|
||||
precision recall f1-score support
|
||||
|
||||
chinese 0.72 0.69 0.70 257
|
||||
indian 0.91 0.87 0.89 243
|
||||
japanese 0.79 0.77 0.78 239
|
||||
korean 0.83 0.79 0.81 236
|
||||
thai 0.72 0.84 0.78 224
|
||||
|
||||
accuracy 0.79 1199
|
||||
macro avg 0.79 0.79 0.79 1199
|
||||
weighted avg 0.79 0.79 0.79 1199
|
||||
```
|
||||
|
||||
### Konverter modellen din til Onnx
|
||||
|
||||
Sørg for å gjøre konverteringen med riktig Tensor-nummer. Dette datasettet har 380 ingredienser oppført, så du må notere det nummeret i `FloatTensorType`:
|
||||
|
||||
1. Konverter med et tensor-nummer på 380.
|
||||
|
||||
```python
|
||||
from skl2onnx import convert_sklearn
|
||||
from skl2onnx.common.data_types import FloatTensorType
|
||||
|
||||
initial_type = [('float_input', FloatTensorType([None, 380]))]
|
||||
options = {id(model): {'nocl': True, 'zipmap': False}}
|
||||
```
|
||||
|
||||
1. Lag onx-filen og lagre den som **model.onnx**:
|
||||
|
||||
```python
|
||||
onx = convert_sklearn(model, initial_types=initial_type, options=options)
|
||||
with open("./model.onnx", "wb") as f:
|
||||
f.write(onx.SerializeToString())
|
||||
```
|
||||
|
||||
> Merk, du kan sende inn [alternativer](https://onnx.ai/sklearn-onnx/parameterized.html) i konverteringsskriptet ditt. I dette tilfellet sendte vi inn 'nocl' som True og 'zipmap' som False. Siden dette er en klassifiseringsmodell, har du muligheten til å fjerne ZipMap som produserer en liste med ordbøker (ikke nødvendig). `nocl` refererer til klasseinformasjon som inkluderes i modellen. Reduser modellens størrelse ved å sette `nocl` til 'True'.
|
||||
|
||||
Hvis du kjører hele notebooken, vil du nå bygge en Onnx-modell og lagre den i denne mappen.
|
||||
|
||||
## Vis modellen din
|
||||
|
||||
Onnx-modeller er ikke veldig synlige i Visual Studio Code, men det finnes en veldig god gratis programvare som mange forskere bruker for å visualisere modellen og sikre at den er riktig bygget. Last ned [Netron](https://github.com/lutzroeder/Netron) og åpne model.onnx-filen din. Du kan se den enkle modellen visualisert, med sine 380 input og klassifiserer listet opp:
|
||||
|
||||
|
||||
|
||||
Netron er et nyttig verktøy for å se modellene dine.
|
||||
|
||||
Nå er du klar til å bruke denne flotte modellen i en webapp. La oss bygge en app som vil være nyttig når du ser i kjøleskapet ditt og prøver å finne ut hvilken kombinasjon av ingredienser du kan bruke for å lage en bestemt matrett, som bestemt av modellen din.
|
||||
|
||||
## Bygg en anbefalingswebapplikasjon
|
||||
|
||||
Du kan bruke modellen din direkte i en webapp. Denne arkitekturen lar deg også kjøre den lokalt og til og med offline om nødvendig. Start med å lage en `index.html`-fil i samme mappe der du lagret `model.onnx`-filen.
|
||||
|
||||
1. I denne filen _index.html_, legg til følgende markup:
|
||||
|
||||
```html
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<header>
|
||||
<title>Cuisine Matcher</title>
|
||||
</header>
|
||||
<body>
|
||||
...
|
||||
</body>
|
||||
</html>
|
||||
```
|
||||
|
||||
1. Nå, arbeid innenfor `body`-taggene, og legg til litt markup for å vise en liste med avkrysningsbokser som reflekterer noen ingredienser:
|
||||
|
||||
```html
|
||||
<h1>Check your refrigerator. What can you create?</h1>
|
||||
<div id="wrapper">
|
||||
<div class="boxCont">
|
||||
<input type="checkbox" value="4" class="checkbox">
|
||||
<label>apple</label>
|
||||
</div>
|
||||
|
||||
<div class="boxCont">
|
||||
<input type="checkbox" value="247" class="checkbox">
|
||||
<label>pear</label>
|
||||
</div>
|
||||
|
||||
<div class="boxCont">
|
||||
<input type="checkbox" value="77" class="checkbox">
|
||||
<label>cherry</label>
|
||||
</div>
|
||||
|
||||
<div class="boxCont">
|
||||
<input type="checkbox" value="126" class="checkbox">
|
||||
<label>fenugreek</label>
|
||||
</div>
|
||||
|
||||
<div class="boxCont">
|
||||
<input type="checkbox" value="302" class="checkbox">
|
||||
<label>sake</label>
|
||||
</div>
|
||||
|
||||
<div class="boxCont">
|
||||
<input type="checkbox" value="327" class="checkbox">
|
||||
<label>soy sauce</label>
|
||||
</div>
|
||||
|
||||
<div class="boxCont">
|
||||
<input type="checkbox" value="112" class="checkbox">
|
||||
<label>cumin</label>
|
||||
</div>
|
||||
</div>
|
||||
<div style="padding-top:10px">
|
||||
<button onClick="startInference()">What kind of cuisine can you make?</button>
|
||||
</div>
|
||||
```
|
||||
|
||||
Legg merke til at hver avkrysningsboks har en verdi. Dette reflekterer indeksen der ingrediensen finnes i henhold til datasettet. Eple, for eksempel, i denne alfabetiske listen, opptar den femte kolonnen, så verdien er '4' siden vi begynner å telle fra 0. Du kan konsultere [ingredients spreadsheet](../../../../4-Classification/data/ingredient_indexes.csv) for å finne en gitt ingrediens sin indeks.
|
||||
|
||||
Fortsett arbeidet ditt i index.html-filen, og legg til en script-blokk der modellen kalles etter den siste lukkende `</div>`.
|
||||
|
||||
1. Først, importer [Onnx Runtime](https://www.onnxruntime.ai/):
|
||||
|
||||
```html
|
||||
<script src="https://cdn.jsdelivr.net/npm/onnxruntime-web@1.9.0/dist/ort.min.js"></script>
|
||||
```
|
||||
|
||||
> Onnx Runtime brukes for å muliggjøre kjøring av Onnx-modeller på tvers av et bredt spekter av maskinvareplattformer, inkludert optimaliseringer og en API for bruk.
|
||||
|
||||
1. Når Runtime er på plass, kan du kalle den:
|
||||
|
||||
```html
|
||||
<script>
|
||||
const ingredients = Array(380).fill(0);
|
||||
|
||||
const checks = [...document.querySelectorAll('.checkbox')];
|
||||
|
||||
checks.forEach(check => {
|
||||
check.addEventListener('change', function() {
|
||||
// toggle the state of the ingredient
|
||||
// based on the checkbox's value (1 or 0)
|
||||
ingredients[check.value] = check.checked ? 1 : 0;
|
||||
});
|
||||
});
|
||||
|
||||
function testCheckboxes() {
|
||||
// validate if at least one checkbox is checked
|
||||
return checks.some(check => check.checked);
|
||||
}
|
||||
|
||||
async function startInference() {
|
||||
|
||||
let atLeastOneChecked = testCheckboxes()
|
||||
|
||||
if (!atLeastOneChecked) {
|
||||
alert('Please select at least one ingredient.');
|
||||
return;
|
||||
}
|
||||
try {
|
||||
// create a new session and load the model.
|
||||
|
||||
const session = await ort.InferenceSession.create('./model.onnx');
|
||||
|
||||
const input = new ort.Tensor(new Float32Array(ingredients), [1, 380]);
|
||||
const feeds = { float_input: input };
|
||||
|
||||
// feed inputs and run
|
||||
const results = await session.run(feeds);
|
||||
|
||||
// read from results
|
||||
alert('You can enjoy ' + results.label.data[0] + ' cuisine today!')
|
||||
|
||||
} catch (e) {
|
||||
console.log(`failed to inference ONNX model`);
|
||||
console.error(e);
|
||||
}
|
||||
}
|
||||
|
||||
</script>
|
||||
```
|
||||
|
||||
I denne koden skjer det flere ting:
|
||||
|
||||
1. Du opprettet et array med 380 mulige verdier (1 eller 0) som skal settes og sendes til modellen for inferens, avhengig av om en ingrediens avkrysningsboks er krysset av.
|
||||
2. Du opprettet et array med avkrysningsbokser og en måte å avgjøre om de var krysset av i en `init`-funksjon som kalles når applikasjonen starter. Når en avkrysningsboks er krysset av, endres `ingredients`-arrayet for å reflektere den valgte ingrediensen.
|
||||
3. Du opprettet en `testCheckboxes`-funksjon som sjekker om noen avkrysningsboks er krysset av.
|
||||
4. Du bruker `startInference`-funksjonen når knappen trykkes, og hvis noen avkrysningsboks er krysset av, starter du inferens.
|
||||
5. Inferensrutinen inkluderer:
|
||||
1. Oppsett av en asynkron last av modellen
|
||||
2. Opprettelse av en Tensor-struktur som skal sendes til modellen
|
||||
3. Opprettelse av 'feeds' som reflekterer `float_input`-input som du opprettet da du trente modellen din (du kan bruke Netron for å verifisere det navnet)
|
||||
4. Sending av disse 'feeds' til modellen og venter på et svar
|
||||
|
||||
## Test applikasjonen din
|
||||
|
||||
Åpne en terminalsesjon i Visual Studio Code i mappen der index.html-filen din ligger. Sørg for at du har [http-server](https://www.npmjs.com/package/http-server) installert globalt, og skriv `http-server` ved ledeteksten. En localhost skal åpne seg, og du kan se webappen din. Sjekk hvilken matrett som anbefales basert på ulike ingredienser:
|
||||
|
||||
|
||||
|
||||
Gratulerer, du har laget en 'anbefalings'-webapp med noen få felt. Ta deg tid til å bygge ut dette systemet!
|
||||
|
||||
## 🚀Utfordring
|
||||
|
||||
Webappen din er veldig enkel, så fortsett å bygge den ut ved hjelp av ingredienser og deres indekser fra [ingredient_indexes](../../../../4-Classification/data/ingredient_indexes.csv)-data. Hvilke smakskombinasjoner fungerer for å lage en gitt nasjonalrett?
|
||||
|
||||
## [Quiz etter leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Gjennomgang og selvstudium
|
||||
|
||||
Selv om denne leksjonen bare berørte nytten av å lage et anbefalingssystem for matingredienser, er dette området innen ML-applikasjoner veldig rikt på eksempler. Les mer om hvordan disse systemene bygges:
|
||||
|
||||
- https://www.sciencedirect.com/topics/computer-science/recommendation-engine
|
||||
- https://www.technologyreview.com/2014/08/25/171547/the-ultimate-challenge-for-recommendation-engines/
|
||||
- https://www.technologyreview.com/2015/03/23/168831/everything-is-a-recommendation/
|
||||
|
||||
## Oppgave
|
||||
|
||||
[Bygg en ny anbefaler](assignment.md)
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,25 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "799ed651e2af0a7cad17c6268db11578",
|
||||
"translation_date": "2025-09-05T21:53:13+00:00",
|
||||
"source_file": "4-Classification/4-Applied/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Bygg en anbefalingsmotor
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
Basert på øvelsene i denne leksjonen, vet du nå hvordan du kan bygge en JavaScript-basert webapp ved hjelp av Onnx Runtime og en konvertert Onnx-modell. Eksperimenter med å lage en ny anbefalingsmotor ved å bruke data fra disse leksjonene eller hentet fra andre kilder (husk å gi kreditt). Du kan for eksempel lage en anbefalingsmotor for kjæledyr basert på ulike personlighetstrekk, eller en anbefalingsmotor for musikksjangre basert på en persons humør. Vær kreativ!
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Eksemplarisk | Tilfredsstillende | Trenger forbedring |
|
||||
| --------- | ---------------------------------------------------------------------- | ------------------------------------- | --------------------------------- |
|
||||
| | En webapp og notatbok presenteres, begge godt dokumentert og fungerende | En av dem mangler eller har feil | Begge mangler eller har feil |
|
||||
|
||||
---
|
||||
|
||||
**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 eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.
|
||||
@ -0,0 +1,41 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "74e809ffd1e613a1058bbc3e9600859e",
|
||||
"translation_date": "2025-09-05T21:49:12+00:00",
|
||||
"source_file": "4-Classification/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Komme i gang med klassifisering
|
||||
|
||||
## Regionalt tema: Deilige asiatiske og indiske retter 🍜
|
||||
|
||||
I Asia og India er mattradisjonene svært mangfoldige og utrolig smakfulle! La oss se på data om regionale retter for å prøve å forstå ingrediensene deres.
|
||||
|
||||
|
||||
> Foto av <a href="https://unsplash.com/@changlisheng?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Lisheng Chang</a> på <a href="https://unsplash.com/s/photos/asian-food?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
|
||||
|
||||
## Hva du vil lære
|
||||
|
||||
I denne delen vil du bygge videre på din tidligere studie av regresjon og lære om andre klassifikatorer som du kan bruke for å forstå dataene bedre.
|
||||
|
||||
> Det finnes nyttige lavkodeverktøy som kan hjelpe deg med å lære om arbeid med klassifiseringsmodeller. Prøv [Azure ML for denne oppgaven](https://docs.microsoft.com/learn/modules/create-classification-model-azure-machine-learning-designer/?WT.mc_id=academic-77952-leestott)
|
||||
|
||||
## Leksjoner
|
||||
|
||||
1. [Introduksjon til klassifisering](1-Introduction/README.md)
|
||||
2. [Flere klassifikatorer](2-Classifiers-1/README.md)
|
||||
3. [Enda flere klassifikatorer](3-Classifiers-2/README.md)
|
||||
4. [Anvendt ML: bygg en webapplikasjon](4-Applied/README.md)
|
||||
|
||||
## Krediteringer
|
||||
|
||||
"Komme i gang med klassifisering" ble skrevet med ♥️ av [Cassie Breviu](https://www.twitter.com/cassiebreviu) og [Jen Looper](https://www.twitter.com/jenlooper)
|
||||
|
||||
Datasettet for de deilige rettene ble hentet fra [Kaggle](https://www.kaggle.com/hoandan/asian-and-indian-cuisines).
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,25 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "589fa015a5e7d9e67bd629f7d47b53de",
|
||||
"translation_date": "2025-09-05T21:28:34+00:00",
|
||||
"source_file": "5-Clustering/1-Visualize/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Utforsk andre visualiseringer for klynging
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
I denne leksjonen har du jobbet med noen visualiseringsteknikker for å få en forståelse av hvordan du kan plotte dataene dine som forberedelse til klynging. Spesielt er spredningsdiagrammer nyttige for å finne grupper av objekter. Undersøk forskjellige måter og ulike biblioteker for å lage spredningsdiagrammer, og dokumenter arbeidet ditt i en notatbok. Du kan bruke data fra denne leksjonen, andre leksjoner, eller data du selv finner (husk å kreditere kilden i notatboken din). Plot noen data ved hjelp av spredningsdiagrammer og forklar hva du oppdager.
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Fremragende | Tilfredsstillende | Trenger forbedring |
|
||||
| --------- | ------------------------------------------------------------- | --------------------------------------------------------------------------------------- | ----------------------------------- |
|
||||
| | En notatbok presenteres med fem godt dokumenterte spredningsdiagrammer | En notatbok presenteres med færre enn fem spredningsdiagrammer og er mindre godt dokumentert | En ufullstendig notatbok presenteres |
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
|
||||
"translation_date": "2025-09-05T21:28:47+00:00",
|
||||
"source_file": "5-Clustering/1-Visualize/solution/Julia/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,261 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "7cdd17338d9bbd7e2171c2cd462eb081",
|
||||
"translation_date": "2025-09-05T21:29:46+00:00",
|
||||
"source_file": "5-Clustering/2-K-Means/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# K-Means klynging
|
||||
|
||||
## [Pre-forelesningsquiz](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
I denne leksjonen vil du lære hvordan du lager klynger ved hjelp av Scikit-learn og det nigerianske musikkdatasettet du importerte tidligere. Vi skal dekke det grunnleggende om K-Means for klynging. Husk at, som du lærte i den forrige leksjonen, finnes det mange måter å jobbe med klynger på, og metoden du bruker avhenger av dataene dine. Vi skal prøve K-Means siden det er den mest vanlige klyngemetoden. La oss komme i gang!
|
||||
|
||||
Begreper du vil lære om:
|
||||
|
||||
- Silhuett-score
|
||||
- Albuemetoden
|
||||
- Inertia
|
||||
- Varians
|
||||
|
||||
## Introduksjon
|
||||
|
||||
[K-Means klynging](https://wikipedia.org/wiki/K-means_clustering) er en metode som stammer fra signalbehandling. Den brukes til å dele og gruppere datasett i 'k' klynger basert på en serie observasjoner. Hver observasjon jobber for å gruppere et gitt datapunkt nærmest sin 'gjennomsnittlige verdi', eller midtpunktet i en klynge.
|
||||
|
||||
Klyngene kan visualiseres som [Voronoi-diagrammer](https://wikipedia.org/wiki/Voronoi_diagram), som inkluderer et punkt (eller 'frø') og dets tilhørende område.
|
||||
|
||||
|
||||
|
||||
> Infografikk av [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
K-Means klyngingsprosessen [utføres i tre trinn](https://scikit-learn.org/stable/modules/clustering.html#k-means):
|
||||
|
||||
1. Algoritmen velger et k-antall midtpunkter ved å ta prøver fra datasettet. Deretter gjentas følgende:
|
||||
1. Den tilordner hver prøve til det nærmeste midtpunktet.
|
||||
2. Den lager nye midtpunkter ved å ta gjennomsnittsverdien av alle prøvene som er tilordnet de tidligere midtpunktene.
|
||||
3. Deretter beregner den forskjellen mellom de nye og gamle midtpunktene og gjentar til midtpunktene stabiliseres.
|
||||
|
||||
En ulempe med å bruke K-Means er at du må bestemme 'k', altså antallet midtpunkter. Heldigvis kan 'albuemetoden' hjelpe med å estimere en god startverdi for 'k'. Du skal prøve det om et øyeblikk.
|
||||
|
||||
## Forutsetninger
|
||||
|
||||
Du vil jobbe i denne leksjonens [_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/2-K-Means/notebook.ipynb)-fil, som inkluderer dataimporten og den innledende rengjøringen du gjorde i forrige leksjon.
|
||||
|
||||
## Øvelse - forberedelse
|
||||
|
||||
Start med å ta en ny titt på sangdataene.
|
||||
|
||||
1. Lag et boksplott ved å kalle `boxplot()` for hver kolonne:
|
||||
|
||||
```python
|
||||
plt.figure(figsize=(20,20), dpi=200)
|
||||
|
||||
plt.subplot(4,3,1)
|
||||
sns.boxplot(x = 'popularity', data = df)
|
||||
|
||||
plt.subplot(4,3,2)
|
||||
sns.boxplot(x = 'acousticness', data = df)
|
||||
|
||||
plt.subplot(4,3,3)
|
||||
sns.boxplot(x = 'energy', data = df)
|
||||
|
||||
plt.subplot(4,3,4)
|
||||
sns.boxplot(x = 'instrumentalness', data = df)
|
||||
|
||||
plt.subplot(4,3,5)
|
||||
sns.boxplot(x = 'liveness', data = df)
|
||||
|
||||
plt.subplot(4,3,6)
|
||||
sns.boxplot(x = 'loudness', data = df)
|
||||
|
||||
plt.subplot(4,3,7)
|
||||
sns.boxplot(x = 'speechiness', data = df)
|
||||
|
||||
plt.subplot(4,3,8)
|
||||
sns.boxplot(x = 'tempo', data = df)
|
||||
|
||||
plt.subplot(4,3,9)
|
||||
sns.boxplot(x = 'time_signature', data = df)
|
||||
|
||||
plt.subplot(4,3,10)
|
||||
sns.boxplot(x = 'danceability', data = df)
|
||||
|
||||
plt.subplot(4,3,11)
|
||||
sns.boxplot(x = 'length', data = df)
|
||||
|
||||
plt.subplot(4,3,12)
|
||||
sns.boxplot(x = 'release_date', data = df)
|
||||
```
|
||||
|
||||
Disse dataene er litt støyete: ved å observere hver kolonne som et boksplott kan du se uteliggere.
|
||||
|
||||
|
||||
|
||||
Du kunne gått gjennom datasettet og fjernet disse uteliggerne, men det ville gjort dataene ganske minimale.
|
||||
|
||||
1. For nå, velg hvilke kolonner du vil bruke til klyngingsøvelsen. Velg kolonner med lignende verdier og kod `artist_top_genre`-kolonnen som numeriske data:
|
||||
|
||||
```python
|
||||
from sklearn.preprocessing import LabelEncoder
|
||||
le = LabelEncoder()
|
||||
|
||||
X = df.loc[:, ('artist_top_genre','popularity','danceability','acousticness','loudness','energy')]
|
||||
|
||||
y = df['artist_top_genre']
|
||||
|
||||
X['artist_top_genre'] = le.fit_transform(X['artist_top_genre'])
|
||||
|
||||
y = le.transform(y)
|
||||
```
|
||||
|
||||
1. Nå må du velge hvor mange klynger du vil målrette. Du vet at det er 3 sangsjangre som vi har skilt ut fra datasettet, så la oss prøve med 3:
|
||||
|
||||
```python
|
||||
from sklearn.cluster import KMeans
|
||||
|
||||
nclusters = 3
|
||||
seed = 0
|
||||
|
||||
km = KMeans(n_clusters=nclusters, random_state=seed)
|
||||
km.fit(X)
|
||||
|
||||
# Predict the cluster for each data point
|
||||
|
||||
y_cluster_kmeans = km.predict(X)
|
||||
y_cluster_kmeans
|
||||
```
|
||||
|
||||
Du ser en matrise som skrives ut med forutsagte klynger (0, 1 eller 2) for hver rad i dataframen.
|
||||
|
||||
1. Bruk denne matrisen til å beregne en 'silhuett-score':
|
||||
|
||||
```python
|
||||
from sklearn import metrics
|
||||
score = metrics.silhouette_score(X, y_cluster_kmeans)
|
||||
score
|
||||
```
|
||||
|
||||
## Silhuett-score
|
||||
|
||||
Se etter en silhuett-score nærmere 1. Denne scoren varierer fra -1 til 1, og hvis scoren er 1, er klyngen tett og godt adskilt fra andre klynger. En verdi nær 0 representerer overlappende klynger med prøver som er veldig nær beslutningsgrensen til naboklyngene. [(Kilde)](https://dzone.com/articles/kmeans-silhouette-score-explained-with-python-exam)
|
||||
|
||||
Vår score er **0,53**, altså midt på treet. Dette indikerer at dataene våre ikke er spesielt godt egnet for denne typen klynging, men la oss fortsette.
|
||||
|
||||
### Øvelse - bygg en modell
|
||||
|
||||
1. Importer `KMeans` og start klyngingsprosessen.
|
||||
|
||||
```python
|
||||
from sklearn.cluster import KMeans
|
||||
wcss = []
|
||||
|
||||
for i in range(1, 11):
|
||||
kmeans = KMeans(n_clusters = i, init = 'k-means++', random_state = 42)
|
||||
kmeans.fit(X)
|
||||
wcss.append(kmeans.inertia_)
|
||||
|
||||
```
|
||||
|
||||
Det er noen deler her som fortjener en forklaring.
|
||||
|
||||
> 🎓 range: Dette er iterasjonene av klyngingsprosessen.
|
||||
|
||||
> 🎓 random_state: "Bestemmer tilfeldig tallgenerering for initialisering av midtpunkter." [Kilde](https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html#sklearn.cluster.KMeans)
|
||||
|
||||
> 🎓 WCSS: "Summen av kvadrerte avstander innenfor klyngen" måler den kvadrerte gjennomsnittsavstanden for alle punktene innenfor en klynge til klyngens midtpunkt. [Kilde](https://medium.com/@ODSC/unsupervised-learning-evaluating-clusters-bd47eed175ce).
|
||||
|
||||
> 🎓 Inertia: K-Means-algoritmer forsøker å velge midtpunkter for å minimere 'inertia', "et mål på hvor internt sammenhengende klynger er." [Kilde](https://scikit-learn.org/stable/modules/clustering.html). Verdien legges til variabelen wcss ved hver iterasjon.
|
||||
|
||||
> 🎓 k-means++: I [Scikit-learn](https://scikit-learn.org/stable/modules/clustering.html#k-means) kan du bruke 'k-means++'-optimalisering, som "initialiserer midtpunktene til å være (generelt) langt fra hverandre, noe som gir sannsynligvis bedre resultater enn tilfeldig initialisering."
|
||||
|
||||
### Albuemetoden
|
||||
|
||||
Tidligere antok du at, siden du har målrettet 3 sangsjangre, bør du velge 3 klynger. Men er det tilfelle?
|
||||
|
||||
1. Bruk 'albuemetoden' for å være sikker.
|
||||
|
||||
```python
|
||||
plt.figure(figsize=(10,5))
|
||||
sns.lineplot(x=range(1, 11), y=wcss, marker='o', color='red')
|
||||
plt.title('Elbow')
|
||||
plt.xlabel('Number of clusters')
|
||||
plt.ylabel('WCSS')
|
||||
plt.show()
|
||||
```
|
||||
|
||||
Bruk variabelen `wcss` som du bygde i forrige steg til å lage et diagram som viser hvor 'knekkpunktet' i albuen er, som indikerer det optimale antallet klynger. Kanskje det **er** 3!
|
||||
|
||||
|
||||
|
||||
## Øvelse - vis klyngene
|
||||
|
||||
1. Prøv prosessen igjen, denne gangen med tre klynger, og vis klyngene som et spredningsdiagram:
|
||||
|
||||
```python
|
||||
from sklearn.cluster import KMeans
|
||||
kmeans = KMeans(n_clusters = 3)
|
||||
kmeans.fit(X)
|
||||
labels = kmeans.predict(X)
|
||||
plt.scatter(df['popularity'],df['danceability'],c = labels)
|
||||
plt.xlabel('popularity')
|
||||
plt.ylabel('danceability')
|
||||
plt.show()
|
||||
```
|
||||
|
||||
1. Sjekk modellens nøyaktighet:
|
||||
|
||||
```python
|
||||
labels = kmeans.labels_
|
||||
|
||||
correct_labels = sum(y == labels)
|
||||
|
||||
print("Result: %d out of %d samples were correctly labeled." % (correct_labels, y.size))
|
||||
|
||||
print('Accuracy score: {0:0.2f}'. format(correct_labels/float(y.size)))
|
||||
```
|
||||
|
||||
Denne modellens nøyaktighet er ikke særlig god, og formen på klyngene gir deg et hint om hvorfor.
|
||||
|
||||
|
||||
|
||||
Disse dataene er for ubalanserte, for lite korrelerte, og det er for mye varians mellom kolonneverdiene til å klynge godt. Faktisk er klyngene som dannes sannsynligvis sterkt påvirket eller skjevfordelt av de tre sjangerkategoriene vi definerte ovenfor. Det var en læringsprosess!
|
||||
|
||||
I Scikit-learns dokumentasjon kan du se at en modell som denne, med klynger som ikke er særlig godt avgrenset, har et 'varians'-problem:
|
||||
|
||||
|
||||
> Infografikk fra Scikit-learn
|
||||
|
||||
## Varians
|
||||
|
||||
Varians er definert som "gjennomsnittet av de kvadrerte forskjellene fra gjennomsnittet" [(Kilde)](https://www.mathsisfun.com/data/standard-deviation.html). I konteksten av dette klyngeproblemet refererer det til data der tallene i datasettet har en tendens til å avvike litt for mye fra gjennomsnittet.
|
||||
|
||||
✅ Dette er et godt tidspunkt å tenke på alle måtene du kan rette opp dette problemet. Justere dataene litt mer? Bruke andre kolonner? Bruke en annen algoritme? Hint: Prøv [å skalere dataene dine](https://www.mygreatlearning.com/blog/learning-data-science-with-k-means-clustering/) for å normalisere dem og teste andre kolonner.
|
||||
|
||||
> Prøv denne '[varianskalkulatoren](https://www.calculatorsoup.com/calculators/statistics/variance-calculator.php)' for å forstå konseptet litt bedre.
|
||||
|
||||
---
|
||||
|
||||
## 🚀Utfordring
|
||||
|
||||
Bruk litt tid på denne notebooken og juster parametere. Kan du forbedre modellens nøyaktighet ved å rense dataene mer (for eksempel fjerne uteliggere)? Du kan bruke vekter for å gi mer vekt til visse datapunkter. Hva annet kan du gjøre for å lage bedre klynger?
|
||||
|
||||
Hint: Prøv å skalere dataene dine. Det er kommentert kode i notebooken som legger til standard skalering for å få datakolonnene til å ligne hverandre mer når det gjelder verdier. Du vil oppdage at selv om silhuett-scoren går ned, jevner 'knekkpunktet' i albuegrafen seg ut. Dette skyldes at å la dataene være uskalert gjør at data med mindre varians får mer vekt. Les mer om dette problemet [her](https://stats.stackexchange.com/questions/21222/are-mean-normalization-and-feature-scaling-needed-for-k-means-clustering/21226#21226).
|
||||
|
||||
## [Etter-forelesningsquiz](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Gjennomgang & Selvstudium
|
||||
|
||||
Ta en titt på en K-Means-simulator [som denne](https://user.ceng.metu.edu.tr/~akifakkus/courses/ceng574/k-means/). Du kan bruke dette verktøyet til å visualisere prøvedatapunkter og bestemme midtpunktene deres. Du kan redigere dataens tilfeldighet, antall klynger og antall midtpunkter. Hjelper dette deg med å få en idé om hvordan dataene kan grupperes?
|
||||
|
||||
Ta også en titt på [dette handoutet om K-Means](https://stanford.edu/~cpiech/cs221/handouts/kmeans.html) fra Stanford.
|
||||
|
||||
## Oppgave
|
||||
|
||||
[Prøv forskjellige klyngemetoder](assignment.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, 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.
|
||||
@ -0,0 +1,25 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "b8e17eff34ad1680eba2a5d3cf9ffc41",
|
||||
"translation_date": "2025-09-05T21:30:25+00:00",
|
||||
"source_file": "5-Clustering/2-K-Means/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Prøv forskjellige klyngemetoder
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
I denne leksjonen lærte du om K-Means klynging. Noen ganger er K-Means ikke passende for dine data. Lag en notatbok ved å bruke data enten fra disse leksjonene eller fra et annet sted (krediter kilden din) og vis en annen klyngemetode som IKKE bruker K-Means. Hva lærte du?
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Eksemplarisk | Tilfredsstillende | Trenger forbedring |
|
||||
| --------- | --------------------------------------------------------------- | -------------------------------------------------------------------- | ---------------------------- |
|
||||
| | En notatbok presenteres med en godt dokumentert klyngemodell | En notatbok presenteres uten god dokumentasjon og/eller ufullstendig | Ufullstendig arbeid leveres |
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
|
||||
"translation_date": "2025-09-05T21:30:37+00:00",
|
||||
"source_file": "5-Clustering/2-K-Means/solution/Julia/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,42 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "b28a3a4911584062772c537b653ebbc7",
|
||||
"translation_date": "2025-09-05T21:25:20+00:00",
|
||||
"source_file": "5-Clustering/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Klusteringsmodeller for maskinlæring
|
||||
|
||||
Klustering er en oppgave innen maskinlæring hvor man forsøker å finne objekter som ligner på hverandre og gruppere disse i grupper kalt klynger. Det som skiller klustering fra andre tilnærminger i maskinlæring, er at ting skjer automatisk. Faktisk kan man si at det er det motsatte av veiledet læring.
|
||||
|
||||
## Regionalt tema: klusteringsmodeller for en nigeriansk publikums musikksmak 🎧
|
||||
|
||||
Nigerias mangfoldige publikum har varierte musikksmaker. Ved å bruke data hentet fra Spotify (inspirert av [denne artikkelen](https://towardsdatascience.com/country-wise-visual-analysis-of-music-taste-using-spotify-api-seaborn-in-python-77f5b749b421)), la oss se på noe av musikken som er populær i Nigeria. Dette datasettet inkluderer informasjon om ulike sangers 'dansbarhet'-score, 'akustisitet', lydstyrke, 'taleinnhold', popularitet og energi. Det vil være interessant å oppdage mønstre i disse dataene!
|
||||
|
||||
|
||||
|
||||
> Foto av <a href="https://unsplash.com/@marcelalaskoski?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Marcela Laskoski</a> på <a href="https://unsplash.com/s/photos/nigerian-music?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
|
||||
|
||||
I denne serien med leksjoner vil du oppdage nye måter å analysere data på ved hjelp av klusteringsteknikker. Klustering er spesielt nyttig når datasettet ditt mangler etiketter. Hvis det har etiketter, kan klassifiseringsteknikker som de du lærte i tidligere leksjoner være mer nyttige. Men i tilfeller der du ønsker å gruppere umerkede data, er klustering en flott måte å oppdage mønstre på.
|
||||
|
||||
> Det finnes nyttige lavkodeverktøy som kan hjelpe deg med å lære å arbeide med klusteringsmodeller. Prøv [Azure ML for denne oppgaven](https://docs.microsoft.com/learn/modules/create-clustering-model-azure-machine-learning-designer/?WT.mc_id=academic-77952-leestott)
|
||||
|
||||
## Leksjoner
|
||||
|
||||
1. [Introduksjon til klustering](1-Visualize/README.md)
|
||||
2. [K-Means klustering](2-K-Means/README.md)
|
||||
|
||||
## Krediteringer
|
||||
|
||||
Disse leksjonene ble skrevet med 🎶 av [Jen Looper](https://www.twitter.com/jenlooper) med nyttige vurderinger fra [Rishit Dagli](https://rishit_dagli) og [Muhammad Sakib Khan Inan](https://twitter.com/Sakibinan).
|
||||
|
||||
Datasettet [Nigerian Songs](https://www.kaggle.com/sootersaalu/nigerian-songs-spotify) ble hentet fra Kaggle som data fra Spotify.
|
||||
|
||||
Nyttige K-Means-eksempler som bidro til å lage denne leksjonen inkluderer denne [iris-utforskningen](https://www.kaggle.com/bburns/iris-exploration-pca-k-means-and-gmm-clustering), denne [introduksjonsnotatboken](https://www.kaggle.com/prashant111/k-means-clustering-with-python), og dette [hypotetiske NGO-eksempelet](https://www.kaggle.com/ankandash/pca-k-means-clustering-hierarchical-clustering).
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,179 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "1c2ec40cf55c98a028a359c27ef7e45a",
|
||||
"translation_date": "2025-09-05T22:22:25+00:00",
|
||||
"source_file": "6-NLP/1-Introduction-to-NLP/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Introduksjon til naturlig språkbehandling
|
||||
|
||||
Denne leksjonen dekker en kort historie og viktige konsepter innen *naturlig språkbehandling*, et underfelt av *datamaskinlingvistikk*.
|
||||
|
||||
## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Introduksjon
|
||||
|
||||
NLP, som det ofte kalles, er et av de mest kjente områdene hvor maskinlæring har blitt anvendt og brukt i produksjonsprogramvare.
|
||||
|
||||
✅ Kan du tenke på programvare du bruker hver dag som sannsynligvis har noe NLP innebygd? Hva med tekstbehandlingsprogrammer eller mobilapper du bruker regelmessig?
|
||||
|
||||
Du vil lære om:
|
||||
|
||||
- **Ideen om språk**. Hvordan språk utviklet seg og hva de viktigste studieområdene har vært.
|
||||
- **Definisjon og konsepter**. Du vil også lære definisjoner og konsepter om hvordan datamaskiner behandler tekst, inkludert parsing, grammatikk og identifisering av substantiver og verb. Det er noen kodingsoppgaver i denne leksjonen, og flere viktige konsepter introduseres som du vil lære å kode senere i de neste leksjonene.
|
||||
|
||||
## Datamaskinlingvistikk
|
||||
|
||||
Datamaskinlingvistikk er et forsknings- og utviklingsområde gjennom mange tiår som studerer hvordan datamaskiner kan arbeide med, og til og med forstå, oversette og kommunisere med språk. Naturlig språkbehandling (NLP) er et relatert felt som fokuserer på hvordan datamaskiner kan behandle 'naturlige', eller menneskelige, språk.
|
||||
|
||||
### Eksempel - diktering på telefon
|
||||
|
||||
Hvis du noen gang har diktert til telefonen din i stedet for å skrive eller spurt en virtuell assistent et spørsmål, ble talen din konvertert til tekstform og deretter behandlet eller *parset* fra språket du snakket. De oppdagede nøkkelordene ble deretter behandlet til et format som telefonen eller assistenten kunne forstå og handle på.
|
||||
|
||||
|
||||
> Ekte språklig forståelse er vanskelig! Bilde av [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
### Hvordan er denne teknologien mulig?
|
||||
|
||||
Dette er mulig fordi noen har skrevet et dataprogram for å gjøre dette. For noen tiår siden forutså noen science fiction-forfattere at folk stort sett ville snakke med datamaskinene sine, og at datamaskinene alltid ville forstå nøyaktig hva de mente. Dessverre viste det seg å være et vanskeligere problem enn mange forestilte seg, og selv om det er et mye bedre forstått problem i dag, er det betydelige utfordringer med å oppnå 'perfekt' naturlig språkbehandling når det gjelder å forstå meningen med en setning. Dette er spesielt vanskelig når det gjelder å forstå humor eller oppdage følelser som sarkasme i en setning.
|
||||
|
||||
På dette tidspunktet husker du kanskje skoletimer der læreren dekket grammatiske deler av en setning. I noen land blir elever undervist i grammatikk og lingvistikk som et eget fag, men i mange land er disse temaene inkludert som en del av språkopplæringen: enten ditt førstespråk i barneskolen (lære å lese og skrive) og kanskje et andrespråk i ungdomsskolen eller videregående. Ikke bekymre deg hvis du ikke er ekspert på å skille substantiver fra verb eller adverb fra adjektiver!
|
||||
|
||||
Hvis du sliter med forskjellen mellom *presens* og *presens progressiv*, er du ikke alene. Dette er utfordrende for mange mennesker, selv de som har språket som morsmål. Den gode nyheten er at datamaskiner er veldig gode til å anvende formelle regler, og du vil lære å skrive kode som kan *parse* en setning like godt som et menneske. Den større utfordringen du vil undersøke senere er å forstå *meningen* og *følelsen* av en setning.
|
||||
|
||||
## Forutsetninger
|
||||
|
||||
For denne leksjonen er den viktigste forutsetningen at du kan lese og forstå språket i denne leksjonen. Det er ingen matematiske problemer eller ligninger å løse. Selv om den opprinnelige forfatteren skrev denne leksjonen på engelsk, er den også oversatt til andre språk, så du kan lese en oversettelse. Det er eksempler der flere forskjellige språk brukes (for å sammenligne de forskjellige grammatikkreglene for ulike språk). Disse er *ikke* oversatt, men den forklarende teksten er det, så meningen bør være klar.
|
||||
|
||||
For kodingsoppgavene vil du bruke Python, og eksemplene bruker Python 3.8.
|
||||
|
||||
I denne delen vil du trenge og bruke:
|
||||
|
||||
- **Python 3 forståelse**. Forståelse av programmeringsspråket Python 3, denne leksjonen bruker input, løkker, fillesing, arrays.
|
||||
- **Visual Studio Code + utvidelse**. Vi vil bruke Visual Studio Code og dens Python-utvidelse. Du kan også bruke en Python IDE etter eget valg.
|
||||
- **TextBlob**. [TextBlob](https://github.com/sloria/TextBlob) er et forenklet tekstbehandlingsbibliotek for Python. Følg instruksjonene på TextBlob-nettstedet for å installere det på systemet ditt (installer også corpora, som vist nedenfor):
|
||||
|
||||
```bash
|
||||
pip install -U textblob
|
||||
python -m textblob.download_corpora
|
||||
```
|
||||
|
||||
> 💡 Tips: Du kan kjøre Python direkte i VS Code-miljøer. Sjekk [dokumentasjonen](https://code.visualstudio.com/docs/languages/python?WT.mc_id=academic-77952-leestott) for mer informasjon.
|
||||
|
||||
## Å snakke med maskiner
|
||||
|
||||
Historien om å prøve å få datamaskiner til å forstå menneskelig språk går flere tiår tilbake, og en av de tidligste forskerne som vurderte naturlig språkbehandling var *Alan Turing*.
|
||||
|
||||
### 'Turing-testen'
|
||||
|
||||
Da Turing forsket på *kunstig intelligens* på 1950-tallet, vurderte han om en samtaletest kunne gis til et menneske og en datamaskin (via skriftlig korrespondanse) der mennesket i samtalen ikke var sikker på om de kommuniserte med et annet menneske eller en datamaskin.
|
||||
|
||||
Hvis, etter en viss lengde på samtalen, mennesket ikke kunne avgjøre om svarene kom fra en datamaskin eller ikke, kunne datamaskinen da sies å *tenke*?
|
||||
|
||||
### Inspirasjonen - 'imitasjonsspillet'
|
||||
|
||||
Ideen til dette kom fra et selskapslek kalt *Imitasjonsspillet* der en utspørrer er alene i et rom og har som oppgave å avgjøre hvem av to personer (i et annet rom) som er henholdsvis mann og kvinne. Utspørreren kan sende notater og må prøve å tenke på spørsmål der de skriftlige svarene avslører kjønnet til den mystiske personen. Selvfølgelig prøver spillerne i det andre rommet å lure utspørreren ved å svare på spørsmål på en måte som villeder eller forvirrer utspørreren, samtidig som de gir inntrykk av å svare ærlig.
|
||||
|
||||
### Utviklingen av Eliza
|
||||
|
||||
På 1960-tallet utviklet en MIT-forsker ved navn *Joseph Weizenbaum* [*Eliza*](https://wikipedia.org/wiki/ELIZA), en datamaskin-'terapeut' som ville stille mennesket spørsmål og gi inntrykk av å forstå svarene deres. Men selv om Eliza kunne parse en setning og identifisere visse grammatiske konstruksjoner og nøkkelord for å gi et rimelig svar, kunne det ikke sies å *forstå* setningen. Hvis Eliza ble presentert med en setning som følger formatet "**Jeg er** <u>trist</u>", kunne den omorganisere og erstatte ord i setningen for å danne svaret "Hvor lenge har **du vært** <u>trist</u>".
|
||||
|
||||
Dette ga inntrykk av at Eliza forsto utsagnet og stilte et oppfølgingsspørsmål, mens den i virkeligheten endret tid og la til noen ord. Hvis Eliza ikke kunne identifisere et nøkkelord som den hadde et svar for, ville den i stedet gi et tilfeldig svar som kunne være anvendelig for mange forskjellige utsagn. Eliza kunne lett bli lurt, for eksempel hvis en bruker skrev "**Du er** en <u>sykkel</u>", kunne den svare med "Hvor lenge har **jeg vært** en <u>sykkel</u>?", i stedet for et mer fornuftig svar.
|
||||
|
||||
[](https://youtu.be/RMK9AphfLco "Chatte med Eliza")
|
||||
|
||||
> 🎥 Klikk på bildet over for en video om det originale ELIZA-programmet
|
||||
|
||||
> Merk: Du kan lese den originale beskrivelsen av [Eliza](https://cacm.acm.org/magazines/1966/1/13317-elizaa-computer-program-for-the-study-of-natural-language-communication-between-man-and-machine/abstract) publisert i 1966 hvis du har en ACM-konto. Alternativt kan du lese om Eliza på [wikipedia](https://wikipedia.org/wiki/ELIZA)
|
||||
|
||||
## Øvelse - kode en enkel samtalebot
|
||||
|
||||
En samtalebot, som Eliza, er et program som henter brukerinput og ser ut til å forstå og svare intelligent. I motsetning til Eliza vil vår bot ikke ha flere regler som gir den inntrykk av å ha en intelligent samtale. I stedet vil vår bot ha én eneste evne, nemlig å holde samtalen i gang med tilfeldige svar som kan fungere i nesten enhver triviell samtale.
|
||||
|
||||
### Planen
|
||||
|
||||
Dine steg når du bygger en samtalebot:
|
||||
|
||||
1. Skriv ut instruksjoner som informerer brukeren om hvordan de skal interagere med boten
|
||||
2. Start en løkke
|
||||
1. Aksepter brukerinput
|
||||
2. Hvis brukeren har bedt om å avslutte, avslutt
|
||||
3. Behandle brukerinput og bestem svar (i dette tilfellet er svaret et tilfeldig valg fra en liste over mulige generiske svar)
|
||||
4. Skriv ut svar
|
||||
3. Gå tilbake til steg 2
|
||||
|
||||
### Bygge boten
|
||||
|
||||
La oss lage boten nå. Vi starter med å definere noen fraser.
|
||||
|
||||
1. Lag denne boten selv i Python med følgende tilfeldige svar:
|
||||
|
||||
```python
|
||||
random_responses = ["That is quite interesting, please tell me more.",
|
||||
"I see. Do go on.",
|
||||
"Why do you say that?",
|
||||
"Funny weather we've been having, isn't it?",
|
||||
"Let's change the subject.",
|
||||
"Did you catch the game last night?"]
|
||||
```
|
||||
|
||||
Her er noen eksempler på output for å veilede deg (brukerinput er på linjene som starter med `>`):
|
||||
|
||||
```output
|
||||
Hello, I am Marvin, the simple robot.
|
||||
You can end this conversation at any time by typing 'bye'
|
||||
After typing each answer, press 'enter'
|
||||
How are you today?
|
||||
> I am good thanks
|
||||
That is quite interesting, please tell me more.
|
||||
> today I went for a walk
|
||||
Did you catch the game last night?
|
||||
> I did, but my team lost
|
||||
Funny weather we've been having, isn't it?
|
||||
> yes but I hope next week is better
|
||||
Let's change the subject.
|
||||
> ok, lets talk about music
|
||||
Why do you say that?
|
||||
> because I like music!
|
||||
Why do you say that?
|
||||
> bye
|
||||
It was nice talking to you, goodbye!
|
||||
```
|
||||
|
||||
En mulig løsning på oppgaven er [her](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/1-Introduction-to-NLP/solution/bot.py)
|
||||
|
||||
✅ Stopp og vurder
|
||||
|
||||
1. Tror du de tilfeldige svarene ville 'lure' noen til å tro at boten faktisk forsto dem?
|
||||
2. Hvilke funksjoner ville boten trenge for å være mer effektiv?
|
||||
3. Hvis en bot virkelig kunne 'forstå' meningen med en setning, ville den trenge å 'huske' meningen med tidligere setninger i en samtale også?
|
||||
|
||||
---
|
||||
|
||||
## 🚀Utfordring
|
||||
|
||||
Velg ett av "stopp og vurder"-elementene ovenfor og prøv enten å implementere dem i kode eller skriv en løsning på papir ved hjelp av pseudokode.
|
||||
|
||||
I neste leksjon vil du lære om en rekke andre tilnærminger til parsing av naturlig språk og maskinlæring.
|
||||
|
||||
## [Quiz etter leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Gjennomgang & Selvstudium
|
||||
|
||||
Ta en titt på referansene nedenfor som videre lesemuligheter.
|
||||
|
||||
### Referanser
|
||||
|
||||
1. Schubert, Lenhart, "Computational Linguistics", *The Stanford Encyclopedia of Philosophy* (Spring 2020 Edition), Edward N. Zalta (ed.), URL = <https://plato.stanford.edu/archives/spr2020/entries/computational-linguistics/>.
|
||||
2. Princeton University "About WordNet." [WordNet](https://wordnet.princeton.edu/). Princeton University. 2010.
|
||||
|
||||
## Oppgave
|
||||
|
||||
[Søk etter en bot](assignment.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, 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.
|
||||
@ -0,0 +1,25 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "1d7583e8046dacbb0c056d5ba0a71b16",
|
||||
"translation_date": "2025-09-05T22:23:09+00:00",
|
||||
"source_file": "6-NLP/1-Introduction-to-NLP/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Finn en bot
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
Boter finnes overalt. Din oppgave: finn en og adopter den! Du kan finne dem på nettsider, i bankapplikasjoner og på telefonen, for eksempel når du ringer finansielle tjenester for råd eller kontoinformasjon. Analyser boten og se om du klarer å forvirre den. Hvis du klarer å forvirre boten, hvorfor tror du det skjedde? Skriv en kort rapport om din opplevelse.
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Eksemplarisk | Tilfredsstillende | Trenger forbedring |
|
||||
| --------- | ----------------------------------------------------------------------------------------------------------- | -------------------------------------------- | --------------------- |
|
||||
| | En fullstendig side er skrevet, som forklarer den antatte bot-arkitekturen og beskriver din opplevelse med den | En rapport er ufullstendig eller ikke godt undersøkt | Ingen rapport er levert |
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,25 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "2efc4c2aba5ed06c780c05539c492ae3",
|
||||
"translation_date": "2025-09-05T22:15:09+00:00",
|
||||
"source_file": "6-NLP/2-Tasks/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Få en bot til å svare tilbake
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
I de siste leksjonene har du programmert en enkel bot som du kan chatte med. Denne boten gir tilfeldige svar helt til du sier 'bye'. Kan du gjøre svarene litt mindre tilfeldige, og få boten til å gi spesifikke svar når du sier bestemte ting, som 'hvorfor' eller 'hvordan'? Tenk litt på hvordan maskinlæring kan gjøre denne typen arbeid mindre manuell når du utvider boten din. Du kan bruke bibliotekene NLTK eller TextBlob for å gjøre oppgavene enklere.
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Eksemplarisk | Tilfredsstillende | Trenger forbedring |
|
||||
| --------- | --------------------------------------------- | ------------------------------------------------ | ----------------------- |
|
||||
| | En ny bot.py-fil er presentert og dokumentert | En ny bot-fil er presentert, men inneholder feil | En fil er ikke presentert |
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,25 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "9d2a734deb904caff310d1a999c6bd7a",
|
||||
"translation_date": "2025-09-05T22:25:55+00:00",
|
||||
"source_file": "6-NLP/3-Translation-Sentiment/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Poetisk frihet
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
I [denne notatboken](https://www.kaggle.com/jenlooper/emily-dickinson-word-frequency) finner du over 500 dikt av Emily Dickinson som tidligere er analysert for sentiment ved hjelp av Azure tekstanalyse. Bruk dette datasettet til å analysere det ved hjelp av teknikkene som er beskrevet i leksjonen. Stemmer det foreslåtte sentimentet i et dikt overens med avgjørelsen til den mer avanserte Azure-tjenesten? Hvorfor eller hvorfor ikke, etter din mening? Er det noe som overrasker deg?
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Eksemplarisk | Tilfredsstillende | Trenger forbedring |
|
||||
| --------- | ------------------------------------------------------------------------- | ------------------------------------------------------ | ------------------------ |
|
||||
| | En notatbok presenteres med en grundig analyse av et utvalg fra forfatteren | Notatboken er ufullstendig eller utfører ikke analysen | Ingen notatbok presenteres |
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
|
||||
"translation_date": "2025-09-05T22:26:29+00:00",
|
||||
"source_file": "6-NLP/3-Translation-Sentiment/solution/Julia/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
|
||||
"translation_date": "2025-09-05T22:26:16+00:00",
|
||||
"source_file": "6-NLP/3-Translation-Sentiment/solution/R/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,417 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "8d32dadeda93c6fb5c43619854882ab1",
|
||||
"translation_date": "2025-09-05T22:18:22+00:00",
|
||||
"source_file": "6-NLP/4-Hotel-Reviews-1/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Sentimentanalyse med hotellanmeldelser - bearbeiding av data
|
||||
|
||||
I denne delen vil du bruke teknikkene fra de tidligere leksjonene til å utføre en utforskende dataanalyse av et stort datasett. Når du har fått en god forståelse av nytten av de ulike kolonnene, vil du lære:
|
||||
|
||||
- hvordan du fjerner unødvendige kolonner
|
||||
- hvordan du beregner ny data basert på eksisterende kolonner
|
||||
- hvordan du lagrer det resulterende datasettet for bruk i den endelige utfordringen
|
||||
|
||||
## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
### Introduksjon
|
||||
|
||||
Så langt har du lært hvordan tekstdata er ganske annerledes enn numeriske datatyper. Hvis det er tekst skrevet eller sagt av et menneske, kan det analyseres for å finne mønstre, frekvenser, sentiment og mening. Denne leksjonen tar deg inn i et ekte datasett med en ekte utfordring: **[515K Hotel Reviews Data in Europe](https://www.kaggle.com/jiashenliu/515k-hotel-reviews-data-in-europe)** som inkluderer en [CC0: Public Domain-lisens](https://creativecommons.org/publicdomain/zero/1.0/). Det ble hentet fra Booking.com fra offentlige kilder. Skaperen av datasettet er Jiashen Liu.
|
||||
|
||||
### Forberedelse
|
||||
|
||||
Du vil trenge:
|
||||
|
||||
* Muligheten til å kjøre .ipynb-notatbøker med Python 3
|
||||
* pandas
|
||||
* NLTK, [som du bør installere lokalt](https://www.nltk.org/install.html)
|
||||
* Datasettet som er tilgjengelig på Kaggle [515K Hotel Reviews Data in Europe](https://www.kaggle.com/jiashenliu/515k-hotel-reviews-data-in-europe). Det er rundt 230 MB ukomprimert. Last det ned til rotmappen `/data` knyttet til disse NLP-leksjonene.
|
||||
|
||||
## Utforskende dataanalyse
|
||||
|
||||
Denne utfordringen antar at du bygger en hotellanbefalingsbot ved hjelp av sentimentanalyse og gjesteanmeldelsesscorer. Datasettet du vil bruke inkluderer anmeldelser av 1493 forskjellige hoteller i 6 byer.
|
||||
|
||||
Ved å bruke Python, et datasett med hotellanmeldelser, og NLTKs sentimentanalyse kan du finne ut:
|
||||
|
||||
* Hva er de mest brukte ordene og frasene i anmeldelsene?
|
||||
* Korresponderer de offisielle *taggene* som beskriver et hotell med anmeldelsesscorer (f.eks. er det flere negative anmeldelser for et bestemt hotell fra *Familie med små barn* enn fra *Alenereisende*, noe som kanskje indikerer at det er bedre for *Alenereisende*)?
|
||||
* Stemmer NLTKs sentimentanalyseresultater overens med den numeriske scoren fra hotellanmelderen?
|
||||
|
||||
#### Datasett
|
||||
|
||||
La oss utforske datasettet du har lastet ned og lagret lokalt. Åpne filen i en editor som VS Code eller til og med Excel.
|
||||
|
||||
Overskriftene i datasettet er som følger:
|
||||
|
||||
*Hotel_Address, Additional_Number_of_Scoring, Review_Date, Average_Score, Hotel_Name, Reviewer_Nationality, Negative_Review, Review_Total_Negative_Word_Counts, Total_Number_of_Reviews, Positive_Review, Review_Total_Positive_Word_Counts, Total_Number_of_Reviews_Reviewer_Has_Given, Reviewer_Score, Tags, days_since_review, lat, lng*
|
||||
|
||||
Her er de gruppert på en måte som kan være lettere å undersøke:
|
||||
##### Hotellkolonner
|
||||
|
||||
* `Hotel_Name`, `Hotel_Address`, `lat` (breddegrad), `lng` (lengdegrad)
|
||||
* Ved å bruke *lat* og *lng* kan du lage et kart med Python som viser hotellplasseringer (kanskje fargekodet for negative og positive anmeldelser)
|
||||
* Hotel_Address er ikke åpenbart nyttig for oss, og vi vil sannsynligvis erstatte det med et land for enklere sortering og søking
|
||||
|
||||
**Hotell meta-anmeldelseskolonner**
|
||||
|
||||
* `Average_Score`
|
||||
* Ifølge datasettets skaper er denne kolonnen *Gjennomsnittsscore for hotellet, beregnet basert på den nyeste kommentaren det siste året*. Dette virker som en uvanlig måte å beregne scoren på, men det er data som er hentet, så vi kan ta det for god fisk for nå.
|
||||
|
||||
✅ Basert på de andre kolonnene i dette datasettet, kan du tenke på en annen måte å beregne gjennomsnittsscoren på?
|
||||
|
||||
* `Total_Number_of_Reviews`
|
||||
* Det totale antallet anmeldelser dette hotellet har mottatt - det er ikke klart (uten å skrive litt kode) om dette refererer til anmeldelsene i datasettet.
|
||||
* `Additional_Number_of_Scoring`
|
||||
* Dette betyr at en anmeldelsesscore ble gitt, men ingen positiv eller negativ anmeldelse ble skrevet av anmelderen
|
||||
|
||||
**Anmeldelseskolonner**
|
||||
|
||||
- `Reviewer_Score`
|
||||
- Dette er en numerisk verdi med maksimalt én desimal mellom minimums- og maksimumsverdiene 2.5 og 10
|
||||
- Det er ikke forklart hvorfor 2.5 er den laveste mulige scoren
|
||||
- `Negative_Review`
|
||||
- Hvis en anmelder ikke skrev noe, vil dette feltet ha "**No Negative**"
|
||||
- Merk at en anmelder kan skrive en positiv anmeldelse i kolonnen for Negative Review (f.eks. "det er ingenting dårlig med dette hotellet")
|
||||
- `Review_Total_Negative_Word_Counts`
|
||||
- Høyere negative ordtellinger indikerer en lavere score (uten å sjekke sentimentet)
|
||||
- `Positive_Review`
|
||||
- Hvis en anmelder ikke skrev noe, vil dette feltet ha "**No Positive**"
|
||||
- Merk at en anmelder kan skrive en negativ anmeldelse i kolonnen for Positive Review (f.eks. "det er ingenting bra med dette hotellet i det hele tatt")
|
||||
- `Review_Total_Positive_Word_Counts`
|
||||
- Høyere positive ordtellinger indikerer en høyere score (uten å sjekke sentimentet)
|
||||
- `Review_Date` og `days_since_review`
|
||||
- En ferskhets- eller foreldelsesmåling kan brukes på en anmeldelse (eldre anmeldelser er kanskje ikke like nøyaktige som nyere fordi hotellledelsen har endret seg, renoveringer er gjort, eller et basseng er lagt til osv.)
|
||||
- `Tags`
|
||||
- Dette er korte beskrivelser som en anmelder kan velge for å beskrive typen gjest de var (f.eks. alene eller familie), typen rom de hadde, lengden på oppholdet og hvordan anmeldelsen ble sendt inn.
|
||||
- Dessverre er bruken av disse taggene problematisk, se avsnittet nedenfor som diskuterer deres nytteverdi
|
||||
|
||||
**Anmelderkolonner**
|
||||
|
||||
- `Total_Number_of_Reviews_Reviewer_Has_Given`
|
||||
- Dette kan være en faktor i en anbefalingsmodell, for eksempel hvis du kan fastslå at mer produktive anmeldere med hundrevis av anmeldelser er mer tilbøyelige til å være negative enn positive. Imidlertid er anmelderen av en bestemt anmeldelse ikke identifisert med en unik kode, og kan derfor ikke kobles til et sett med anmeldelser. Det er 30 anmeldere med 100 eller flere anmeldelser, men det er vanskelig å se hvordan dette kan hjelpe anbefalingsmodellen.
|
||||
- `Reviewer_Nationality`
|
||||
- Noen kan tro at visse nasjonaliteter er mer tilbøyelige til å gi en positiv eller negativ anmeldelse på grunn av en nasjonal tilbøyelighet. Vær forsiktig med å bygge slike anekdotiske synspunkter inn i modellene dine. Dette er nasjonale (og noen ganger rasemessige) stereotyper, og hver anmelder var en individuell person som skrev en anmeldelse basert på sin opplevelse. Den kan ha blitt filtrert gjennom mange linser som deres tidligere hotellopphold, avstanden de reiste, og deres personlige temperament. Å tro at deres nasjonalitet var årsaken til en anmeldelsesscore er vanskelig å rettferdiggjøre.
|
||||
|
||||
##### Eksempler
|
||||
|
||||
| Gjennomsnittlig Score | Totalt Antall Anmeldelser | Anmelder Score | Negativ <br />Anmeldelse | Positiv Anmeldelse | Tags |
|
||||
| ---------------------- | -------------------------- | ---------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------ | ----------------------------------------------------------------------------------------- |
|
||||
| 7.8 | 1945 | 2.5 | Dette er for øyeblikket ikke et hotell, men en byggeplass Jeg ble terrorisert fra tidlig morgen og hele dagen med uakseptabel byggestøy mens jeg hvilte etter en lang reise og jobbet på rommet Folk jobbet hele dagen med f.eks. trykkluftbor i de tilstøtende rommene Jeg ba om å bytte rom, men ingen stille rom var tilgjengelig For å gjøre ting verre ble jeg overbelastet Jeg sjekket ut på kvelden siden jeg måtte dra veldig tidlig fly og mottok en passende regning En dag senere gjorde hotellet en annen belastning uten mitt samtykke som oversteg den bookede prisen Det er et forferdelig sted Ikke straff deg selv ved å booke her | Ingenting Forferdelig sted Hold deg unna | Forretningsreise Par Standard Dobbeltrom Bodde 2 netter |
|
||||
|
||||
Som du kan se, hadde denne gjesten ikke et hyggelig opphold på dette hotellet. Hotellet har en god gjennomsnittsscore på 7.8 og 1945 anmeldelser, men denne anmelderen ga det 2.5 og skrev 115 ord om hvor negativt oppholdet var. Hvis de ikke skrev noe i Positive_Review-kolonnen, kan du anta at det ikke var noe positivt, men de skrev faktisk 7 ord som advarsel. Hvis vi bare teller ord i stedet for betydningen eller sentimentet av ordene, kan vi få et skjevt bilde av anmelderens intensjon. Merkelig nok er deres score på 2.5 forvirrende, fordi hvis hotelloppholdet var så dårlig, hvorfor gi det noen poeng i det hele tatt? Ved å undersøke datasettet nøye, vil du se at den laveste mulige scoren er 2.5, ikke 0. Den høyeste mulige scoren er 10.
|
||||
|
||||
##### Tags
|
||||
|
||||
Som nevnt ovenfor, ved første øyekast virker ideen om å bruke `Tags` til å kategorisere data fornuftig. Dessverre er disse taggene ikke standardiserte, noe som betyr at i et gitt hotell kan alternativene være *Enkeltrom*, *Tomannsrom* og *Dobbeltrom*, men i neste hotell er de *Deluxe Enkeltrom*, *Klassisk Queen-rom* og *Executive King-rom*. Disse kan være de samme tingene, men det er så mange variasjoner at valget blir:
|
||||
|
||||
1. Forsøke å endre alle begrepene til en enkelt standard, noe som er veldig vanskelig, fordi det ikke er klart hva konverteringsbanen vil være i hvert tilfelle (f.eks. *Klassisk enkeltrom* kartlegges til *Enkeltrom*, men *Superior Queen-rom med hage eller byutsikt* er mye vanskeligere å kartlegge)
|
||||
|
||||
1. Vi kan ta en NLP-tilnærming og måle frekvensen av visse begreper som *Alene*, *Forretningsreisende* eller *Familie med små barn* slik de gjelder for hvert hotell, og ta dette med i anbefalingen
|
||||
|
||||
Tags er vanligvis (men ikke alltid) et enkelt felt som inneholder en liste med 5 til 6 kommaseparerte verdier som samsvarer med *Type reise*, *Type gjester*, *Type rom*, *Antall netter* og *Type enhet anmeldelsen ble sendt inn fra*. Imidlertid, fordi noen anmeldere ikke fyller ut hvert felt (de kan la ett være tomt), er verdiene ikke alltid i samme rekkefølge.
|
||||
|
||||
Som et eksempel, ta *Type gruppe*. Det er 1025 unike muligheter i dette feltet i `Tags`-kolonnen, og dessverre refererer bare noen av dem til en gruppe (noen er typen rom osv.). Hvis du filtrerer bare de som nevner familie, inneholder resultatene mange *Familierom*-type resultater. Hvis du inkluderer begrepet *med*, dvs. teller *Familie med*-verdier, er resultatene bedre, med over 80,000 av de 515,000 resultatene som inneholder frasen "Familie med små barn" eller "Familie med eldre barn".
|
||||
|
||||
Dette betyr at tags-kolonnen ikke er helt ubrukelig for oss, men det vil kreve litt arbeid for å gjøre den nyttig.
|
||||
|
||||
##### Gjennomsnittlig hotellscore
|
||||
|
||||
Det er en rekke rariteter eller avvik med datasettet som jeg ikke kan finne ut av, men som er illustrert her slik at du er klar over dem når du bygger modellene dine. Hvis du finner ut av det, gi oss beskjed i diskusjonsseksjonen!
|
||||
|
||||
Datasettet har følgende kolonner relatert til gjennomsnittsscore og antall anmeldelser:
|
||||
|
||||
1. Hotel_Name
|
||||
2. Additional_Number_of_Scoring
|
||||
3. Average_Score
|
||||
4. Total_Number_of_Reviews
|
||||
5. Reviewer_Score
|
||||
|
||||
Hotellet med flest anmeldelser i dette datasettet er *Britannia International Hotel Canary Wharf* med 4789 anmeldelser av 515,000. Men hvis vi ser på verdien `Total_Number_of_Reviews` for dette hotellet, er det 9086. Du kan anta at det er mange flere scorer uten anmeldelser, så kanskje vi bør legge til verdien i kolonnen `Additional_Number_of_Scoring`. Den verdien er 2682, og å legge den til 4789 gir oss 7471, som fortsatt er 1615 mindre enn `Total_Number_of_Reviews`.
|
||||
|
||||
Hvis du tar kolonnen `Average_Score`, kan du anta at det er gjennomsnittet av anmeldelsene i datasettet, men beskrivelsen fra Kaggle er "*Gjennomsnittsscore for hotellet, beregnet basert på den nyeste kommentaren det siste året*". Det virker ikke så nyttig, men vi kan beregne vårt eget gjennomsnitt basert på anmeldelsesscorene i datasettet. Ved å bruke det samme hotellet som et eksempel, er den gjennomsnittlige hotellscoren gitt som 7.1, men den beregnede scoren (gjennomsnittlig anmelder-score *i* datasettet) er 6.8. Dette er nært, men ikke den samme verdien, og vi kan bare gjette at scorene gitt i `Additional_Number_of_Scoring`-anmeldelsene økte gjennomsnittet til 7.1. Dessverre, uten noen måte å teste eller bevise den påstanden, er det vanskelig å bruke eller stole på `Average_Score`, `Additional_Number_of_Scoring` og `Total_Number_of_Reviews` når de er basert på, eller refererer til, data vi ikke har.
|
||||
|
||||
For å komplisere ting ytterligere, har hotellet med det nest høyeste antallet anmeldelser en beregnet gjennomsnittsscore på 8.12, og datasettets `Average_Score` er 8.1. Er denne korrekte scoren en tilfeldighet, eller er det første hotellet et avvik?
|
||||
|
||||
På muligheten for at disse hotellene kan være uteliggere, og at kanskje de fleste verdiene stemmer (men noen gjør det ikke av en eller annen grunn), vil vi skrive et kort program neste gang for å utforske verdiene i datasettet og bestemme korrekt bruk (eller ikke-bruk) av verdiene.
|
||||
> 🚨 En advarsel
|
||||
|
||||
> Når du arbeider med dette datasettet, vil du skrive kode som beregner noe ut fra teksten uten å måtte lese eller analysere teksten selv. Dette er essensen av NLP, å tolke mening eller sentiment uten at en menneskelig person trenger å gjøre det. Det er imidlertid mulig at du vil lese noen av de negative anmeldelsene. Jeg vil sterkt oppfordre deg til å la være, fordi du ikke trenger det. Noen av dem er tullete eller irrelevante negative hotellanmeldelser, som for eksempel "Været var ikke bra", noe som er utenfor hotellets, eller noens, kontroll. Men det finnes også en mørk side ved noen anmeldelser. Noen ganger er de negative anmeldelsene rasistiske, sexistiske eller aldersdiskriminerende. Dette er uheldig, men forventet i et datasett hentet fra en offentlig nettside. Noen anmeldere legger igjen anmeldelser som du kan finne smakløse, ubehagelige eller opprørende. Det er bedre å la koden måle sentimentet enn å lese dem selv og bli opprørt. Når det er sagt, er det en minoritet som skriver slike ting, men de finnes likevel.
|
||||
## Øvelse - Datautforskning
|
||||
### Last inn dataene
|
||||
|
||||
Det er nok å undersøke dataene visuelt, nå skal du skrive litt kode og få noen svar! Denne delen bruker pandas-biblioteket. Din aller første oppgave er å sørge for at du kan laste inn og lese CSV-dataene. Pandas-biblioteket har en rask CSV-laster, og resultatet plasseres i en dataframe, som i tidligere leksjoner. CSV-filen vi laster inn har over en halv million rader, men bare 17 kolonner. Pandas gir deg mange kraftige måter å samhandle med en dataframe på, inkludert muligheten til å utføre operasjoner på hver rad.
|
||||
|
||||
Fra nå av i denne leksjonen vil det være kodeeksempler, noen forklaringer av koden og diskusjoner om hva resultatene betyr. Bruk den inkluderte _notebook.ipynb_ for koden din.
|
||||
|
||||
La oss starte med å laste inn datafilen du skal bruke:
|
||||
|
||||
```python
|
||||
# Load the hotel reviews from CSV
|
||||
import pandas as pd
|
||||
import time
|
||||
# importing time so the start and end time can be used to calculate file loading time
|
||||
print("Loading data file now, this could take a while depending on file size")
|
||||
start = time.time()
|
||||
# df is 'DataFrame' - make sure you downloaded the file to the data folder
|
||||
df = pd.read_csv('../../data/Hotel_Reviews.csv')
|
||||
end = time.time()
|
||||
print("Loading took " + str(round(end - start, 2)) + " seconds")
|
||||
```
|
||||
|
||||
Nå som dataene er lastet inn, kan vi utføre noen operasjoner på dem. Hold denne koden øverst i programmet ditt for neste del.
|
||||
|
||||
## Utforsk dataene
|
||||
|
||||
I dette tilfellet er dataene allerede *rene*, det betyr at de er klare til å jobbe med og ikke inneholder tegn fra andre språk som kan skape problemer for algoritmer som forventer kun engelske tegn.
|
||||
|
||||
✅ Du kan komme til å jobbe med data som krever en viss forhåndsbehandling for å formatere dem før du bruker NLP-teknikker, men ikke denne gangen. Hvis du måtte, hvordan ville du håndtert ikke-engelske tegn?
|
||||
|
||||
Ta et øyeblikk for å forsikre deg om at når dataene er lastet inn, kan du utforske dem med kode. Det er veldig lett å ville fokusere på kolonnene `Negative_Review` og `Positive_Review`. De er fylt med naturlig tekst som NLP-algoritmene dine kan prosessere. Men vent! Før du hopper inn i NLP og sentimentanalyse, bør du følge koden nedenfor for å fastslå om verdiene som er gitt i datasettet samsvarer med verdiene du beregner med pandas.
|
||||
|
||||
## Dataframe-operasjoner
|
||||
|
||||
Den første oppgaven i denne leksjonen er å sjekke om følgende påstander er korrekte ved å skrive litt kode som undersøker dataframen (uten å endre den).
|
||||
|
||||
> Som med mange programmeringsoppgaver, finnes det flere måter å løse dette på, men et godt råd er å gjøre det på den enkleste og letteste måten, spesielt hvis det vil være lettere å forstå når du kommer tilbake til denne koden i fremtiden. Med dataframes finnes det et omfattende API som ofte vil ha en effektiv måte å gjøre det du ønsker.
|
||||
|
||||
Behandle følgende spørsmål som kodingsoppgaver og prøv å svare på dem uten å se på løsningen.
|
||||
|
||||
1. Skriv ut *formen* til dataframen du nettopp har lastet inn (formen er antall rader og kolonner).
|
||||
2. Beregn frekvensen for anmeldernasjonaliteter:
|
||||
1. Hvor mange distinkte verdier finnes det i kolonnen `Reviewer_Nationality`, og hva er de?
|
||||
2. Hvilken anmeldernasjonalitet er den vanligste i datasettet (skriv ut land og antall anmeldelser)?
|
||||
3. Hva er de neste 10 mest vanlige nasjonalitetene, og deres frekvens?
|
||||
3. Hvilket hotell ble anmeldt oftest for hver av de 10 mest vanlige anmeldernasjonalitetene?
|
||||
4. Hvor mange anmeldelser er det per hotell (frekvensen av anmeldelser per hotell) i datasettet?
|
||||
5. Selv om det finnes en kolonne `Average_Score` for hvert hotell i datasettet, kan du også beregne en gjennomsnittsscore (ved å ta gjennomsnittet av alle anmelderscorer i datasettet for hvert hotell). Legg til en ny kolonne i dataframen med kolonneoverskriften `Calc_Average_Score` som inneholder den beregnede gjennomsnittsscoren.
|
||||
6. Har noen hoteller samme (avrundet til én desimal) `Average_Score` og `Calc_Average_Score`?
|
||||
1. Prøv å skrive en Python-funksjon som tar en Series (rad) som et argument og sammenligner verdiene, og skriver ut en melding når verdiene ikke er like. Bruk deretter `.apply()`-metoden for å prosessere hver rad med funksjonen.
|
||||
7. Beregn og skriv ut hvor mange rader som har verdien "No Negative" i kolonnen `Negative_Review`.
|
||||
8. Beregn og skriv ut hvor mange rader som har verdien "No Positive" i kolonnen `Positive_Review`.
|
||||
9. Beregn og skriv ut hvor mange rader som har verdien "No Positive" i kolonnen `Positive_Review` **og** verdien "No Negative" i kolonnen `Negative_Review`.
|
||||
|
||||
### Kodesvar
|
||||
|
||||
1. Skriv ut *formen* til dataframen du nettopp har lastet inn (formen er antall rader og kolonner).
|
||||
|
||||
```python
|
||||
print("The shape of the data (rows, cols) is " + str(df.shape))
|
||||
> The shape of the data (rows, cols) is (515738, 17)
|
||||
```
|
||||
|
||||
2. Beregn frekvensen for anmeldernasjonaliteter:
|
||||
|
||||
1. Hvor mange distinkte verdier finnes det i kolonnen `Reviewer_Nationality`, og hva er de?
|
||||
2. Hvilken anmeldernasjonalitet er den vanligste i datasettet (skriv ut land og antall anmeldelser)?
|
||||
|
||||
```python
|
||||
# value_counts() creates a Series object that has index and values in this case, the country and the frequency they occur in reviewer nationality
|
||||
nationality_freq = df["Reviewer_Nationality"].value_counts()
|
||||
print("There are " + str(nationality_freq.size) + " different nationalities")
|
||||
# print first and last rows of the Series. Change to nationality_freq.to_string() to print all of the data
|
||||
print(nationality_freq)
|
||||
|
||||
There are 227 different nationalities
|
||||
United Kingdom 245246
|
||||
United States of America 35437
|
||||
Australia 21686
|
||||
Ireland 14827
|
||||
United Arab Emirates 10235
|
||||
...
|
||||
Comoros 1
|
||||
Palau 1
|
||||
Northern Mariana Islands 1
|
||||
Cape Verde 1
|
||||
Guinea 1
|
||||
Name: Reviewer_Nationality, Length: 227, dtype: int64
|
||||
```
|
||||
|
||||
3. Hva er de neste 10 mest vanlige nasjonalitetene, og deres frekvens?
|
||||
|
||||
```python
|
||||
print("The highest frequency reviewer nationality is " + str(nationality_freq.index[0]).strip() + " with " + str(nationality_freq[0]) + " reviews.")
|
||||
# Notice there is a leading space on the values, strip() removes that for printing
|
||||
# What is the top 10 most common nationalities and their frequencies?
|
||||
print("The next 10 highest frequency reviewer nationalities are:")
|
||||
print(nationality_freq[1:11].to_string())
|
||||
|
||||
The highest frequency reviewer nationality is United Kingdom with 245246 reviews.
|
||||
The next 10 highest frequency reviewer nationalities are:
|
||||
United States of America 35437
|
||||
Australia 21686
|
||||
Ireland 14827
|
||||
United Arab Emirates 10235
|
||||
Saudi Arabia 8951
|
||||
Netherlands 8772
|
||||
Switzerland 8678
|
||||
Germany 7941
|
||||
Canada 7894
|
||||
France 7296
|
||||
```
|
||||
|
||||
3. Hvilket hotell ble anmeldt oftest for hver av de 10 mest vanlige anmeldernasjonalitetene?
|
||||
|
||||
```python
|
||||
# What was the most frequently reviewed hotel for the top 10 nationalities
|
||||
# Normally with pandas you will avoid an explicit loop, but wanted to show creating a new dataframe using criteria (don't do this with large amounts of data because it could be very slow)
|
||||
for nat in nationality_freq[:10].index:
|
||||
# First, extract all the rows that match the criteria into a new dataframe
|
||||
nat_df = df[df["Reviewer_Nationality"] == nat]
|
||||
# Now get the hotel freq
|
||||
freq = nat_df["Hotel_Name"].value_counts()
|
||||
print("The most reviewed hotel for " + str(nat).strip() + " was " + str(freq.index[0]) + " with " + str(freq[0]) + " reviews.")
|
||||
|
||||
The most reviewed hotel for United Kingdom was Britannia International Hotel Canary Wharf with 3833 reviews.
|
||||
The most reviewed hotel for United States of America was Hotel Esther a with 423 reviews.
|
||||
The most reviewed hotel for Australia was Park Plaza Westminster Bridge London with 167 reviews.
|
||||
The most reviewed hotel for Ireland was Copthorne Tara Hotel London Kensington with 239 reviews.
|
||||
The most reviewed hotel for United Arab Emirates was Millennium Hotel London Knightsbridge with 129 reviews.
|
||||
The most reviewed hotel for Saudi Arabia was The Cumberland A Guoman Hotel with 142 reviews.
|
||||
The most reviewed hotel for Netherlands was Jaz Amsterdam with 97 reviews.
|
||||
The most reviewed hotel for Switzerland was Hotel Da Vinci with 97 reviews.
|
||||
The most reviewed hotel for Germany was Hotel Da Vinci with 86 reviews.
|
||||
The most reviewed hotel for Canada was St James Court A Taj Hotel London with 61 reviews.
|
||||
```
|
||||
|
||||
4. Hvor mange anmeldelser er det per hotell (frekvensen av anmeldelser per hotell) i datasettet?
|
||||
|
||||
```python
|
||||
# First create a new dataframe based on the old one, removing the uneeded columns
|
||||
hotel_freq_df = df.drop(["Hotel_Address", "Additional_Number_of_Scoring", "Review_Date", "Average_Score", "Reviewer_Nationality", "Negative_Review", "Review_Total_Negative_Word_Counts", "Positive_Review", "Review_Total_Positive_Word_Counts", "Total_Number_of_Reviews_Reviewer_Has_Given", "Reviewer_Score", "Tags", "days_since_review", "lat", "lng"], axis = 1)
|
||||
|
||||
# Group the rows by Hotel_Name, count them and put the result in a new column Total_Reviews_Found
|
||||
hotel_freq_df['Total_Reviews_Found'] = hotel_freq_df.groupby('Hotel_Name').transform('count')
|
||||
|
||||
# Get rid of all the duplicated rows
|
||||
hotel_freq_df = hotel_freq_df.drop_duplicates(subset = ["Hotel_Name"])
|
||||
display(hotel_freq_df)
|
||||
```
|
||||
| Hotel_Name | Total_Number_of_Reviews | Total_Reviews_Found |
|
||||
| :----------------------------------------: | :---------------------: | :-----------------: |
|
||||
| Britannia International Hotel Canary Wharf | 9086 | 4789 |
|
||||
| Park Plaza Westminster Bridge London | 12158 | 4169 |
|
||||
| Copthorne Tara Hotel London Kensington | 7105 | 3578 |
|
||||
| ... | ... | ... |
|
||||
| Mercure Paris Porte d Orleans | 110 | 10 |
|
||||
| Hotel Wagner | 135 | 10 |
|
||||
| Hotel Gallitzinberg | 173 | 8 |
|
||||
|
||||
Du vil kanskje legge merke til at resultatene *telt i datasettet* ikke samsvarer med verdien i `Total_Number_of_Reviews`. Det er uklart om denne verdien i datasettet representerer det totale antallet anmeldelser hotellet hadde, men ikke alle ble skrapet, eller om det er en annen beregning. `Total_Number_of_Reviews` brukes ikke i modellen på grunn av denne uklarheten.
|
||||
|
||||
5. Selv om det finnes en kolonne `Average_Score` for hvert hotell i datasettet, kan du også beregne en gjennomsnittsscore (ved å ta gjennomsnittet av alle anmelderscorer i datasettet for hvert hotell). Legg til en ny kolonne i dataframen med kolonneoverskriften `Calc_Average_Score` som inneholder den beregnede gjennomsnittsscoren. Skriv ut kolonnene `Hotel_Name`, `Average_Score` og `Calc_Average_Score`.
|
||||
|
||||
```python
|
||||
# define a function that takes a row and performs some calculation with it
|
||||
def get_difference_review_avg(row):
|
||||
return row["Average_Score"] - row["Calc_Average_Score"]
|
||||
|
||||
# 'mean' is mathematical word for 'average'
|
||||
df['Calc_Average_Score'] = round(df.groupby('Hotel_Name').Reviewer_Score.transform('mean'), 1)
|
||||
|
||||
# Add a new column with the difference between the two average scores
|
||||
df["Average_Score_Difference"] = df.apply(get_difference_review_avg, axis = 1)
|
||||
|
||||
# Create a df without all the duplicates of Hotel_Name (so only 1 row per hotel)
|
||||
review_scores_df = df.drop_duplicates(subset = ["Hotel_Name"])
|
||||
|
||||
# Sort the dataframe to find the lowest and highest average score difference
|
||||
review_scores_df = review_scores_df.sort_values(by=["Average_Score_Difference"])
|
||||
|
||||
display(review_scores_df[["Average_Score_Difference", "Average_Score", "Calc_Average_Score", "Hotel_Name"]])
|
||||
```
|
||||
|
||||
Du lurer kanskje også på verdien `Average_Score` og hvorfor den noen ganger er forskjellig fra den beregnede gjennomsnittsscoren. Siden vi ikke kan vite hvorfor noen av verdiene samsvarer, men andre har en forskjell, er det tryggest i dette tilfellet å bruke anmelderscorene vi har for å beregne gjennomsnittet selv. Når det er sagt, er forskjellene vanligvis veldig små. Her er hotellene med størst avvik mellom gjennomsnittet i datasettet og det beregnede gjennomsnittet:
|
||||
|
||||
| Average_Score_Difference | Average_Score | Calc_Average_Score | Hotel_Name |
|
||||
| :----------------------: | :-----------: | :----------------: | ------------------------------------------: |
|
||||
| -0.8 | 7.7 | 8.5 | Best Western Hotel Astoria |
|
||||
| -0.7 | 8.8 | 9.5 | Hotel Stendhal Place Vend me Paris MGallery |
|
||||
| -0.7 | 7.5 | 8.2 | Mercure Paris Porte d Orleans |
|
||||
| -0.7 | 7.9 | 8.6 | Renaissance Paris Vendome Hotel |
|
||||
| -0.5 | 7.0 | 7.5 | Hotel Royal Elys es |
|
||||
| ... | ... | ... | ... |
|
||||
| 0.7 | 7.5 | 6.8 | Mercure Paris Op ra Faubourg Montmartre |
|
||||
| 0.8 | 7.1 | 6.3 | Holiday Inn Paris Montparnasse Pasteur |
|
||||
| 0.9 | 6.8 | 5.9 | Villa Eugenie |
|
||||
| 0.9 | 8.6 | 7.7 | MARQUIS Faubourg St Honor Relais Ch teaux |
|
||||
| 1.3 | 7.2 | 5.9 | Kube Hotel Ice Bar |
|
||||
|
||||
Med bare 1 hotell som har en forskjell i score større enn 1, betyr det at vi sannsynligvis kan ignorere forskjellen og bruke den beregnede gjennomsnittsscoren.
|
||||
|
||||
6. Beregn og skriv ut hvor mange rader som har verdien "No Negative" i kolonnen `Negative_Review`.
|
||||
|
||||
7. Beregn og skriv ut hvor mange rader som har verdien "No Positive" i kolonnen `Positive_Review`.
|
||||
|
||||
8. Beregn og skriv ut hvor mange rader som har verdien "No Positive" i kolonnen `Positive_Review` **og** verdien "No Negative" i kolonnen `Negative_Review`.
|
||||
|
||||
```python
|
||||
# with lambdas:
|
||||
start = time.time()
|
||||
no_negative_reviews = df.apply(lambda x: True if x['Negative_Review'] == "No Negative" else False , axis=1)
|
||||
print("Number of No Negative reviews: " + str(len(no_negative_reviews[no_negative_reviews == True].index)))
|
||||
|
||||
no_positive_reviews = df.apply(lambda x: True if x['Positive_Review'] == "No Positive" else False , axis=1)
|
||||
print("Number of No Positive reviews: " + str(len(no_positive_reviews[no_positive_reviews == True].index)))
|
||||
|
||||
both_no_reviews = df.apply(lambda x: True if x['Negative_Review'] == "No Negative" and x['Positive_Review'] == "No Positive" else False , axis=1)
|
||||
print("Number of both No Negative and No Positive reviews: " + str(len(both_no_reviews[both_no_reviews == True].index)))
|
||||
end = time.time()
|
||||
print("Lambdas took " + str(round(end - start, 2)) + " seconds")
|
||||
|
||||
Number of No Negative reviews: 127890
|
||||
Number of No Positive reviews: 35946
|
||||
Number of both No Negative and No Positive reviews: 127
|
||||
Lambdas took 9.64 seconds
|
||||
```
|
||||
|
||||
## En annen måte
|
||||
|
||||
En annen måte å telle elementer uten Lambdas, og bruke sum for å telle radene:
|
||||
|
||||
```python
|
||||
# without lambdas (using a mixture of notations to show you can use both)
|
||||
start = time.time()
|
||||
no_negative_reviews = sum(df.Negative_Review == "No Negative")
|
||||
print("Number of No Negative reviews: " + str(no_negative_reviews))
|
||||
|
||||
no_positive_reviews = sum(df["Positive_Review"] == "No Positive")
|
||||
print("Number of No Positive reviews: " + str(no_positive_reviews))
|
||||
|
||||
both_no_reviews = sum((df.Negative_Review == "No Negative") & (df.Positive_Review == "No Positive"))
|
||||
print("Number of both No Negative and No Positive reviews: " + str(both_no_reviews))
|
||||
|
||||
end = time.time()
|
||||
print("Sum took " + str(round(end - start, 2)) + " seconds")
|
||||
|
||||
Number of No Negative reviews: 127890
|
||||
Number of No Positive reviews: 35946
|
||||
Number of both No Negative and No Positive reviews: 127
|
||||
Sum took 0.19 seconds
|
||||
```
|
||||
|
||||
Du har kanskje lagt merke til at det er 127 rader som har både "No Negative" og "No Positive" verdier i kolonnene `Negative_Review` og `Positive_Review` henholdsvis. Det betyr at anmelderen ga hotellet en numerisk score, men unnlot å skrive enten en positiv eller negativ anmeldelse. Heldigvis er dette en liten mengde rader (127 av 515738, eller 0,02 %), så det vil sannsynligvis ikke skjevfordele modellen vår eller resultatene i noen bestemt retning, men du hadde kanskje ikke forventet at et datasett med anmeldelser skulle ha rader uten anmeldelser, så det er verdt å utforske dataene for å oppdage slike rader.
|
||||
|
||||
Nå som du har utforsket datasettet, vil du i neste leksjon filtrere dataene og legge til litt sentimentanalyse.
|
||||
|
||||
---
|
||||
## 🚀Utfordring
|
||||
|
||||
Denne leksjonen viser, som vi så i tidligere leksjoner, hvor kritisk viktig det er å forstå dataene dine og deres særegenheter før du utfører operasjoner på dem. Tekstbaserte data krever spesielt nøye gransking. Grav gjennom ulike teksttunge datasett og se om du kan oppdage områder som kan introdusere skjevhet eller skjev sentimentanalyse i en modell.
|
||||
|
||||
## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Gjennomgang og selvstudium
|
||||
|
||||
Ta [denne læringsstien om NLP](https://docs.microsoft.com/learn/paths/explore-natural-language-processing/?WT.mc_id=academic-77952-leestott) for å oppdage verktøy du kan prøve når du bygger tale- og teksttunge modeller.
|
||||
|
||||
## Oppgave
|
||||
|
||||
[NLTK](assignment.md)
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,19 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "bf39bceb833cd628f224941dca8041df",
|
||||
"translation_date": "2025-09-05T22:20:12+00:00",
|
||||
"source_file": "6-NLP/4-Hotel-Reviews-1/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# NLTK
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
NLTK er et velkjent bibliotek for bruk innenfor datalingvistikk og NLP. Benytt denne anledningen til å lese gjennom '[NLTK-boken](https://www.nltk.org/book/)' og prøv ut øvelsene der. I denne ikke-vurderte oppgaven vil du bli bedre kjent med dette biblioteket.
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
|
||||
"translation_date": "2025-09-05T22:20:34+00:00",
|
||||
"source_file": "6-NLP/4-Hotel-Reviews-1/solution/Julia/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
|
||||
"translation_date": "2025-09-05T22:20:25+00:00",
|
||||
"source_file": "6-NLP/4-Hotel-Reviews-1/solution/R/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,25 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "daf144daa552da6a7d442aff6f3e77d8",
|
||||
"translation_date": "2025-09-05T22:29:33+00:00",
|
||||
"source_file": "6-NLP/5-Hotel-Reviews-2/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Prøv et annet datasett
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
Nå som du har lært å bruke NLTK for å tildele sentiment til tekst, prøv et annet datasett. Du vil sannsynligvis måtte gjøre noe databehandling rundt det, så opprett en notatbok og dokumenter tankeprosessen din. Hva oppdager du?
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Eksemplarisk | Tilfredsstillende | Trenger forbedring |
|
||||
| --------- | ------------------------------------------------------------------------------------------------------------- | ----------------------------------------- | ---------------------- |
|
||||
| | En komplett notatbok og datasett presenteres med godt dokumenterte celler som forklarer hvordan sentiment tildeles | Notatboken mangler gode forklaringer | Notatboken har mangler |
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
|
||||
"translation_date": "2025-09-05T22:30:03+00:00",
|
||||
"source_file": "6-NLP/5-Hotel-Reviews-2/solution/Julia/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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, ber vi deg være 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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
|
||||
"translation_date": "2025-09-05T22:29:48+00:00",
|
||||
"source_file": "6-NLP/5-Hotel-Reviews-2/solution/R/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "ee0670655c89e4719319764afb113624",
|
||||
"translation_date": "2025-09-05T22:20:47+00:00",
|
||||
"source_file": "6-NLP/data/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,199 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "662b509c39eee205687726636d0a8455",
|
||||
"translation_date": "2025-09-05T21:21:53+00:00",
|
||||
"source_file": "7-TimeSeries/1-Introduction/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Introduksjon til tidsserieprognoser
|
||||
|
||||
|
||||
|
||||
> Sketchnote av [Tomomi Imura](https://www.twitter.com/girlie_mac)
|
||||
|
||||
I denne leksjonen og den neste vil du lære litt om tidsserieprognoser, en interessant og verdifull del av en ML-forskers verktøykasse som er litt mindre kjent enn andre emner. Tidsserieprognoser er som en slags "krystallkule": basert på tidligere ytelse av en variabel, som pris, kan du forutsi dens fremtidige potensielle verdi.
|
||||
|
||||
[](https://youtu.be/cBojo1hsHiI "Introduksjon til tidsserieprognoser")
|
||||
|
||||
> 🎥 Klikk på bildet over for en video om tidsserieprognoser
|
||||
|
||||
## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
Det er et nyttig og interessant felt med reell verdi for næringslivet, gitt dets direkte anvendelse på problemer som prissetting, lagerstyring og forsyningskjedeutfordringer. Selv om dype læringsteknikker har begynt å bli brukt for å få mer innsikt og bedre forutsi fremtidig ytelse, forblir tidsserieprognoser et felt som i stor grad er informert av klassiske ML-teknikker.
|
||||
|
||||
> Penn States nyttige tidsseriepensum finner du [her](https://online.stat.psu.edu/stat510/lesson/1)
|
||||
|
||||
## Introduksjon
|
||||
|
||||
Anta at du administrerer en rekke smarte parkeringsmålere som gir data om hvor ofte de brukes og hvor lenge over tid.
|
||||
|
||||
> Hva om du kunne forutsi, basert på målerens tidligere ytelse, dens fremtidige verdi i henhold til lovene om tilbud og etterspørsel?
|
||||
|
||||
Å forutsi nøyaktig når man skal handle for å oppnå sitt mål er en utfordring som kan takles med tidsserieprognoser. Det ville ikke gjøre folk glade å bli belastet mer i travle tider når de leter etter en parkeringsplass, men det ville være en sikker måte å generere inntekter for å rengjøre gatene!
|
||||
|
||||
La oss utforske noen av typene tidsseriealgoritmer og starte en notebook for å rense og forberede noen data. Dataene du vil analysere er hentet fra GEFCom2014 prognosekonkurransen. Det består av 3 år med timebaserte verdier for elektrisitetsforbruk og temperatur mellom 2012 og 2014. Gitt de historiske mønstrene for elektrisitetsforbruk og temperatur, kan du forutsi fremtidige verdier for elektrisitetsforbruk.
|
||||
|
||||
I dette eksemplet vil du lære hvordan du forutsier ett tidssteg fremover, ved å bruke kun historiske forbruksdata. Før du starter, er det imidlertid nyttig å forstå hva som skjer bak kulissene.
|
||||
|
||||
## Noen definisjoner
|
||||
|
||||
Når du møter begrepet "tidsserie", må du forstå dets bruk i flere forskjellige sammenhenger.
|
||||
|
||||
🎓 **Tidsserie**
|
||||
|
||||
I matematikk er "en tidsserie en serie med datapunkter indeksert (eller listet eller grafet) i tidsrekkefølge. Oftest er en tidsserie en sekvens tatt ved suksessive, jevnt fordelte punkter i tid." Et eksempel på en tidsserie er den daglige sluttverdien av [Dow Jones Industrial Average](https://wikipedia.org/wiki/Time_series). Bruken av tidsserieplott og statistisk modellering er ofte sett i signalbehandling, værprognoser, jordskjelvforutsigelser og andre felt der hendelser oppstår og datapunkter kan plottes over tid.
|
||||
|
||||
🎓 **Tidsserieanalyse**
|
||||
|
||||
Tidsserieanalyse er analysen av den ovennevnte tidsseriedataen. Tidsseriedata kan ta forskjellige former, inkludert "avbrutte tidsserier" som oppdager mønstre i en tidsseries utvikling før og etter en avbrytende hendelse. Typen analyse som trengs for tidsserien, avhenger av naturen til dataene. Tidsseriedata i seg selv kan ta form av serier med tall eller tegn.
|
||||
|
||||
Analysen som skal utføres, bruker en rekke metoder, inkludert frekvensdomene og tidsdomene, lineære og ikke-lineære, og mer. [Lær mer](https://www.itl.nist.gov/div898/handbook/pmc/section4/pmc4.htm) om de mange måtene å analysere denne typen data.
|
||||
|
||||
🎓 **Tidsserieprognoser**
|
||||
|
||||
Tidsserieprognoser er bruken av en modell for å forutsi fremtidige verdier basert på mønstre vist av tidligere innsamlede data slik de oppstod i fortiden. Selv om det er mulig å bruke regresjonsmodeller for å utforske tidsseriedata, med tidsindekser som x-variabler på et plott, analyseres slike data best ved hjelp av spesielle typer modeller.
|
||||
|
||||
Tidsseriedata er en liste med ordnede observasjoner, i motsetning til data som kan analyseres ved lineær regresjon. Den vanligste modellen er ARIMA, et akronym som står for "Autoregressive Integrated Moving Average".
|
||||
|
||||
[ARIMA-modeller](https://online.stat.psu.edu/stat510/lesson/1/1.1) "relaterer den nåværende verdien av en serie til tidligere verdier og tidligere prediksjonsfeil." De er mest passende for å analysere tidsdomenedata, der data er ordnet over tid.
|
||||
|
||||
> Det finnes flere typer ARIMA-modeller, som du kan lære om [her](https://people.duke.edu/~rnau/411arim.htm) og som du vil berøre i neste leksjon.
|
||||
|
||||
I neste leksjon vil du bygge en ARIMA-modell ved hjelp av [Univariate Time Series](https://itl.nist.gov/div898/handbook/pmc/section4/pmc44.htm), som fokuserer på én variabel som endrer sin verdi over tid. Et eksempel på denne typen data er [dette datasettet](https://itl.nist.gov/div898/handbook/pmc/section4/pmc4411.htm) som registrerer den månedlige CO2-konsentrasjonen ved Mauna Loa-observatoriet:
|
||||
|
||||
| CO2 | YearMonth | Year | Month |
|
||||
| :----: | :-------: | :---: | :---: |
|
||||
| 330.62 | 1975.04 | 1975 | 1 |
|
||||
| 331.40 | 1975.13 | 1975 | 2 |
|
||||
| 331.87 | 1975.21 | 1975 | 3 |
|
||||
| 333.18 | 1975.29 | 1975 | 4 |
|
||||
| 333.92 | 1975.38 | 1975 | 5 |
|
||||
| 333.43 | 1975.46 | 1975 | 6 |
|
||||
| 331.85 | 1975.54 | 1975 | 7 |
|
||||
| 330.01 | 1975.63 | 1975 | 8 |
|
||||
| 328.51 | 1975.71 | 1975 | 9 |
|
||||
| 328.41 | 1975.79 | 1975 | 10 |
|
||||
| 329.25 | 1975.88 | 1975 | 11 |
|
||||
| 330.97 | 1975.96 | 1975 | 12 |
|
||||
|
||||
✅ Identifiser variabelen som endrer seg over tid i dette datasettet
|
||||
|
||||
## Tidsseriedataegenskaper å vurdere
|
||||
|
||||
Når du ser på tidsseriedata, kan du legge merke til at det har [visse egenskaper](https://online.stat.psu.edu/stat510/lesson/1/1.1) som du må ta hensyn til og redusere for bedre å forstå mønstrene. Hvis du ser på tidsseriedata som potensielt gir et "signal" du vil analysere, kan disse egenskapene betraktes som "støy". Du må ofte redusere denne "støyen" ved å kompensere for noen av disse egenskapene ved hjelp av statistiske teknikker.
|
||||
|
||||
Her er noen begreper du bør kjenne til for å kunne jobbe med tidsserier:
|
||||
|
||||
🎓 **Trender**
|
||||
|
||||
Trender er definert som målbare økninger og reduksjoner over tid. [Les mer](https://machinelearningmastery.com/time-series-trends-in-python). I sammenheng med tidsserier handler det om hvordan man bruker og, hvis nødvendig, fjerner trender fra tidsserien.
|
||||
|
||||
🎓 **[Sesongvariasjon](https://machinelearningmastery.com/time-series-seasonality-with-python/)**
|
||||
|
||||
Sesongvariasjon er definert som periodiske svingninger, som for eksempel høytidssalg som kan påvirke salget. [Ta en titt](https://itl.nist.gov/div898/handbook/pmc/section4/pmc443.htm) på hvordan forskjellige typer plott viser sesongvariasjon i data.
|
||||
|
||||
🎓 **Avvik**
|
||||
|
||||
Avvik er datapunkter som ligger langt unna den normale variansen i dataene.
|
||||
|
||||
🎓 **Langsiktig syklus**
|
||||
|
||||
Uavhengig av sesongvariasjon kan data vise en langsiktig syklus, som for eksempel en økonomisk nedgang som varer lenger enn ett år.
|
||||
|
||||
🎓 **Konstant varians**
|
||||
|
||||
Over tid viser noen data konstante svingninger, som energiforbruk per dag og natt.
|
||||
|
||||
🎓 **Brå endringer**
|
||||
|
||||
Dataene kan vise en brå endring som kan kreve ytterligere analyse. For eksempel førte den plutselige nedstengningen av virksomheter på grunn av COVID til endringer i dataene.
|
||||
|
||||
✅ Her er et [eksempel på et tidsserieplott](https://www.kaggle.com/kashnitsky/topic-9-part-1-time-series-analysis-in-python) som viser daglig bruk av in-game valuta over noen år. Kan du identifisere noen av egenskapene som er nevnt ovenfor i disse dataene?
|
||||
|
||||
|
||||
|
||||
## Øvelse - komme i gang med strømforbruksdata
|
||||
|
||||
La oss komme i gang med å lage en tidsseriemodell for å forutsi fremtidig strømforbruk basert på tidligere forbruk.
|
||||
|
||||
> Dataene i dette eksemplet er hentet fra GEFCom2014 prognosekonkurransen. Det består av 3 år med timebaserte verdier for elektrisitetsforbruk og temperatur mellom 2012 og 2014.
|
||||
>
|
||||
> Tao Hong, Pierre Pinson, Shu Fan, Hamidreza Zareipour, Alberto Troccoli og Rob J. Hyndman, "Probabilistic energy forecasting: Global Energy Forecasting Competition 2014 and beyond", International Journal of Forecasting, vol.32, no.3, pp 896-913, juli-september, 2016.
|
||||
|
||||
1. I `working`-mappen for denne leksjonen, åpne _notebook.ipynb_-filen. Start med å legge til biblioteker som vil hjelpe deg med å laste inn og visualisere data
|
||||
|
||||
```python
|
||||
import os
|
||||
import matplotlib.pyplot as plt
|
||||
from common.utils import load_data
|
||||
%matplotlib inline
|
||||
```
|
||||
|
||||
Merk at du bruker filene fra den inkluderte `common`-mappen som setter opp miljøet ditt og håndterer nedlasting av dataene.
|
||||
|
||||
2. Undersøk deretter dataene som en dataframe ved å kalle `load_data()` og `head()`:
|
||||
|
||||
```python
|
||||
data_dir = './data'
|
||||
energy = load_data(data_dir)[['load']]
|
||||
energy.head()
|
||||
```
|
||||
|
||||
Du kan se at det er to kolonner som representerer dato og forbruk:
|
||||
|
||||
| | load |
|
||||
| :-----------------: | :----: |
|
||||
| 2012-01-01 00:00:00 | 2698.0 |
|
||||
| 2012-01-01 01:00:00 | 2558.0 |
|
||||
| 2012-01-01 02:00:00 | 2444.0 |
|
||||
| 2012-01-01 03:00:00 | 2402.0 |
|
||||
| 2012-01-01 04:00:00 | 2403.0 |
|
||||
|
||||
3. Nå, plott dataene ved å kalle `plot()`:
|
||||
|
||||
```python
|
||||
energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
|
||||
plt.xlabel('timestamp', fontsize=12)
|
||||
plt.ylabel('load', fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
4. Nå, plott den første uken i juli 2014, ved å gi den som input til `energy` i `[fra dato]: [til dato]`-mønsteret:
|
||||
|
||||
```python
|
||||
energy['2014-07-01':'2014-07-07'].plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
|
||||
plt.xlabel('timestamp', fontsize=12)
|
||||
plt.ylabel('load', fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Et vakkert plott! Ta en titt på disse plottene og se om du kan identifisere noen av egenskapene som er nevnt ovenfor. Hva kan vi anta ved å visualisere dataene?
|
||||
|
||||
I neste leksjon vil du lage en ARIMA-modell for å lage noen prognoser.
|
||||
|
||||
---
|
||||
|
||||
## 🚀Utfordring
|
||||
|
||||
Lag en liste over alle bransjer og forskningsområder du kan tenke deg som vil ha nytte av tidsserieprognoser. Kan du tenke deg en anvendelse av disse teknikkene innen kunst? Innen økonometrikk? Økologi? Detaljhandel? Industri? Finans? Hvor ellers?
|
||||
|
||||
## [Quiz etter leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Gjennomgang & Selvstudium
|
||||
|
||||
Selv om vi ikke dekker dem her, brukes nevrale nettverk noen ganger for å forbedre klassiske metoder for tidsserieprognoser. Les mer om dem [i denne artikkelen](https://medium.com/microsoftazure/neural-networks-for-forecasting-financial-and-economic-time-series-6aca370ff412)
|
||||
|
||||
## Oppgave
|
||||
|
||||
[Visualiser flere tidsserier](assignment.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, 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.
|
||||
@ -0,0 +1,25 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "d1781b0b92568ea1d119d0a198b576b4",
|
||||
"translation_date": "2025-09-05T21:22:37+00:00",
|
||||
"source_file": "7-TimeSeries/1-Introduction/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Visualiser noen flere tidsserier
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
Du har begynt å lære om tidsserieprognoser ved å se på typen data som krever denne spesielle modelleringen. Du har visualisert noen data knyttet til energi. Nå, se deg rundt etter andre data som kan dra nytte av tidsserieprognoser. Finn tre eksempler (prøv [Kaggle](https://kaggle.com) og [Azure Open Datasets](https://azure.microsoft.com/en-us/services/open-datasets/catalog/?WT.mc_id=academic-77952-leestott)) og lag en notatbok for å visualisere dem. Noter eventuelle spesielle egenskaper de har (sesongvariasjoner, brå endringer eller andre trender) i notatboken.
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Eksemplarisk | Tilfredsstillende | Trenger forbedring |
|
||||
| --------- | ------------------------------------------------------ | -------------------------------------------------- | --------------------------------------------------------------------------------------- |
|
||||
| | Tre datasett er plottet og forklart i en notatbok | To datasett er plottet og forklart i en notatbok | Få datasett er plottet eller forklart i en notatbok, eller dataene som presenteres er utilstrekkelige |
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
|
||||
"translation_date": "2025-09-05T21:23:00+00:00",
|
||||
"source_file": "7-TimeSeries/1-Introduction/solution/Julia/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
|
||||
"translation_date": "2025-09-05T21:22:51+00:00",
|
||||
"source_file": "7-TimeSeries/1-Introduction/solution/R/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,407 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "917dbf890db71a322f306050cb284749",
|
||||
"translation_date": "2025-09-05T21:19:25+00:00",
|
||||
"source_file": "7-TimeSeries/2-ARIMA/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Tidsserieprognoser med ARIMA
|
||||
|
||||
I forrige leksjon lærte du litt om tidsserieprognoser og lastet inn et datasett som viser svingninger i elektrisk belastning over en tidsperiode.
|
||||
|
||||
[](https://youtu.be/IUSk-YDau10 "Introduksjon til ARIMA")
|
||||
|
||||
> 🎥 Klikk på bildet ovenfor for en video: En kort introduksjon til ARIMA-modeller. Eksempelet er gjort i R, men konseptene er universelle.
|
||||
|
||||
## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Introduksjon
|
||||
|
||||
I denne leksjonen vil du oppdage en spesifikk måte å bygge modeller på med [ARIMA: *A*uto*R*egressive *I*ntegrated *M*oving *A*verage](https://wikipedia.org/wiki/Autoregressive_integrated_moving_average). ARIMA-modeller er spesielt godt egnet til å tilpasse data som viser [ikke-stasjonaritet](https://wikipedia.org/wiki/Stationary_process).
|
||||
|
||||
## Generelle konsepter
|
||||
|
||||
For å kunne jobbe med ARIMA, er det noen konsepter du må kjenne til:
|
||||
|
||||
- 🎓 **Stasjonaritet**. Fra et statistisk perspektiv refererer stasjonaritet til data der distribusjonen ikke endres når den forskyves i tid. Ikke-stasjonære data viser derimot svingninger på grunn av trender som må transformeres for å kunne analyseres. Sesongvariasjoner, for eksempel, kan introdusere svingninger i data og kan elimineres ved en prosess kalt 'sesongdifferensiering'.
|
||||
|
||||
- 🎓 **[Differensiering](https://wikipedia.org/wiki/Autoregressive_integrated_moving_average#Differencing)**. Differensiering av data, igjen fra et statistisk perspektiv, refererer til prosessen med å transformere ikke-stasjonære data for å gjøre dem stasjonære ved å fjerne deres ikke-konstante trend. "Differensiering fjerner endringene i nivået til en tidsserie, eliminerer trend og sesongvariasjoner og stabiliserer dermed gjennomsnittet av tidsserien." [Paper av Shixiong et al](https://arxiv.org/abs/1904.07632)
|
||||
|
||||
## ARIMA i konteksten av tidsserier
|
||||
|
||||
La oss pakke ut delene av ARIMA for bedre å forstå hvordan det hjelper oss med å modellere tidsserier og lage prognoser basert på dem.
|
||||
|
||||
- **AR - for AutoRegressiv**. Autoregressive modeller, som navnet antyder, ser 'tilbake' i tid for å analysere tidligere verdier i dataene dine og gjøre antakelser om dem. Disse tidligere verdiene kalles 'lags'. Et eksempel kan være data som viser månedlige salg av blyanter. Hver måneds salgssum vil bli betraktet som en 'utviklende variabel' i datasettet. Denne modellen bygges ved at "den utviklende variabelen av interesse regresseres på sine egne forsinkede (dvs. tidligere) verdier." [wikipedia](https://wikipedia.org/wiki/Autoregressive_integrated_moving_average)
|
||||
|
||||
- **I - for Integrert**. I motsetning til de lignende 'ARMA'-modellene, refererer 'I' i ARIMA til dens *[integrerte](https://wikipedia.org/wiki/Order_of_integration)* aspekt. Dataene blir 'integrert' når differensieringstrinn brukes for å eliminere ikke-stasjonaritet.
|
||||
|
||||
- **MA - for Glidende Gjennomsnitt**. Det [glidende gjennomsnittet](https://wikipedia.org/wiki/Moving-average_model) i denne modellen refererer til utgangsvariabelen som bestemmes ved å observere nåværende og tidligere verdier av lags.
|
||||
|
||||
Kort oppsummert: ARIMA brukes til å lage en modell som passer så tett som mulig til den spesielle formen for tidsseriedata.
|
||||
|
||||
## Øvelse - bygg en ARIMA-modell
|
||||
|
||||
Åpne [_/working_](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA/working)-mappen i denne leksjonen og finn filen [_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/7-TimeSeries/2-ARIMA/working/notebook.ipynb).
|
||||
|
||||
1. Kjør notebooken for å laste inn Python-biblioteket `statsmodels`; du trenger dette for ARIMA-modeller.
|
||||
|
||||
1. Last inn nødvendige biblioteker.
|
||||
|
||||
1. Deretter laster du inn flere biblioteker som er nyttige for å plotte data:
|
||||
|
||||
```python
|
||||
import os
|
||||
import warnings
|
||||
import matplotlib.pyplot as plt
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
import datetime as dt
|
||||
import math
|
||||
|
||||
from pandas.plotting import autocorrelation_plot
|
||||
from statsmodels.tsa.statespace.sarimax import SARIMAX
|
||||
from sklearn.preprocessing import MinMaxScaler
|
||||
from common.utils import load_data, mape
|
||||
from IPython.display import Image
|
||||
|
||||
%matplotlib inline
|
||||
pd.options.display.float_format = '{:,.2f}'.format
|
||||
np.set_printoptions(precision=2)
|
||||
warnings.filterwarnings("ignore") # specify to ignore warning messages
|
||||
```
|
||||
|
||||
1. Last inn data fra `/data/energy.csv`-filen til en Pandas dataframe og ta en titt:
|
||||
|
||||
```python
|
||||
energy = load_data('./data')[['load']]
|
||||
energy.head(10)
|
||||
```
|
||||
|
||||
1. Plot all tilgjengelig energidata fra januar 2012 til desember 2014. Det bør ikke være noen overraskelser, da vi så disse dataene i forrige leksjon:
|
||||
|
||||
```python
|
||||
energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
|
||||
plt.xlabel('timestamp', fontsize=12)
|
||||
plt.ylabel('load', fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
Nå, la oss bygge en modell!
|
||||
|
||||
### Opprett trenings- og testdatasett
|
||||
|
||||
Nå er dataene dine lastet inn, så du kan dele dem opp i trenings- og testsett. Du vil trene modellen din på treningssettet. Som vanlig, etter at modellen er ferdig trent, vil du evaluere nøyaktigheten ved hjelp av testsettet. Du må sørge for at testsettet dekker en senere tidsperiode enn treningssettet for å sikre at modellen ikke får informasjon fra fremtidige tidsperioder.
|
||||
|
||||
1. Tildel en to-måneders periode fra 1. september til 31. oktober 2014 til treningssettet. Testsettet vil inkludere to-måneders perioden fra 1. november til 31. desember 2014:
|
||||
|
||||
```python
|
||||
train_start_dt = '2014-11-01 00:00:00'
|
||||
test_start_dt = '2014-12-30 00:00:00'
|
||||
```
|
||||
|
||||
Siden disse dataene reflekterer det daglige energiforbruket, er det et sterkt sesongmønster, men forbruket er mest likt forbruket i mer nylige dager.
|
||||
|
||||
1. Visualiser forskjellene:
|
||||
|
||||
```python
|
||||
energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)][['load']].rename(columns={'load':'train'}) \
|
||||
.join(energy[test_start_dt:][['load']].rename(columns={'load':'test'}), how='outer') \
|
||||
.plot(y=['train', 'test'], figsize=(15, 8), fontsize=12)
|
||||
plt.xlabel('timestamp', fontsize=12)
|
||||
plt.ylabel('load', fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Derfor bør det være tilstrekkelig å bruke et relativt lite tidsvindu for å trene dataene.
|
||||
|
||||
> Merk: Siden funksjonen vi bruker for å tilpasse ARIMA-modellen bruker in-sample validering under tilpasning, vil vi utelate valideringsdata.
|
||||
|
||||
### Forbered dataene for trening
|
||||
|
||||
Nå må du forberede dataene for trening ved å filtrere og skalere dem. Filtrer datasettet ditt for kun å inkludere de nødvendige tidsperiodene og kolonnene, og skaler dataene for å sikre at de projiseres i intervallet 0,1.
|
||||
|
||||
1. Filtrer det originale datasettet for kun å inkludere de nevnte tidsperiodene per sett og kun inkludere den nødvendige kolonnen 'load' pluss datoen:
|
||||
|
||||
```python
|
||||
train = energy.copy()[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']]
|
||||
test = energy.copy()[energy.index >= test_start_dt][['load']]
|
||||
|
||||
print('Training data shape: ', train.shape)
|
||||
print('Test data shape: ', test.shape)
|
||||
```
|
||||
|
||||
Du kan se formen på dataene:
|
||||
|
||||
```output
|
||||
Training data shape: (1416, 1)
|
||||
Test data shape: (48, 1)
|
||||
```
|
||||
|
||||
1. Skaler dataene til å være i området (0, 1).
|
||||
|
||||
```python
|
||||
scaler = MinMaxScaler()
|
||||
train['load'] = scaler.fit_transform(train)
|
||||
train.head(10)
|
||||
```
|
||||
|
||||
1. Visualiser de originale vs. skalerte dataene:
|
||||
|
||||
```python
|
||||
energy[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']].rename(columns={'load':'original load'}).plot.hist(bins=100, fontsize=12)
|
||||
train.rename(columns={'load':'scaled load'}).plot.hist(bins=100, fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
> De originale dataene
|
||||
|
||||
|
||||
|
||||
> De skalerte dataene
|
||||
|
||||
1. Nå som du har kalibrert de skalerte dataene, kan du skalere testdataene:
|
||||
|
||||
```python
|
||||
test['load'] = scaler.transform(test)
|
||||
test.head()
|
||||
```
|
||||
|
||||
### Implementer ARIMA
|
||||
|
||||
Det er på tide å implementere ARIMA! Du vil nå bruke `statsmodels`-biblioteket som du installerte tidligere.
|
||||
|
||||
Nå må du følge flere trinn:
|
||||
|
||||
1. Definer modellen ved å kalle `SARIMAX()` og sende inn modellparametrene: p, d og q-parametere, samt P, D og Q-parametere.
|
||||
2. Forbered modellen for treningsdataene ved å kalle fit()-funksjonen.
|
||||
3. Lag prognoser ved å kalle `forecast()`-funksjonen og spesifisere antall steg (horisonten) som skal prognoseres.
|
||||
|
||||
> 🎓 Hva er alle disse parameterne til? I en ARIMA-modell er det 3 parametere som brukes for å modellere de viktigste aspektene ved en tidsserie: sesongvariasjon, trend og støy. Disse parameterne er:
|
||||
|
||||
`p`: parameteren knyttet til den autoregressive delen av modellen, som inkorporerer *tidligere* verdier.
|
||||
`d`: parameteren knyttet til den integrerte delen av modellen, som påvirker mengden *differensiering* (🎓 husk differensiering 👆?) som skal brukes på en tidsserie.
|
||||
`q`: parameteren knyttet til den glidende gjennomsnittsdelen av modellen.
|
||||
|
||||
> Merk: Hvis dataene dine har en sesongmessig komponent - som disse dataene har - bruker vi en sesongmessig ARIMA-modell (SARIMA). I så fall må du bruke et annet sett med parametere: `P`, `D` og `Q`, som beskriver de samme assosiasjonene som `p`, `d` og `q`, men tilsvarer de sesongmessige komponentene i modellen.
|
||||
|
||||
1. Start med å sette din foretrukne horisontverdi. La oss prøve 3 timer:
|
||||
|
||||
```python
|
||||
# Specify the number of steps to forecast ahead
|
||||
HORIZON = 3
|
||||
print('Forecasting horizon:', HORIZON, 'hours')
|
||||
```
|
||||
|
||||
Å velge de beste verdiene for en ARIMA-modells parametere kan være utfordrende, da det er noe subjektivt og tidkrevende. Du kan vurdere å bruke en `auto_arima()`-funksjon fra [`pyramid`-biblioteket](https://alkaline-ml.com/pmdarima/0.9.0/modules/generated/pyramid.arima.auto_arima.html).
|
||||
|
||||
1. For nå, prøv noen manuelle valg for å finne en god modell.
|
||||
|
||||
```python
|
||||
order = (4, 1, 0)
|
||||
seasonal_order = (1, 1, 0, 24)
|
||||
|
||||
model = SARIMAX(endog=train, order=order, seasonal_order=seasonal_order)
|
||||
results = model.fit()
|
||||
|
||||
print(results.summary())
|
||||
```
|
||||
|
||||
En tabell med resultater blir skrevet ut.
|
||||
|
||||
Du har bygget din første modell! Nå må vi finne en måte å evaluere den på.
|
||||
|
||||
### Evaluer modellen din
|
||||
|
||||
For å evaluere modellen din kan du utføre den såkalte `walk forward`-valideringen. I praksis blir tidsseriemodeller re-trent hver gang nye data blir tilgjengelige. Dette lar modellen lage den beste prognosen ved hvert tidssteg.
|
||||
|
||||
Start ved begynnelsen av tidsserien med denne teknikken, tren modellen på treningsdatasettet. Deretter lager du en prognose for neste tidssteg. Prognosen evalueres mot den kjente verdien. Treningssettet utvides deretter til å inkludere den kjente verdien, og prosessen gjentas.
|
||||
|
||||
> Merk: Du bør holde treningssettets vindu fast for mer effektiv trening, slik at hver gang du legger til en ny observasjon i treningssettet, fjerner du observasjonen fra begynnelsen av settet.
|
||||
|
||||
Denne prosessen gir en mer robust estimering av hvordan modellen vil prestere i praksis. Imidlertid kommer det med beregningskostnaden ved å lage så mange modeller. Dette er akseptabelt hvis dataene er små eller hvis modellen er enkel, men kan være et problem i stor skala.
|
||||
|
||||
Walk-forward validering er gullstandarden for evaluering av tidsseriemodeller og anbefales for dine egne prosjekter.
|
||||
|
||||
1. Først, opprett et testdatapunkt for hvert HORIZON-steg.
|
||||
|
||||
```python
|
||||
test_shifted = test.copy()
|
||||
|
||||
for t in range(1, HORIZON+1):
|
||||
test_shifted['load+'+str(t)] = test_shifted['load'].shift(-t, freq='H')
|
||||
|
||||
test_shifted = test_shifted.dropna(how='any')
|
||||
test_shifted.head(5)
|
||||
```
|
||||
|
||||
| | | load | load+1 | load+2 |
|
||||
| ---------- | -------- | ---- | ------ | ------ |
|
||||
| 2014-12-30 | 00:00:00 | 0.33 | 0.29 | 0.27 |
|
||||
| 2014-12-30 | 01:00:00 | 0.29 | 0.27 | 0.27 |
|
||||
| 2014-12-30 | 02:00:00 | 0.27 | 0.27 | 0.30 |
|
||||
| 2014-12-30 | 03:00:00 | 0.27 | 0.30 | 0.41 |
|
||||
| 2014-12-30 | 04:00:00 | 0.30 | 0.41 | 0.57 |
|
||||
|
||||
Dataene forskyves horisontalt i henhold til horisontpunktet.
|
||||
|
||||
1. Lag prognoser for testdataene dine ved hjelp av denne glidende vindustilnærmingen i en løkke på størrelse med testdatasettets lengde:
|
||||
|
||||
```python
|
||||
%%time
|
||||
training_window = 720 # dedicate 30 days (720 hours) for training
|
||||
|
||||
train_ts = train['load']
|
||||
test_ts = test_shifted
|
||||
|
||||
history = [x for x in train_ts]
|
||||
history = history[(-training_window):]
|
||||
|
||||
predictions = list()
|
||||
|
||||
order = (2, 1, 0)
|
||||
seasonal_order = (1, 1, 0, 24)
|
||||
|
||||
for t in range(test_ts.shape[0]):
|
||||
model = SARIMAX(endog=history, order=order, seasonal_order=seasonal_order)
|
||||
model_fit = model.fit()
|
||||
yhat = model_fit.forecast(steps = HORIZON)
|
||||
predictions.append(yhat)
|
||||
obs = list(test_ts.iloc[t])
|
||||
# move the training window
|
||||
history.append(obs[0])
|
||||
history.pop(0)
|
||||
print(test_ts.index[t])
|
||||
print(t+1, ': predicted =', yhat, 'expected =', obs)
|
||||
```
|
||||
|
||||
Du kan se treningen foregå:
|
||||
|
||||
```output
|
||||
2014-12-30 00:00:00
|
||||
1 : predicted = [0.32 0.29 0.28] expected = [0.32945389435989236, 0.2900626678603402, 0.2739480752014323]
|
||||
|
||||
2014-12-30 01:00:00
|
||||
2 : predicted = [0.3 0.29 0.3 ] expected = [0.2900626678603402, 0.2739480752014323, 0.26812891674127126]
|
||||
|
||||
2014-12-30 02:00:00
|
||||
3 : predicted = [0.27 0.28 0.32] expected = [0.2739480752014323, 0.26812891674127126, 0.3025962399283795]
|
||||
```
|
||||
|
||||
1. Sammenlign prognosene med den faktiske belastningen:
|
||||
|
||||
```python
|
||||
eval_df = pd.DataFrame(predictions, columns=['t+'+str(t) for t in range(1, HORIZON+1)])
|
||||
eval_df['timestamp'] = test.index[0:len(test.index)-HORIZON+1]
|
||||
eval_df = pd.melt(eval_df, id_vars='timestamp', value_name='prediction', var_name='h')
|
||||
eval_df['actual'] = np.array(np.transpose(test_ts)).ravel()
|
||||
eval_df[['prediction', 'actual']] = scaler.inverse_transform(eval_df[['prediction', 'actual']])
|
||||
eval_df.head()
|
||||
```
|
||||
|
||||
Output
|
||||
| | | timestamp | h | prediction | actual |
|
||||
| --- | ---------- | --------- | --- | ---------- | -------- |
|
||||
| 0 | 2014-12-30 | 00:00:00 | t+1 | 3,008.74 | 3,023.00 |
|
||||
| 1 | 2014-12-30 | 01:00:00 | t+1 | 2,955.53 | 2,935.00 |
|
||||
| 2 | 2014-12-30 | 02:00:00 | t+1 | 2,900.17 | 2,899.00 |
|
||||
| 3 | 2014-12-30 | 03:00:00 | t+1 | 2,917.69 | 2,886.00 |
|
||||
| 4 | 2014-12-30 | 04:00:00 | t+1 | 2,946.99 | 2,963.00 |
|
||||
|
||||
Observer prognosen for timebaserte data sammenlignet med den faktiske belastningen. Hvor nøyaktig er dette?
|
||||
|
||||
### Sjekk modellens nøyaktighet
|
||||
|
||||
Sjekk nøyaktigheten til modellen din ved å teste dens gjennomsnittlige absolutte prosentvise feil (MAPE) over alle prognosene.
|
||||
> **🧮 Vis meg matematikken**
|
||||
>
|
||||
> 
|
||||
>
|
||||
> [MAPE](https://www.linkedin.com/pulse/what-mape-mad-msd-time-series-allameh-statistics/) brukes for å vise prediksjonsnøyaktighet som et forhold definert av formelen ovenfor. Forskjellen mellom faktisk og forutsagt deles på det faktiske.
|
||||
>
|
||||
> "Den absolutte verdien i denne beregningen summeres for hvert prognosert tidspunkt og deles på antall tilpassede punkter n." [wikipedia](https://wikipedia.org/wiki/Mean_absolute_percentage_error)
|
||||
1. Uttrykk ligningen i kode:
|
||||
|
||||
```python
|
||||
if(HORIZON > 1):
|
||||
eval_df['APE'] = (eval_df['prediction'] - eval_df['actual']).abs() / eval_df['actual']
|
||||
print(eval_df.groupby('h')['APE'].mean())
|
||||
```
|
||||
|
||||
1. Beregn MAPE for ett steg:
|
||||
|
||||
```python
|
||||
print('One step forecast MAPE: ', (mape(eval_df[eval_df['h'] == 't+1']['prediction'], eval_df[eval_df['h'] == 't+1']['actual']))*100, '%')
|
||||
```
|
||||
|
||||
MAPE for ett steg: 0.5570581332313952 %
|
||||
|
||||
1. Skriv ut MAPE for flertrinnsprognosen:
|
||||
|
||||
```python
|
||||
print('Multi-step forecast MAPE: ', mape(eval_df['prediction'], eval_df['actual'])*100, '%')
|
||||
```
|
||||
|
||||
```output
|
||||
Multi-step forecast MAPE: 1.1460048657704118 %
|
||||
```
|
||||
|
||||
Et lavt tall er best: husk at en prognose med en MAPE på 10 er feil med 10%.
|
||||
|
||||
1. Men som alltid, det er enklere å se denne typen nøyaktighetsmåling visuelt, så la oss plotte det:
|
||||
|
||||
```python
|
||||
if(HORIZON == 1):
|
||||
## Plotting single step forecast
|
||||
eval_df.plot(x='timestamp', y=['actual', 'prediction'], style=['r', 'b'], figsize=(15, 8))
|
||||
|
||||
else:
|
||||
## Plotting multi step forecast
|
||||
plot_df = eval_df[(eval_df.h=='t+1')][['timestamp', 'actual']]
|
||||
for t in range(1, HORIZON+1):
|
||||
plot_df['t+'+str(t)] = eval_df[(eval_df.h=='t+'+str(t))]['prediction'].values
|
||||
|
||||
fig = plt.figure(figsize=(15, 8))
|
||||
ax = plt.plot(plot_df['timestamp'], plot_df['actual'], color='red', linewidth=4.0)
|
||||
ax = fig.add_subplot(111)
|
||||
for t in range(1, HORIZON+1):
|
||||
x = plot_df['timestamp'][(t-1):]
|
||||
y = plot_df['t+'+str(t)][0:len(x)]
|
||||
ax.plot(x, y, color='blue', linewidth=4*math.pow(.9,t), alpha=math.pow(0.8,t))
|
||||
|
||||
ax.legend(loc='best')
|
||||
|
||||
plt.xlabel('timestamp', fontsize=12)
|
||||
plt.ylabel('load', fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
🏆 Et veldig fint plot som viser en modell med god nøyaktighet. Bra jobbet!
|
||||
|
||||
---
|
||||
|
||||
## 🚀Utfordring
|
||||
|
||||
Utforsk måter å teste nøyaktigheten til en tidsseriemodell. Vi berører MAPE i denne leksjonen, men finnes det andre metoder du kan bruke? Undersøk dem og kommenter dem. Et nyttig dokument kan finnes [her](https://otexts.com/fpp2/accuracy.html)
|
||||
|
||||
## [Quiz etter leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Gjennomgang & Selvstudium
|
||||
|
||||
Denne leksjonen berører kun det grunnleggende innen tidsserieprognoser med ARIMA. Ta deg tid til å utdype kunnskapen din ved å utforske [dette repositoriet](https://microsoft.github.io/forecasting/) og dets ulike modelltyper for å lære andre måter å bygge tidsseriemodeller på.
|
||||
|
||||
## Oppgave
|
||||
|
||||
[En ny ARIMA-modell](assignment.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.
|
||||
@ -0,0 +1,25 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "1c814013e10866dfd92cdb32caaae3ac",
|
||||
"translation_date": "2025-09-05T21:20:16+00:00",
|
||||
"source_file": "7-TimeSeries/2-ARIMA/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# En ny ARIMA-modell
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
Nå som du har bygget en ARIMA-modell, lag en ny med ferske data (prøv en av [disse datasettene fra Duke](http://www2.stat.duke.edu/~mw/ts_data_sets.html). Kommenter arbeidet ditt i en notebook, visualiser dataene og modellen din, og test nøyaktigheten ved hjelp av MAPE.
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Eksemplarisk | Tilfredsstillende | Trenger forbedring |
|
||||
| --------- | ----------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------- | ---------------------------------- |
|
||||
| | En notebook presenteres med en ny ARIMA-modell bygget, testet og forklart med visualiseringer og angitt nøyaktighet. | Notebooken som presenteres er ikke kommentert eller inneholder feil | En ufullstendig notebook presenteres |
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
|
||||
"translation_date": "2025-09-05T21:20:39+00:00",
|
||||
"source_file": "7-TimeSeries/2-ARIMA/solution/Julia/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
|
||||
"translation_date": "2025-09-05T21:20:29+00:00",
|
||||
"source_file": "7-TimeSeries/2-ARIMA/solution/R/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,393 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "482bccabe1df958496ea71a3667995cd",
|
||||
"translation_date": "2025-09-05T21:24:09+00:00",
|
||||
"source_file": "7-TimeSeries/3-SVR/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Tidsserieprognoser med Support Vector Regressor
|
||||
|
||||
I forrige leksjon lærte du hvordan du bruker ARIMA-modellen til å lage tidsserieprediksjoner. Nå skal vi se på Support Vector Regressor-modellen, som er en regresjonsmodell brukt til å forutsi kontinuerlige data.
|
||||
|
||||
## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Introduksjon
|
||||
|
||||
I denne leksjonen vil du oppdage en spesifikk måte å bygge modeller med [**SVM**: **S**upport **V**ector **M**achine](https://en.wikipedia.org/wiki/Support-vector_machine) for regresjon, eller **SVR: Support Vector Regressor**.
|
||||
|
||||
### SVR i konteksten av tidsserier [^1]
|
||||
|
||||
Før du forstår viktigheten av SVR i tidsserieprediksjon, er det noen viktige konsepter du bør kjenne til:
|
||||
|
||||
- **Regresjon:** En overvåket læringsteknikk for å forutsi kontinuerlige verdier basert på et gitt sett med input. Ideen er å tilpasse en kurve (eller linje) i funksjonsrommet som har flest mulig datapunkter. [Klikk her](https://en.wikipedia.org/wiki/Regression_analysis) for mer informasjon.
|
||||
- **Support Vector Machine (SVM):** En type overvåket maskinlæringsmodell brukt til klassifisering, regresjon og deteksjon av avvik. Modellen er et hyperplan i funksjonsrommet, som i tilfelle klassifisering fungerer som en grense, og i tilfelle regresjon fungerer som den beste tilpassede linjen. I SVM brukes vanligvis en Kernel-funksjon for å transformere datasettet til et rom med høyere dimensjoner, slik at de blir lettere separerbare. [Klikk her](https://en.wikipedia.org/wiki/Support-vector_machine) for mer informasjon om SVM.
|
||||
- **Support Vector Regressor (SVR):** En type SVM som finner den beste tilpassede linjen (som i tilfelle SVM er et hyperplan) som har flest mulig datapunkter.
|
||||
|
||||
### Hvorfor SVR? [^1]
|
||||
|
||||
I forrige leksjon lærte du om ARIMA, som er en svært vellykket statistisk lineær metode for å forutsi tidsseriedata. Men i mange tilfeller har tidsseriedata *ikke-linearitet*, som ikke kan modelleres av lineære metoder. I slike tilfeller gjør SVMs evne til å ta hensyn til ikke-linearitet i dataene for regresjonsoppgaver SVR vellykket i tidsserieprognoser.
|
||||
|
||||
## Øvelse - bygg en SVR-modell
|
||||
|
||||
De første stegene for datapreparering er de samme som i forrige leksjon om [ARIMA](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA).
|
||||
|
||||
Åpne [_/working_](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/3-SVR/working)-mappen i denne leksjonen og finn [_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/7-TimeSeries/3-SVR/working/notebook.ipynb)-filen.[^2]
|
||||
|
||||
1. Kjør notebooken og importer de nødvendige bibliotekene: [^2]
|
||||
|
||||
```python
|
||||
import sys
|
||||
sys.path.append('../../')
|
||||
```
|
||||
|
||||
```python
|
||||
import os
|
||||
import warnings
|
||||
import matplotlib.pyplot as plt
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
import datetime as dt
|
||||
import math
|
||||
|
||||
from sklearn.svm import SVR
|
||||
from sklearn.preprocessing import MinMaxScaler
|
||||
from common.utils import load_data, mape
|
||||
```
|
||||
|
||||
2. Last inn dataene fra `/data/energy.csv`-filen til en Pandas-datastruktur og se på dem: [^2]
|
||||
|
||||
```python
|
||||
energy = load_data('../../data')[['load']]
|
||||
```
|
||||
|
||||
3. Plott alle tilgjengelige energidata fra januar 2012 til desember 2014: [^2]
|
||||
|
||||
```python
|
||||
energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
|
||||
plt.xlabel('timestamp', fontsize=12)
|
||||
plt.ylabel('load', fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Nå skal vi bygge vår SVR-modell.
|
||||
|
||||
### Opprett trenings- og testdatasett
|
||||
|
||||
Nå er dataene dine lastet inn, så du kan dele dem opp i trenings- og testsett. Deretter vil du omforme dataene for å lage et tidsstegbasert datasett som vil være nødvendig for SVR. Du vil trene modellen på treningssettet. Etter at modellen er ferdig trent, vil du evaluere dens nøyaktighet på treningssettet, testsettet og deretter hele datasettet for å se den generelle ytelsen. Du må sørge for at testsettet dekker en senere tidsperiode enn treningssettet for å sikre at modellen ikke får informasjon fra fremtidige tidsperioder [^2] (en situasjon kjent som *Overfitting*).
|
||||
|
||||
1. Tildel en to-måneders periode fra 1. september til 31. oktober 2014 til treningssettet. Testsettet vil inkludere to-måneders perioden fra 1. november til 31. desember 2014: [^2]
|
||||
|
||||
```python
|
||||
train_start_dt = '2014-11-01 00:00:00'
|
||||
test_start_dt = '2014-12-30 00:00:00'
|
||||
```
|
||||
|
||||
2. Visualiser forskjellene: [^2]
|
||||
|
||||
```python
|
||||
energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)][['load']].rename(columns={'load':'train'}) \
|
||||
.join(energy[test_start_dt:][['load']].rename(columns={'load':'test'}), how='outer') \
|
||||
.plot(y=['train', 'test'], figsize=(15, 8), fontsize=12)
|
||||
plt.xlabel('timestamp', fontsize=12)
|
||||
plt.ylabel('load', fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
### Forbered dataene for trening
|
||||
|
||||
Nå må du forberede dataene for trening ved å filtrere og skalere dataene dine. Filtrer datasettet for kun å inkludere de tidsperiodene og kolonnene du trenger, og skaler for å sikre at dataene projiseres i intervallet 0,1.
|
||||
|
||||
1. Filtrer det originale datasettet for kun å inkludere de nevnte tidsperiodene per sett og kun inkludere den nødvendige kolonnen 'load' pluss datoen: [^2]
|
||||
|
||||
```python
|
||||
train = energy.copy()[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']]
|
||||
test = energy.copy()[energy.index >= test_start_dt][['load']]
|
||||
|
||||
print('Training data shape: ', train.shape)
|
||||
print('Test data shape: ', test.shape)
|
||||
```
|
||||
|
||||
```output
|
||||
Training data shape: (1416, 1)
|
||||
Test data shape: (48, 1)
|
||||
```
|
||||
|
||||
2. Skaler treningsdataene til å være i området (0, 1): [^2]
|
||||
|
||||
```python
|
||||
scaler = MinMaxScaler()
|
||||
train['load'] = scaler.fit_transform(train)
|
||||
```
|
||||
|
||||
4. Nå skalerer du testdataene: [^2]
|
||||
|
||||
```python
|
||||
test['load'] = scaler.transform(test)
|
||||
```
|
||||
|
||||
### Opprett data med tidssteg [^1]
|
||||
|
||||
For SVR transformerer du inputdataene til formen `[batch, timesteps]`. Så du omformer de eksisterende `train_data` og `test_data` slik at det er en ny dimensjon som refererer til tidsstegene.
|
||||
|
||||
```python
|
||||
# Converting to numpy arrays
|
||||
train_data = train.values
|
||||
test_data = test.values
|
||||
```
|
||||
|
||||
For dette eksempelet tar vi `timesteps = 5`. Så input til modellen er dataene for de første 4 tidsstegene, og output vil være dataene for det 5. tidssteget.
|
||||
|
||||
```python
|
||||
timesteps=5
|
||||
```
|
||||
|
||||
Konverter treningsdata til 2D tensor ved hjelp av nested list comprehension:
|
||||
|
||||
```python
|
||||
train_data_timesteps=np.array([[j for j in train_data[i:i+timesteps]] for i in range(0,len(train_data)-timesteps+1)])[:,:,0]
|
||||
train_data_timesteps.shape
|
||||
```
|
||||
|
||||
```output
|
||||
(1412, 5)
|
||||
```
|
||||
|
||||
Konverter testdata til 2D tensor:
|
||||
|
||||
```python
|
||||
test_data_timesteps=np.array([[j for j in test_data[i:i+timesteps]] for i in range(0,len(test_data)-timesteps+1)])[:,:,0]
|
||||
test_data_timesteps.shape
|
||||
```
|
||||
|
||||
```output
|
||||
(44, 5)
|
||||
```
|
||||
|
||||
Velg input og output fra trenings- og testdata:
|
||||
|
||||
```python
|
||||
x_train, y_train = train_data_timesteps[:,:timesteps-1],train_data_timesteps[:,[timesteps-1]]
|
||||
x_test, y_test = test_data_timesteps[:,:timesteps-1],test_data_timesteps[:,[timesteps-1]]
|
||||
|
||||
print(x_train.shape, y_train.shape)
|
||||
print(x_test.shape, y_test.shape)
|
||||
```
|
||||
|
||||
```output
|
||||
(1412, 4) (1412, 1)
|
||||
(44, 4) (44, 1)
|
||||
```
|
||||
|
||||
### Implementer SVR [^1]
|
||||
|
||||
Nå er det på tide å implementere SVR. For å lese mer om denne implementeringen, kan du referere til [denne dokumentasjonen](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVR.html). For vår implementering følger vi disse stegene:
|
||||
|
||||
1. Definer modellen ved å kalle `SVR()` og sende inn modellens hyperparametere: kernel, gamma, c og epsilon
|
||||
2. Forbered modellen for treningsdataene ved å kalle funksjonen `fit()`
|
||||
3. Lag prediksjoner ved å kalle funksjonen `predict()`
|
||||
|
||||
Nå oppretter vi en SVR-modell. Her bruker vi [RBF-kjernen](https://scikit-learn.org/stable/modules/svm.html#parameters-of-the-rbf-kernel), og setter hyperparameterne gamma, C og epsilon til henholdsvis 0.5, 10 og 0.05.
|
||||
|
||||
```python
|
||||
model = SVR(kernel='rbf',gamma=0.5, C=10, epsilon = 0.05)
|
||||
```
|
||||
|
||||
#### Tren modellen på treningsdata [^1]
|
||||
|
||||
```python
|
||||
model.fit(x_train, y_train[:,0])
|
||||
```
|
||||
|
||||
```output
|
||||
SVR(C=10, cache_size=200, coef0=0.0, degree=3, epsilon=0.05, gamma=0.5,
|
||||
kernel='rbf', max_iter=-1, shrinking=True, tol=0.001, verbose=False)
|
||||
```
|
||||
|
||||
#### Lag modellprediksjoner [^1]
|
||||
|
||||
```python
|
||||
y_train_pred = model.predict(x_train).reshape(-1,1)
|
||||
y_test_pred = model.predict(x_test).reshape(-1,1)
|
||||
|
||||
print(y_train_pred.shape, y_test_pred.shape)
|
||||
```
|
||||
|
||||
```output
|
||||
(1412, 1) (44, 1)
|
||||
```
|
||||
|
||||
Du har bygget din SVR! Nå må vi evaluere den.
|
||||
|
||||
### Evaluer modellen din [^1]
|
||||
|
||||
For evaluering skal vi først skalere dataene tilbake til vår originale skala. Deretter, for å sjekke ytelsen, skal vi plotte den originale og predikerte tidsserien, og også skrive ut MAPE-resultatet.
|
||||
|
||||
Skaler den predikerte og originale outputen:
|
||||
|
||||
```python
|
||||
# Scaling the predictions
|
||||
y_train_pred = scaler.inverse_transform(y_train_pred)
|
||||
y_test_pred = scaler.inverse_transform(y_test_pred)
|
||||
|
||||
print(len(y_train_pred), len(y_test_pred))
|
||||
```
|
||||
|
||||
```python
|
||||
# Scaling the original values
|
||||
y_train = scaler.inverse_transform(y_train)
|
||||
y_test = scaler.inverse_transform(y_test)
|
||||
|
||||
print(len(y_train), len(y_test))
|
||||
```
|
||||
|
||||
#### Sjekk modellens ytelse på trenings- og testdata [^1]
|
||||
|
||||
Vi henter tidsstemplene fra datasettet for å vise på x-aksen i vårt plot. Merk at vi bruker de første ```timesteps-1``` verdiene som input for den første outputen, så tidsstemplene for outputen vil starte etter det.
|
||||
|
||||
```python
|
||||
train_timestamps = energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)].index[timesteps-1:]
|
||||
test_timestamps = energy[test_start_dt:].index[timesteps-1:]
|
||||
|
||||
print(len(train_timestamps), len(test_timestamps))
|
||||
```
|
||||
|
||||
```output
|
||||
1412 44
|
||||
```
|
||||
|
||||
Plot prediksjonene for treningsdata:
|
||||
|
||||
```python
|
||||
plt.figure(figsize=(25,6))
|
||||
plt.plot(train_timestamps, y_train, color = 'red', linewidth=2.0, alpha = 0.6)
|
||||
plt.plot(train_timestamps, y_train_pred, color = 'blue', linewidth=0.8)
|
||||
plt.legend(['Actual','Predicted'])
|
||||
plt.xlabel('Timestamp')
|
||||
plt.title("Training data prediction")
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Skriv ut MAPE for treningsdata
|
||||
|
||||
```python
|
||||
print('MAPE for training data: ', mape(y_train_pred, y_train)*100, '%')
|
||||
```
|
||||
|
||||
```output
|
||||
MAPE for training data: 1.7195710200875551 %
|
||||
```
|
||||
|
||||
Plot prediksjonene for testdata
|
||||
|
||||
```python
|
||||
plt.figure(figsize=(10,3))
|
||||
plt.plot(test_timestamps, y_test, color = 'red', linewidth=2.0, alpha = 0.6)
|
||||
plt.plot(test_timestamps, y_test_pred, color = 'blue', linewidth=0.8)
|
||||
plt.legend(['Actual','Predicted'])
|
||||
plt.xlabel('Timestamp')
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Skriv ut MAPE for testdata
|
||||
|
||||
```python
|
||||
print('MAPE for testing data: ', mape(y_test_pred, y_test)*100, '%')
|
||||
```
|
||||
|
||||
```output
|
||||
MAPE for testing data: 1.2623790187854018 %
|
||||
```
|
||||
|
||||
🏆 Du har et veldig godt resultat på testdatasettet!
|
||||
|
||||
### Sjekk modellens ytelse på hele datasettet [^1]
|
||||
|
||||
```python
|
||||
# Extracting load values as numpy array
|
||||
data = energy.copy().values
|
||||
|
||||
# Scaling
|
||||
data = scaler.transform(data)
|
||||
|
||||
# Transforming to 2D tensor as per model input requirement
|
||||
data_timesteps=np.array([[j for j in data[i:i+timesteps]] for i in range(0,len(data)-timesteps+1)])[:,:,0]
|
||||
print("Tensor shape: ", data_timesteps.shape)
|
||||
|
||||
# Selecting inputs and outputs from data
|
||||
X, Y = data_timesteps[:,:timesteps-1],data_timesteps[:,[timesteps-1]]
|
||||
print("X shape: ", X.shape,"\nY shape: ", Y.shape)
|
||||
```
|
||||
|
||||
```output
|
||||
Tensor shape: (26300, 5)
|
||||
X shape: (26300, 4)
|
||||
Y shape: (26300, 1)
|
||||
```
|
||||
|
||||
```python
|
||||
# Make model predictions
|
||||
Y_pred = model.predict(X).reshape(-1,1)
|
||||
|
||||
# Inverse scale and reshape
|
||||
Y_pred = scaler.inverse_transform(Y_pred)
|
||||
Y = scaler.inverse_transform(Y)
|
||||
```
|
||||
|
||||
```python
|
||||
plt.figure(figsize=(30,8))
|
||||
plt.plot(Y, color = 'red', linewidth=2.0, alpha = 0.6)
|
||||
plt.plot(Y_pred, color = 'blue', linewidth=0.8)
|
||||
plt.legend(['Actual','Predicted'])
|
||||
plt.xlabel('Timestamp')
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
```python
|
||||
print('MAPE: ', mape(Y_pred, Y)*100, '%')
|
||||
```
|
||||
|
||||
```output
|
||||
MAPE: 2.0572089029888656 %
|
||||
```
|
||||
|
||||
🏆 Veldig fine plott som viser en modell med god nøyaktighet. Bra jobbet!
|
||||
|
||||
---
|
||||
|
||||
## 🚀Utfordring
|
||||
|
||||
- Prøv å justere hyperparameterne (gamma, C, epsilon) mens du oppretter modellen og evaluer på dataene for å se hvilke sett med hyperparametere som gir de beste resultatene på testdataene. For å lære mer om disse hyperparameterne, kan du referere til dokumentet [her](https://scikit-learn.org/stable/modules/svm.html#parameters-of-the-rbf-kernel).
|
||||
- Prøv å bruke forskjellige kjernefunksjoner for modellen og analyser deres ytelse på datasettet. Et nyttig dokument kan finnes [her](https://scikit-learn.org/stable/modules/svm.html#kernel-functions).
|
||||
- Prøv å bruke forskjellige verdier for `timesteps` for modellen for å se tilbake og lage prediksjoner.
|
||||
|
||||
## [Quiz etter leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Gjennomgang & Selvstudie
|
||||
|
||||
Denne leksjonen var en introduksjon til bruken av SVR for tidsserieprognoser. For å lese mer om SVR, kan du referere til [denne bloggen](https://www.analyticsvidhya.com/blog/2020/03/support-vector-regression-tutorial-for-machine-learning/). Denne [dokumentasjonen på scikit-learn](https://scikit-learn.org/stable/modules/svm.html) gir en mer omfattende forklaring om SVM generelt, [SVR](https://scikit-learn.org/stable/modules/svm.html#regression) og også andre implementeringsdetaljer som de forskjellige [kjernefunksjonene](https://scikit-learn.org/stable/modules/svm.html#kernel-functions) som kan brukes, og deres parametere.
|
||||
|
||||
## Oppgave
|
||||
|
||||
[En ny SVR-modell](assignment.md)
|
||||
|
||||
## Krediteringer
|
||||
|
||||
[^1]: Teksten, koden og outputen i denne seksjonen ble bidratt av [@AnirbanMukherjeeXD](https://github.com/AnirbanMukherjeeXD)
|
||||
[^2]: Teksten, koden og outputen i denne seksjonen ble hentet fra [ARIMA](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA)
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,27 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "94aa2fc6154252ae30a3f3740299707a",
|
||||
"translation_date": "2025-09-05T21:24:51+00:00",
|
||||
"source_file": "7-TimeSeries/3-SVR/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# En ny SVR-modell
|
||||
|
||||
## Instruksjoner [^1]
|
||||
|
||||
Nå som du har bygget en SVR-modell, bygg en ny med ferske data (prøv en av [disse datasettene fra Duke](http://www2.stat.duke.edu/~mw/ts_data_sets.html)). Kommenter arbeidet ditt i en notebook, visualiser dataene og modellen din, og test nøyaktigheten ved hjelp av passende grafer og MAPE. Prøv også å justere de ulike hyperparameterne og bruke forskjellige verdier for tidsstegene.
|
||||
|
||||
## Vurderingskriterier [^1]
|
||||
|
||||
| Kriterier | Eksemplarisk | Tilfredsstillende | Trenger forbedring |
|
||||
| --------- | ----------------------------------------------------------- | -------------------------------------------------------- | ---------------------------------- |
|
||||
| | En notebook presenteres med en SVR-modell bygget, testet og forklart med visualiseringer og nøyaktighet angitt. | Notebooken som presenteres er ikke kommentert eller inneholder feil. | En ufullstendig notebook presenteres |
|
||||
|
||||
[^1]:Teksten i denne seksjonen er basert på [oppgaven fra ARIMA](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA/assignment.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.
|
||||
@ -0,0 +1,37 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "61342603bad8acadbc6b2e4e3aab3f66",
|
||||
"translation_date": "2025-09-05T21:17:47+00:00",
|
||||
"source_file": "7-TimeSeries/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Introduksjon til tidsserieprognoser
|
||||
|
||||
Hva er tidsserieprognoser? Det handler om å forutsi fremtidige hendelser ved å analysere trender fra fortiden.
|
||||
|
||||
## Regionalt tema: globalt strømforbruk ✨
|
||||
|
||||
I disse to leksjonene vil du bli introdusert til tidsserieprognoser, et noe mindre kjent område innen maskinlæring som likevel er svært verdifullt for industri- og forretningsapplikasjoner, blant andre felt. Selv om nevrale nettverk kan brukes for å forbedre nytten av disse modellene, vil vi studere dem i konteksten av klassisk maskinlæring, ettersom modellene hjelper med å forutsi fremtidig ytelse basert på fortiden.
|
||||
|
||||
Vårt regionale fokus er elektrisk forbruk i verden, et interessant datasett for å lære om å forutsi fremtidig strømforbruk basert på mønstre fra tidligere belastning. Du kan se hvordan denne typen prognoser kan være svært nyttig i en forretningssammenheng.
|
||||
|
||||
|
||||
|
||||
Foto av [Peddi Sai hrithik](https://unsplash.com/@shutter_log?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) av elektriske tårn på en vei i Rajasthan på [Unsplash](https://unsplash.com/s/photos/electric-india?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)
|
||||
|
||||
## Leksjoner
|
||||
|
||||
1. [Introduksjon til tidsserieprognoser](1-Introduction/README.md)
|
||||
2. [Bygge ARIMA-modeller for tidsserier](2-ARIMA/README.md)
|
||||
3. [Bygge Support Vector Regressor for tidsserieprognoser](3-SVR/README.md)
|
||||
|
||||
## Krediteringer
|
||||
|
||||
"Introduksjon til tidsserieprognoser" ble skrevet med ⚡️ av [Francesca Lazzeri](https://twitter.com/frlazzeri) og [Jen Looper](https://twitter.com/jenlooper). Notatbøkene dukket først opp online i [Azure "Deep Learning For Time Series"-repoet](https://github.com/Azure/DeepLearningForTimeSeriesForecasting) opprinnelig skrevet av Francesca Lazzeri. SVR-leksjonen ble skrevet av [Anirban Mukherjee](https://github.com/AnirbanMukherjeeXD)
|
||||
|
||||
---
|
||||
|
||||
**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 automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør 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.
|
||||
@ -0,0 +1,256 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "911efd5e595089000cb3c16fce1beab8",
|
||||
"translation_date": "2025-09-05T22:05:43+00:00",
|
||||
"source_file": "8-Reinforcement/1-QLearning/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Introduksjon til forsterkende læring og Q-Læring
|
||||
|
||||
|
||||
> Sketchnote av [Tomomi Imura](https://www.twitter.com/girlie_mac)
|
||||
|
||||
Forsterkende læring involverer tre viktige konsepter: agenten, noen tilstander, og et sett med handlinger per tilstand. Ved å utføre en handling i en spesifisert tilstand, får agenten en belønning. Tenk igjen på dataspillet Super Mario. Du er Mario, du er i et spillnivå, stående ved kanten av en klippe. Over deg er det en mynt. Du som Mario, i et spillnivå, på en spesifikk posisjon ... det er din tilstand. Å ta et steg til høyre (en handling) vil føre deg over kanten, og det vil gi deg en lav numerisk score. Men å trykke på hopp-knappen vil gi deg et poeng og holde deg i live. Det er et positivt utfall og bør gi deg en positiv numerisk score.
|
||||
|
||||
Ved å bruke forsterkende læring og en simulator (spillet), kan du lære hvordan du spiller spillet for å maksimere belønningen, som er å holde seg i live og score så mange poeng som mulig.
|
||||
|
||||
[](https://www.youtube.com/watch?v=lDq_en8RNOo)
|
||||
|
||||
> 🎥 Klikk på bildet over for å høre Dmitry diskutere forsterkende læring
|
||||
|
||||
## [Quiz før forelesning](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Forutsetninger og oppsett
|
||||
|
||||
I denne leksjonen skal vi eksperimentere med litt kode i Python. Du bør kunne kjøre Jupyter Notebook-koden fra denne leksjonen, enten på din egen datamaskin eller i skyen.
|
||||
|
||||
Du kan åpne [notatboken for leksjonen](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/notebook.ipynb) og gå gjennom denne leksjonen for å bygge.
|
||||
|
||||
> **Merk:** Hvis du åpner denne koden fra skyen, må du også hente filen [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py), som brukes i notatbok-koden. Legg den i samme katalog som notatboken.
|
||||
|
||||
## Introduksjon
|
||||
|
||||
I denne leksjonen skal vi utforske verdenen til **[Peter og ulven](https://en.wikipedia.org/wiki/Peter_and_the_Wolf)**, inspirert av et musikalsk eventyr av den russiske komponisten [Sergei Prokofiev](https://en.wikipedia.org/wiki/Sergei_Prokofiev). Vi skal bruke **forsterkende læring** for å la Peter utforske sitt miljø, samle smakfulle epler og unngå å møte ulven.
|
||||
|
||||
**Forsterkende læring** (RL) er en læringsteknikk som lar oss lære optimal oppførsel for en **agent** i et **miljø** ved å kjøre mange eksperimenter. En agent i dette miljøet bør ha et **mål**, definert av en **belønningsfunksjon**.
|
||||
|
||||
## Miljøet
|
||||
|
||||
For enkelhets skyld, la oss anta at Peters verden er et kvadratisk brett med størrelse `bredde` x `høyde`, som dette:
|
||||
|
||||
|
||||
|
||||
Hver celle i dette brettet kan enten være:
|
||||
|
||||
* **bakke**, som Peter og andre skapninger kan gå på.
|
||||
* **vann**, som man åpenbart ikke kan gå på.
|
||||
* et **tre** eller **gress**, et sted hvor man kan hvile.
|
||||
* et **eple**, som representerer noe Peter vil være glad for å finne for å mate seg selv.
|
||||
* en **ulv**, som er farlig og bør unngås.
|
||||
|
||||
Det finnes et eget Python-modul, [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py), som inneholder koden for å arbeide med dette miljøet. Fordi denne koden ikke er viktig for å forstå konseptene våre, vil vi importere modulen og bruke den til å lage brettet (kodeblokk 1):
|
||||
|
||||
```python
|
||||
from rlboard import *
|
||||
|
||||
width, height = 8,8
|
||||
m = Board(width,height)
|
||||
m.randomize(seed=13)
|
||||
m.plot()
|
||||
```
|
||||
|
||||
Denne koden bør skrive ut et bilde av miljøet som ligner på det ovenfor.
|
||||
|
||||
## Handlinger og strategi
|
||||
|
||||
I vårt eksempel vil Peters mål være å finne et eple, mens han unngår ulven og andre hindringer. For å gjøre dette kan han i hovedsak gå rundt til han finner et eple.
|
||||
|
||||
Derfor kan han på enhver posisjon velge mellom en av følgende handlinger: opp, ned, venstre og høyre.
|
||||
|
||||
Vi vil definere disse handlingene som et ordbok, og knytte dem til par av tilsvarende koordinatendringer. For eksempel vil det å bevege seg til høyre (`R`) tilsvare paret `(1,0)`. (kodeblokk 2):
|
||||
|
||||
```python
|
||||
actions = { "U" : (0,-1), "D" : (0,1), "L" : (-1,0), "R" : (1,0) }
|
||||
action_idx = { a : i for i,a in enumerate(actions.keys()) }
|
||||
```
|
||||
|
||||
For å oppsummere, strategien og målet for dette scenariet er som følger:
|
||||
|
||||
- **Strategien**, for vår agent (Peter) er definert av en såkalt **policy**. En policy er en funksjon som returnerer handlingen i en gitt tilstand. I vårt tilfelle er tilstanden til problemet representert av brettet, inkludert spillerens nåværende posisjon.
|
||||
|
||||
- **Målet**, med forsterkende læring er å til slutt lære en god policy som lar oss løse problemet effektivt. Men som en baseline, la oss vurdere den enkleste policyen kalt **tilfeldig vandring**.
|
||||
|
||||
## Tilfeldig vandring
|
||||
|
||||
La oss først løse problemet vårt ved å implementere en strategi for tilfeldig vandring. Med tilfeldig vandring vil vi tilfeldig velge neste handling fra de tillatte handlingene, til vi når eplet (kodeblokk 3).
|
||||
|
||||
1. Implementer den tilfeldige vandringen med koden nedenfor:
|
||||
|
||||
```python
|
||||
def random_policy(m):
|
||||
return random.choice(list(actions))
|
||||
|
||||
def walk(m,policy,start_position=None):
|
||||
n = 0 # number of steps
|
||||
# set initial position
|
||||
if start_position:
|
||||
m.human = start_position
|
||||
else:
|
||||
m.random_start()
|
||||
while True:
|
||||
if m.at() == Board.Cell.apple:
|
||||
return n # success!
|
||||
if m.at() in [Board.Cell.wolf, Board.Cell.water]:
|
||||
return -1 # eaten by wolf or drowned
|
||||
while True:
|
||||
a = actions[policy(m)]
|
||||
new_pos = m.move_pos(m.human,a)
|
||||
if m.is_valid(new_pos) and m.at(new_pos)!=Board.Cell.water:
|
||||
m.move(a) # do the actual move
|
||||
break
|
||||
n+=1
|
||||
|
||||
walk(m,random_policy)
|
||||
```
|
||||
|
||||
Kallet til `walk` bør returnere lengden på den tilsvarende stien, som kan variere fra en kjøring til en annen.
|
||||
|
||||
1. Kjør vandringseksperimentet et antall ganger (si, 100), og skriv ut de resulterende statistikkene (kodeblokk 4):
|
||||
|
||||
```python
|
||||
def print_statistics(policy):
|
||||
s,w,n = 0,0,0
|
||||
for _ in range(100):
|
||||
z = walk(m,policy)
|
||||
if z<0:
|
||||
w+=1
|
||||
else:
|
||||
s += z
|
||||
n += 1
|
||||
print(f"Average path length = {s/n}, eaten by wolf: {w} times")
|
||||
|
||||
print_statistics(random_policy)
|
||||
```
|
||||
|
||||
Merk at gjennomsnittlig lengde på en sti er rundt 30-40 steg, noe som er ganske mye, gitt at gjennomsnittlig avstand til nærmeste eple er rundt 5-6 steg.
|
||||
|
||||
Du kan også se hvordan Peters bevegelser ser ut under den tilfeldige vandringen:
|
||||
|
||||
|
||||
|
||||
## Belønningsfunksjon
|
||||
|
||||
For å gjøre vår policy mer intelligent, må vi forstå hvilke bevegelser som er "bedre" enn andre. For å gjøre dette må vi definere målet vårt.
|
||||
|
||||
Målet kan defineres i form av en **belønningsfunksjon**, som vil returnere en scoreverdi for hver tilstand. Jo høyere tallet er, jo bedre er belønningsfunksjonen. (kodeblokk 5)
|
||||
|
||||
```python
|
||||
move_reward = -0.1
|
||||
goal_reward = 10
|
||||
end_reward = -10
|
||||
|
||||
def reward(m,pos=None):
|
||||
pos = pos or m.human
|
||||
if not m.is_valid(pos):
|
||||
return end_reward
|
||||
x = m.at(pos)
|
||||
if x==Board.Cell.water or x == Board.Cell.wolf:
|
||||
return end_reward
|
||||
if x==Board.Cell.apple:
|
||||
return goal_reward
|
||||
return move_reward
|
||||
```
|
||||
|
||||
En interessant ting med belønningsfunksjoner er at i de fleste tilfeller *får vi bare en betydelig belønning på slutten av spillet*. Dette betyr at algoritmen vår på en eller annen måte må huske "gode" steg som fører til en positiv belønning til slutt, og øke deres betydning. På samme måte bør alle bevegelser som fører til dårlige resultater avskrekkes.
|
||||
|
||||
## Q-Læring
|
||||
|
||||
En algoritme som vi skal diskutere her kalles **Q-Læring**. I denne algoritmen er policyen definert av en funksjon (eller en datastruktur) kalt en **Q-Tabell**. Den registrerer "godheten" til hver av handlingene i en gitt tilstand.
|
||||
|
||||
Den kalles en Q-Tabell fordi det ofte er praktisk å representere den som en tabell, eller en flerdimensjonal matrise. Siden brettet vårt har dimensjonene `bredde` x `høyde`, kan vi representere Q-Tabellen ved hjelp av en numpy-matrise med formen `bredde` x `høyde` x `len(actions)`: (kodeblokk 6)
|
||||
|
||||
```python
|
||||
Q = np.ones((width,height,len(actions)),dtype=np.float)*1.0/len(actions)
|
||||
```
|
||||
|
||||
Legg merke til at vi initialiserer alle verdiene i Q-Tabellen med en lik verdi, i vårt tilfelle - 0.25. Dette tilsvarer policyen "tilfeldig vandring", fordi alle bevegelser i hver tilstand er like gode. Vi kan sende Q-Tabellen til `plot`-funksjonen for å visualisere tabellen på brettet: `m.plot(Q)`.
|
||||
|
||||
|
||||
|
||||
I midten av hver celle er det en "pil" som indikerer den foretrukne retningen for bevegelse. Siden alle retninger er like, vises en prikk.
|
||||
|
||||
Nå må vi kjøre simuleringen, utforske miljøet vårt, og lære en bedre fordeling av Q-Tabell-verdier, som vil tillate oss å finne veien til eplet mye raskere.
|
||||
|
||||
## Essensen av Q-Læring: Bellman-likningen
|
||||
|
||||
Når vi begynner å bevege oss, vil hver handling ha en tilsvarende belønning, dvs. vi kan teoretisk velge neste handling basert på den høyeste umiddelbare belønningen. Men i de fleste tilstander vil ikke bevegelsen oppnå målet vårt om å nå eplet, og dermed kan vi ikke umiddelbart avgjøre hvilken retning som er bedre.
|
||||
|
||||
> Husk at det ikke er det umiddelbare resultatet som betyr noe, men heller det endelige resultatet, som vi vil oppnå på slutten av simuleringen.
|
||||
|
||||
For å ta hensyn til denne forsinkede belønningen, må vi bruke prinsippene for **[dynamisk programmering](https://en.wikipedia.org/wiki/Dynamic_programming)**, som lar oss tenke på problemet vårt rekursivt.
|
||||
|
||||
Anta at vi nå er i tilstanden *s*, og vi ønsker å bevege oss til neste tilstand *s'*. Ved å gjøre det vil vi motta den umiddelbare belønningen *r(s,a)*, definert av belønningsfunksjonen, pluss en fremtidig belønning. Hvis vi antar at Q-Tabellen vår korrekt reflekterer "attraktiviteten" til hver handling, vil vi i tilstanden *s'* velge en handling *a* som tilsvarer maksimal verdi av *Q(s',a')*. Dermed vil den beste mulige fremtidige belønningen vi kunne få i tilstanden *s* bli definert som `max`
|
||||
|
||||
## Sjekke policyen
|
||||
|
||||
Siden Q-Tabellen viser "attraktiviteten" til hver handling i hver tilstand, er det ganske enkelt å bruke den til å definere effektiv navigering i vår verden. I det enkleste tilfellet kan vi velge handlingen som tilsvarer den høyeste verdien i Q-Tabellen: (kodeblokk 9)
|
||||
|
||||
```python
|
||||
def qpolicy_strict(m):
|
||||
x,y = m.human
|
||||
v = probs(Q[x,y])
|
||||
a = list(actions)[np.argmax(v)]
|
||||
return a
|
||||
|
||||
walk(m,qpolicy_strict)
|
||||
```
|
||||
|
||||
> Hvis du prøver koden ovenfor flere ganger, kan du legge merke til at den noen ganger "henger", og du må trykke på STOP-knappen i notatboken for å avbryte den. Dette skjer fordi det kan oppstå situasjoner der to tilstander "peker" på hverandre når det gjelder optimal Q-verdi, i så fall ender agenten opp med å bevege seg mellom disse tilstandene uendelig.
|
||||
|
||||
## 🚀Utfordring
|
||||
|
||||
> **Oppgave 1:** Endre `walk`-funksjonen slik at den begrenser maksimal lengde på stien til et visst antall steg (for eksempel 100), og se koden ovenfor returnere denne verdien fra tid til annen.
|
||||
|
||||
> **Oppgave 2:** Endre `walk`-funksjonen slik at den ikke går tilbake til steder den allerede har vært tidligere. Dette vil forhindre at `walk` går i loop, men agenten kan fortsatt ende opp med å bli "fanget" på et sted den ikke kan unnslippe fra.
|
||||
|
||||
## Navigering
|
||||
|
||||
En bedre navigeringspolicy ville være den vi brukte under trening, som kombinerer utnyttelse og utforskning. I denne policyen vil vi velge hver handling med en viss sannsynlighet, proporsjonal med verdiene i Q-Tabellen. Denne strategien kan fortsatt føre til at agenten returnerer til en posisjon den allerede har utforsket, men som du kan se fra koden nedenfor, resulterer den i en veldig kort gjennomsnittlig sti til ønsket lokasjon (husk at `print_statistics` kjører simuleringen 100 ganger): (kodeblokk 10)
|
||||
|
||||
```python
|
||||
def qpolicy(m):
|
||||
x,y = m.human
|
||||
v = probs(Q[x,y])
|
||||
a = random.choices(list(actions),weights=v)[0]
|
||||
return a
|
||||
|
||||
print_statistics(qpolicy)
|
||||
```
|
||||
|
||||
Etter å ha kjørt denne koden, bør du få en mye kortere gjennomsnittlig stilengde enn før, i området 3-6.
|
||||
|
||||
## Undersøke læringsprosessen
|
||||
|
||||
Som vi har nevnt, er læringsprosessen en balanse mellom utforskning og utnyttelse av opparbeidet kunnskap om problemrommets struktur. Vi har sett at resultatene av læringen (evnen til å hjelpe en agent med å finne en kort sti til målet) har forbedret seg, men det er også interessant å observere hvordan gjennomsnittlig stilengde oppfører seg under læringsprosessen:
|
||||
|
||||
## Oppsummering av læringen:
|
||||
|
||||
- **Gjennomsnittlig stilengde øker**. Det vi ser her er at i starten øker gjennomsnittlig stilengde. Dette skyldes sannsynligvis at når vi ikke vet noe om miljøet, er vi mer sannsynlig å bli fanget i dårlige tilstander, som vann eller ulv. Etter hvert som vi lærer mer og begynner å bruke denne kunnskapen, kan vi utforske miljøet lenger, men vi vet fortsatt ikke veldig godt hvor eplene er.
|
||||
|
||||
- **Stilengden avtar etter hvert som vi lærer mer**. Når vi har lært nok, blir det lettere for agenten å nå målet, og stilengden begynner å avta. Vi er imidlertid fortsatt åpne for utforskning, så vi avviker ofte fra den beste stien og utforsker nye alternativer, noe som gjør stien lengre enn optimal.
|
||||
|
||||
- **Lengden øker brått**. Det vi også observerer på denne grafen er at på et tidspunkt økte lengden brått. Dette indikerer den stokastiske naturen til prosessen, og at vi på et tidspunkt kan "ødelegge" Q-Tabell-koeffisientene ved å overskrive dem med nye verdier. Dette bør ideelt sett minimeres ved å redusere læringsraten (for eksempel mot slutten av treningen justerer vi Q-Tabell-verdiene med en liten verdi).
|
||||
|
||||
Alt i alt er det viktig å huske at suksessen og kvaliteten på læringsprosessen avhenger betydelig av parametere, som læringsrate, læringsrate-avtakelse og diskonteringsfaktor. Disse kalles ofte **hyperparametere**, for å skille dem fra **parametere**, som vi optimaliserer under trening (for eksempel Q-Tabell-koeffisienter). Prosessen med å finne de beste verdiene for hyperparametere kalles **hyperparameteroptimalisering**, og det fortjener et eget tema.
|
||||
|
||||
## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Oppgave
|
||||
[En mer realistisk verden](assignment.md)
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,41 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "68394b2102d3503882e5e914bd0ff5c1",
|
||||
"translation_date": "2025-09-05T22:07:28+00:00",
|
||||
"source_file": "8-Reinforcement/1-QLearning/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# En Mer Realistisk Verden
|
||||
|
||||
I vår situasjon kunne Peter bevege seg rundt nesten uten å bli sliten eller sulten. I en mer realistisk verden må han sette seg ned og hvile fra tid til annen, og også spise for å holde seg i live. La oss gjøre vår verden mer realistisk ved å implementere følgende regler:
|
||||
|
||||
1. Ved å bevege seg fra ett sted til et annet, mister Peter **energi** og får noe **utmattelse**.
|
||||
2. Peter kan få mer energi ved å spise epler.
|
||||
3. Peter kan kvitte seg med utmattelse ved å hvile under et tre eller på gresset (dvs. gå til en plass på brettet med et tre eller gress - grønt felt).
|
||||
4. Peter må finne og drepe ulven.
|
||||
5. For å drepe ulven må Peter ha visse nivåer av energi og utmattelse, ellers taper han kampen.
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
Bruk den originale [notebook.ipynb](../../../../8-Reinforcement/1-QLearning/notebook.ipynb)-notatboken som utgangspunkt for løsningen din.
|
||||
|
||||
Modifiser belønningsfunksjonen ovenfor i henhold til spillreglene, kjør forsterkningslæringsalgoritmen for å lære den beste strategien for å vinne spillet, og sammenlign resultatene av tilfeldig vandring med algoritmen din når det gjelder antall spill vunnet og tapt.
|
||||
|
||||
> **Note**: I din nye verden er tilstanden mer kompleks, og inkluderer i tillegg til menneskets posisjon også nivåer av utmattelse og energi. Du kan velge å representere tilstanden som en tuple (Brett, energi, utmattelse), eller definere en klasse for tilstanden (du kan også velge å avlede den fra `Board`), eller til og med modifisere den originale `Board`-klassen i [rlboard.py](../../../../8-Reinforcement/1-QLearning/rlboard.py).
|
||||
|
||||
I løsningen din, vennligst behold koden som er ansvarlig for strategien med tilfeldig vandring, og sammenlign resultatene av algoritmen din med tilfeldig vandring til slutt.
|
||||
|
||||
> **Note**: Du kan trenge å justere hyperparametere for å få det til å fungere, spesielt antall epoker. Fordi suksessen i spillet (å bekjempe ulven) er en sjelden hendelse, kan du forvente mye lengre treningstid.
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Fremragende | Tilfredsstillende | Trenger Forbedring |
|
||||
| --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
|
||||
| | En notatbok presenteres med definisjonen av nye verdensregler, Q-Learning-algoritme og noen tekstlige forklaringer. Q-Learning er i stand til å forbedre resultatene betydelig sammenlignet med tilfeldig vandring. | Notatbok presenteres, Q-Learning er implementert og forbedrer resultatene sammenlignet med tilfeldig vandring, men ikke betydelig; eller notatboken er dårlig dokumentert og koden er ikke godt strukturert | Noen forsøk på å redefinere verdensreglene er gjort, men Q-Learning-algoritmen fungerer ikke, eller belønningsfunksjonen er ikke fullt definert |
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
|
||||
"translation_date": "2025-09-05T22:07:59+00:00",
|
||||
"source_file": "8-Reinforcement/1-QLearning/solution/Julia/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
|
||||
"translation_date": "2025-09-05T22:07:50+00:00",
|
||||
"source_file": "8-Reinforcement/1-QLearning/solution/R/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,333 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "107d5bb29da8a562e7ae72262d251a75",
|
||||
"translation_date": "2025-09-05T22:09:29+00:00",
|
||||
"source_file": "8-Reinforcement/2-Gym/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
## Forutsetninger
|
||||
|
||||
I denne leksjonen skal vi bruke et bibliotek kalt **OpenAI Gym** for å simulere ulike **miljøer**. Du kan kjøre koden fra denne leksjonen lokalt (f.eks. fra Visual Studio Code), i så fall vil simuleringen åpne seg i et nytt vindu. Når du kjører koden online, kan det være nødvendig å gjøre noen justeringer i koden, som beskrevet [her](https://towardsdatascience.com/rendering-openai-gym-envs-on-binder-and-google-colab-536f99391cc7).
|
||||
|
||||
## OpenAI Gym
|
||||
|
||||
I den forrige leksjonen ble reglene for spillet og tilstanden definert av klassen `Board`, som vi laget selv. Her skal vi bruke et spesielt **simuleringsmiljø** som simulerer fysikken bak den balanserende stangen. Et av de mest populære simuleringsmiljøene for trening av forsterkningslæringsalgoritmer kalles [Gym](https://gym.openai.com/), som vedlikeholdes av [OpenAI](https://openai.com/). Ved å bruke dette gymmet kan vi lage ulike **miljøer**, fra en CartPole-simulering til Atari-spill.
|
||||
|
||||
> **Merk**: Du kan se andre tilgjengelige miljøer fra OpenAI Gym [her](https://gym.openai.com/envs/#classic_control).
|
||||
|
||||
Først, la oss installere gym og importere nødvendige biblioteker (kodeblokk 1):
|
||||
|
||||
```python
|
||||
import sys
|
||||
!{sys.executable} -m pip install gym
|
||||
|
||||
import gym
|
||||
import matplotlib.pyplot as plt
|
||||
import numpy as np
|
||||
import random
|
||||
```
|
||||
|
||||
## Oppgave - initialiser et CartPole-miljø
|
||||
|
||||
For å jobbe med et CartPole-balanseringsproblem må vi initialisere det tilsvarende miljøet. Hvert miljø er knyttet til:
|
||||
|
||||
- **Observasjonsrom** som definerer strukturen til informasjonen vi mottar fra miljøet. For CartPole-problemet mottar vi posisjonen til stangen, hastighet og noen andre verdier.
|
||||
|
||||
- **Handlingsrom** som definerer mulige handlinger. I vårt tilfelle er handlingsrommet diskret og består av to handlinger - **venstre** og **høyre**. (kodeblokk 2)
|
||||
|
||||
1. For å initialisere, skriv følgende kode:
|
||||
|
||||
```python
|
||||
env = gym.make("CartPole-v1")
|
||||
print(env.action_space)
|
||||
print(env.observation_space)
|
||||
print(env.action_space.sample())
|
||||
```
|
||||
|
||||
For å se hvordan miljøet fungerer, la oss kjøre en kort simulering i 100 steg. Ved hvert steg gir vi en av handlingene som skal utføres - i denne simuleringen velger vi bare tilfeldig en handling fra `action_space`.
|
||||
|
||||
1. Kjør koden nedenfor og se hva det fører til.
|
||||
|
||||
✅ Husk at det er foretrukket å kjøre denne koden på en lokal Python-installasjon! (kodeblokk 3)
|
||||
|
||||
```python
|
||||
env.reset()
|
||||
|
||||
for i in range(100):
|
||||
env.render()
|
||||
env.step(env.action_space.sample())
|
||||
env.close()
|
||||
```
|
||||
|
||||
Du bør se noe som ligner på dette bildet:
|
||||
|
||||
|
||||
|
||||
1. Under simuleringen må vi få observasjoner for å avgjøre hvordan vi skal handle. Faktisk returnerer step-funksjonen nåværende observasjoner, en belønningsfunksjon og en flagg som indikerer om det gir mening å fortsette simuleringen eller ikke: (kodeblokk 4)
|
||||
|
||||
```python
|
||||
env.reset()
|
||||
|
||||
done = False
|
||||
while not done:
|
||||
env.render()
|
||||
obs, rew, done, info = env.step(env.action_space.sample())
|
||||
print(f"{obs} -> {rew}")
|
||||
env.close()
|
||||
```
|
||||
|
||||
Du vil ende opp med å se noe som dette i notebook-utgangen:
|
||||
|
||||
```text
|
||||
[ 0.03403272 -0.24301182 0.02669811 0.2895829 ] -> 1.0
|
||||
[ 0.02917248 -0.04828055 0.03248977 0.00543839] -> 1.0
|
||||
[ 0.02820687 0.14636075 0.03259854 -0.27681916] -> 1.0
|
||||
[ 0.03113408 0.34100283 0.02706215 -0.55904489] -> 1.0
|
||||
[ 0.03795414 0.53573468 0.01588125 -0.84308041] -> 1.0
|
||||
...
|
||||
[ 0.17299878 0.15868546 -0.20754175 -0.55975453] -> 1.0
|
||||
[ 0.17617249 0.35602306 -0.21873684 -0.90998894] -> 1.0
|
||||
```
|
||||
|
||||
Observasjonsvektoren som returneres ved hvert steg av simuleringen inneholder følgende verdier:
|
||||
- Posisjon til vognen
|
||||
- Hastighet til vognen
|
||||
- Vinkel til stangen
|
||||
- Rotasjonshastighet til stangen
|
||||
|
||||
1. Finn minimums- og maksimumsverdien av disse tallene: (kodeblokk 5)
|
||||
|
||||
```python
|
||||
print(env.observation_space.low)
|
||||
print(env.observation_space.high)
|
||||
```
|
||||
|
||||
Du vil også legge merke til at belønningsverdien ved hvert simuleringssteg alltid er 1. Dette er fordi målet vårt er å overleve så lenge som mulig, dvs. holde stangen i en rimelig vertikal posisjon i lengst mulig tid.
|
||||
|
||||
✅ Faktisk anses CartPole-simuleringen som løst hvis vi klarer å oppnå en gjennomsnittlig belønning på 195 over 100 påfølgende forsøk.
|
||||
|
||||
## Diskretisering av tilstand
|
||||
|
||||
I Q-Læring må vi bygge en Q-Tabell som definerer hva vi skal gjøre i hver tilstand. For å kunne gjøre dette må tilstanden være **diskret**, mer presist, den bør inneholde et begrenset antall diskrete verdier. Dermed må vi på en eller annen måte **diskretisere** observasjonene våre, og kartlegge dem til et begrenset sett med tilstander.
|
||||
|
||||
Det finnes noen måter vi kan gjøre dette på:
|
||||
|
||||
- **Del inn i intervaller**. Hvis vi kjenner intervallet til en viss verdi, kan vi dele dette intervallet inn i et antall **intervaller**, og deretter erstatte verdien med nummeret på intervallet den tilhører. Dette kan gjøres ved hjelp av numpy-metoden [`digitize`](https://numpy.org/doc/stable/reference/generated/numpy.digitize.html). I dette tilfellet vil vi nøyaktig vite størrelsen på tilstanden, fordi den vil avhenge av antall intervaller vi velger for digitalisering.
|
||||
|
||||
✅ Vi kan bruke lineær interpolasjon for å bringe verdier til et begrenset intervall (for eksempel fra -20 til 20), og deretter konvertere tallene til heltall ved å runde dem av. Dette gir oss litt mindre kontroll over størrelsen på tilstanden, spesielt hvis vi ikke kjenner de nøyaktige grensene for inngangsverdiene. For eksempel, i vårt tilfelle har 2 av 4 verdier ikke øvre/nedre grenser for verdiene sine, noe som kan resultere i et uendelig antall tilstander.
|
||||
|
||||
I vårt eksempel vil vi gå for den andre tilnærmingen. Som du kanskje legger merke til senere, til tross for udefinerte øvre/nedre grenser, tar disse verdiene sjelden verdier utenfor visse begrensede intervaller, og dermed vil tilstander med ekstreme verdier være svært sjeldne.
|
||||
|
||||
1. Her er funksjonen som vil ta observasjonen fra modellen vår og produsere en tuple med 4 heltallsverdier: (kodeblokk 6)
|
||||
|
||||
```python
|
||||
def discretize(x):
|
||||
return tuple((x/np.array([0.25, 0.25, 0.01, 0.1])).astype(np.int))
|
||||
```
|
||||
|
||||
1. La oss også utforske en annen diskretiseringsmetode ved bruk av intervaller: (kodeblokk 7)
|
||||
|
||||
```python
|
||||
def create_bins(i,num):
|
||||
return np.arange(num+1)*(i[1]-i[0])/num+i[0]
|
||||
|
||||
print("Sample bins for interval (-5,5) with 10 bins\n",create_bins((-5,5),10))
|
||||
|
||||
ints = [(-5,5),(-2,2),(-0.5,0.5),(-2,2)] # intervals of values for each parameter
|
||||
nbins = [20,20,10,10] # number of bins for each parameter
|
||||
bins = [create_bins(ints[i],nbins[i]) for i in range(4)]
|
||||
|
||||
def discretize_bins(x):
|
||||
return tuple(np.digitize(x[i],bins[i]) for i in range(4))
|
||||
```
|
||||
|
||||
1. La oss nå kjøre en kort simulering og observere disse diskrete miljøverdiene. Prøv gjerne både `discretize` og `discretize_bins` og se om det er noen forskjell.
|
||||
|
||||
✅ `discretize_bins` returnerer nummeret på intervallet, som er 0-basert. Dermed returnerer den for verdier av inngangsvariabelen rundt 0 nummeret fra midten av intervallet (10). I `discretize` brydde vi oss ikke om området for utgangsverdiene, og tillot dem å være negative, slik at tilstandsverdiene ikke er forskjøvet, og 0 tilsvarer 0. (kodeblokk 8)
|
||||
|
||||
```python
|
||||
env.reset()
|
||||
|
||||
done = False
|
||||
while not done:
|
||||
#env.render()
|
||||
obs, rew, done, info = env.step(env.action_space.sample())
|
||||
#print(discretize_bins(obs))
|
||||
print(discretize(obs))
|
||||
env.close()
|
||||
```
|
||||
|
||||
✅ Fjern kommentaren på linjen som starter med `env.render` hvis du vil se hvordan miljøet utføres. Ellers kan du utføre det i bakgrunnen, som er raskere. Vi vil bruke denne "usynlige" utførelsen under vår Q-Læringsprosess.
|
||||
|
||||
## Strukturen til Q-Tabellen
|
||||
|
||||
I vår forrige leksjon var tilstanden et enkelt par med tall fra 0 til 8, og dermed var det praktisk å representere Q-Tabellen med en numpy-tensor med formen 8x8x2. Hvis vi bruker intervall-diskretisering, er størrelsen på tilstandsvektoren vår også kjent, så vi kan bruke samme tilnærming og representere tilstanden med en array med formen 20x20x10x10x2 (her er 2 dimensjonen til handlingsrommet, og de første dimensjonene tilsvarer antall intervaller vi har valgt å bruke for hver av parameterne i observasjonsrommet).
|
||||
|
||||
Imidlertid er det noen ganger ikke kjent de nøyaktige dimensjonene til observasjonsrommet. I tilfelle av funksjonen `discretize`, kan vi aldri være sikre på at tilstanden vår holder seg innenfor visse grenser, fordi noen av de opprinnelige verdiene ikke er begrenset. Dermed vil vi bruke en litt annen tilnærming og representere Q-Tabellen med en ordbok.
|
||||
|
||||
1. Bruk paret *(state,action)* som nøkkelen i ordboken, og verdien vil tilsvare verdien i Q-Tabellen. (kodeblokk 9)
|
||||
|
||||
```python
|
||||
Q = {}
|
||||
actions = (0,1)
|
||||
|
||||
def qvalues(state):
|
||||
return [Q.get((state,a),0) for a in actions]
|
||||
```
|
||||
|
||||
Her definerer vi også en funksjon `qvalues()`, som returnerer en liste med verdier fra Q-Tabellen for en gitt tilstand som tilsvarer alle mulige handlinger. Hvis oppføringen ikke er til stede i Q-Tabellen, vil vi returnere 0 som standard.
|
||||
|
||||
## La oss starte Q-Læring
|
||||
|
||||
Nå er vi klare til å lære Peter å balansere!
|
||||
|
||||
1. Først, la oss sette noen hyperparametere: (kodeblokk 10)
|
||||
|
||||
```python
|
||||
# hyperparameters
|
||||
alpha = 0.3
|
||||
gamma = 0.9
|
||||
epsilon = 0.90
|
||||
```
|
||||
|
||||
Her er `alpha` **læringsraten** som definerer i hvilken grad vi skal justere de nåværende verdiene i Q-Tabellen ved hvert steg. I den forrige leksjonen startet vi med 1, og deretter reduserte vi `alpha` til lavere verdier under treningen. I dette eksemplet vil vi holde den konstant bare for enkelhets skyld, og du kan eksperimentere med å justere `alpha`-verdiene senere.
|
||||
|
||||
`gamma` er **diskonteringsfaktoren** som viser i hvilken grad vi skal prioritere fremtidig belønning over nåværende belønning.
|
||||
|
||||
`epsilon` er **utforsknings-/utnyttelsesfaktoren** som avgjør om vi skal foretrekke utforskning fremfor utnyttelse eller omvendt. I algoritmen vår vil vi i `epsilon` prosent av tilfellene velge neste handling i henhold til verdiene i Q-Tabellen, og i de resterende tilfellene vil vi utføre en tilfeldig handling. Dette vil tillate oss å utforske områder av søkeområdet som vi aldri har sett før.
|
||||
|
||||
✅ Når det gjelder balansering - å velge en tilfeldig handling (utforskning) vil fungere som et tilfeldig dytt i feil retning, og stangen må lære seg å gjenopprette balansen fra disse "feilene".
|
||||
|
||||
### Forbedre algoritmen
|
||||
|
||||
Vi kan også gjøre to forbedringer i algoritmen vår fra forrige leksjon:
|
||||
|
||||
- **Beregn gjennomsnittlig kumulativ belønning** over et antall simuleringer. Vi vil skrive ut fremgangen hver 5000 iterasjoner, og vi vil beregne gjennomsnittet av vår kumulative belønning over den perioden. Det betyr at hvis vi får mer enn 195 poeng - kan vi anse problemet som løst, med enda høyere kvalitet enn nødvendig.
|
||||
|
||||
- **Beregn maksimal gjennomsnittlig kumulativ belønning**, `Qmax`, og vi vil lagre Q-Tabellen som tilsvarer det resultatet. Når du kjører treningen, vil du legge merke til at noen ganger begynner den gjennomsnittlige kumulative belønningen å synke, og vi ønsker å beholde verdiene i Q-Tabellen som tilsvarer den beste modellen observert under treningen.
|
||||
|
||||
1. Samle alle kumulative belønninger ved hver simulering i `rewards`-vektoren for videre plotting. (kodeblokk 11)
|
||||
|
||||
```python
|
||||
def probs(v,eps=1e-4):
|
||||
v = v-v.min()+eps
|
||||
v = v/v.sum()
|
||||
return v
|
||||
|
||||
Qmax = 0
|
||||
cum_rewards = []
|
||||
rewards = []
|
||||
for epoch in range(100000):
|
||||
obs = env.reset()
|
||||
done = False
|
||||
cum_reward=0
|
||||
# == do the simulation ==
|
||||
while not done:
|
||||
s = discretize(obs)
|
||||
if random.random()<epsilon:
|
||||
# exploitation - chose the action according to Q-Table probabilities
|
||||
v = probs(np.array(qvalues(s)))
|
||||
a = random.choices(actions,weights=v)[0]
|
||||
else:
|
||||
# exploration - randomly chose the action
|
||||
a = np.random.randint(env.action_space.n)
|
||||
|
||||
obs, rew, done, info = env.step(a)
|
||||
cum_reward+=rew
|
||||
ns = discretize(obs)
|
||||
Q[(s,a)] = (1 - alpha) * Q.get((s,a),0) + alpha * (rew + gamma * max(qvalues(ns)))
|
||||
cum_rewards.append(cum_reward)
|
||||
rewards.append(cum_reward)
|
||||
# == Periodically print results and calculate average reward ==
|
||||
if epoch%5000==0:
|
||||
print(f"{epoch}: {np.average(cum_rewards)}, alpha={alpha}, epsilon={epsilon}")
|
||||
if np.average(cum_rewards) > Qmax:
|
||||
Qmax = np.average(cum_rewards)
|
||||
Qbest = Q
|
||||
cum_rewards=[]
|
||||
```
|
||||
|
||||
Hva du kan legge merke til fra disse resultatene:
|
||||
|
||||
- **Nær målet vårt**. Vi er veldig nær å oppnå målet om å få 195 kumulative belønninger over 100+ påfølgende simuleringer, eller vi kan faktisk ha oppnådd det! Selv om vi får mindre tall, vet vi fortsatt ikke, fordi vi beregner gjennomsnittet over 5000 kjøringer, og bare 100 kjøringer er nødvendig i de formelle kriteriene.
|
||||
|
||||
- **Belønningen begynner å synke**. Noen ganger begynner belønningen å synke, noe som betyr at vi kan "ødelegge" allerede lærte verdier i Q-Tabellen med de som gjør situasjonen verre.
|
||||
|
||||
Denne observasjonen er mer tydelig synlig hvis vi plotter treningsfremgangen.
|
||||
|
||||
## Plotting av treningsfremgang
|
||||
|
||||
Under treningen har vi samlet den kumulative belønningsverdien ved hver iterasjon i `rewards`-vektoren. Slik ser det ut når vi plotter det mot iterasjonsnummeret:
|
||||
|
||||
```python
|
||||
plt.plot(rewards)
|
||||
```
|
||||
|
||||
|
||||
|
||||
Fra denne grafen er det ikke mulig å si noe, fordi på grunn av den stokastiske treningsprosessen varierer lengden på treningsøktene sterkt. For å gi mer mening til denne grafen kan vi beregne **glidende gjennomsnitt** over en serie eksperimenter, la oss si 100. Dette kan gjøres praktisk ved hjelp av `np.convolve`: (kodeblokk 12)
|
||||
|
||||
```python
|
||||
def running_average(x,window):
|
||||
return np.convolve(x,np.ones(window)/window,mode='valid')
|
||||
|
||||
plt.plot(running_average(rewards,100))
|
||||
```
|
||||
|
||||
|
||||
|
||||
## Variasjon av hyperparametere
|
||||
|
||||
For å gjøre læringen mer stabil gir det mening å justere noen av hyperparameterne våre under treningen. Spesielt:
|
||||
|
||||
- **For læringsraten**, `alpha`, kan vi starte med verdier nær 1, og deretter fortsette å redusere parameteren. Med tiden vil vi få gode sannsynlighetsverdier i Q-Tabellen, og dermed bør vi justere dem litt, og ikke overskrive dem helt med nye verdier.
|
||||
|
||||
- **Øk epsilon**. Vi kan ønske å øke `epsilon` sakte, for å utforske mindre og utnytte mer. Det gir sannsynligvis mening å starte med en lav verdi av `epsilon`, og bevege seg opp mot nesten 1.
|
||||
> **Oppgave 1**: Prøv deg frem med verdier for hyperparametere og se om du kan oppnå høyere kumulativ belønning. Får du over 195?
|
||||
> **Oppgave 2**: For å løse problemet formelt, må du oppnå en gjennomsnittlig belønning på 195 over 100 sammenhengende kjøringer. Mål dette under treningen og sørg for at du har løst problemet formelt!
|
||||
|
||||
## Se resultatet i praksis
|
||||
|
||||
Det kan være interessant å faktisk se hvordan den trente modellen oppfører seg. La oss kjøre simuleringen og følge samme strategi for valg av handlinger som under treningen, ved å prøve ut fra sannsynlighetsfordelingen i Q-Tabellen: (kodeblokk 13)
|
||||
|
||||
```python
|
||||
obs = env.reset()
|
||||
done = False
|
||||
while not done:
|
||||
s = discretize(obs)
|
||||
env.render()
|
||||
v = probs(np.array(qvalues(s)))
|
||||
a = random.choices(actions,weights=v)[0]
|
||||
obs,_,done,_ = env.step(a)
|
||||
env.close()
|
||||
```
|
||||
|
||||
Du bør se noe som dette:
|
||||
|
||||
|
||||
|
||||
---
|
||||
|
||||
## 🚀Utfordring
|
||||
|
||||
> **Oppgave 3**: Her brukte vi den endelige kopien av Q-Tabellen, som kanskje ikke er den beste. Husk at vi har lagret den best-presterende Q-Tabellen i variabelen `Qbest`! Prøv det samme eksempelet med den best-presterende Q-Tabellen ved å kopiere `Qbest` over til `Q` og se om du merker noen forskjell.
|
||||
|
||||
> **Oppgave 4**: Her valgte vi ikke den beste handlingen på hvert steg, men prøvde heller ut fra den tilsvarende sannsynlighetsfordelingen. Ville det gi mer mening å alltid velge den beste handlingen, med den høyeste verdien i Q-Tabellen? Dette kan gjøres ved å bruke funksjonen `np.argmax` for å finne handlingsnummeret som tilsvarer den høyeste verdien i Q-Tabellen. Implementer denne strategien og se om det forbedrer balansen.
|
||||
|
||||
## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Oppgave
|
||||
[Tren en Mountain Car](assignment.md)
|
||||
|
||||
## Konklusjon
|
||||
|
||||
Vi har nå lært hvordan vi kan trene agenter til å oppnå gode resultater bare ved å gi dem en belønningsfunksjon som definerer ønsket tilstand i spillet, og ved å gi dem muligheten til å utforske søkeområdet intelligent. Vi har med suksess anvendt Q-Learning-algoritmen i tilfeller med diskrete og kontinuerlige miljøer, men med diskrete handlinger.
|
||||
|
||||
Det er også viktig å studere situasjoner der handlingsrommet også er kontinuerlig, og når observasjonsrommet er mye mer komplekst, som bildet fra skjermen i et Atari-spill. I slike problemer trenger vi ofte å bruke mer kraftige maskinlæringsteknikker, som nevrale nettverk, for å oppnå gode resultater. Disse mer avanserte temaene er emnet for vårt kommende mer avanserte AI-kurs.
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,55 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "1f2b7441745eb52e25745423b247016b",
|
||||
"translation_date": "2025-09-05T22:11:06+00:00",
|
||||
"source_file": "8-Reinforcement/2-Gym/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Tren Mountain Car
|
||||
|
||||
[OpenAI Gym](http://gym.openai.com) er designet slik at alle miljøer tilbyr samme API - altså de samme metodene `reset`, `step` og `render`, og de samme abstraksjonene for **handlingsrom** og **observasjonsrom**. Derfor bør det være mulig å tilpasse de samme forsterkningslæringsalgoritmene til forskjellige miljøer med minimale kodeendringer.
|
||||
|
||||
## Et Mountain Car-miljø
|
||||
|
||||
[Mountain Car-miljøet](https://gym.openai.com/envs/MountainCar-v0/) inneholder en bil som sitter fast i en dal:
|
||||
|
||||
Målet er å komme seg ut av dalen og fange flagget, ved å utføre en av følgende handlinger på hvert steg:
|
||||
|
||||
| Verdi | Betydning |
|
||||
|---|---|
|
||||
| 0 | Akselerer til venstre |
|
||||
| 1 | Ikke akselerer |
|
||||
| 2 | Akselerer til høyre |
|
||||
|
||||
Hovedutfordringen i dette problemet er imidlertid at bilens motor ikke er sterk nok til å klatre opp fjellet i én enkelt passering. Derfor er den eneste måten å lykkes på å kjøre frem og tilbake for å bygge opp nok moment.
|
||||
|
||||
Observasjonsrommet består kun av to verdier:
|
||||
|
||||
| Nr | Observasjon | Min | Maks |
|
||||
|-----|--------------|-----|-----|
|
||||
| 0 | Bilens posisjon | -1.2| 0.6 |
|
||||
| 1 | Bilens hastighet | -0.07 | 0.07 |
|
||||
|
||||
Belønningssystemet for Mountain Car er ganske utfordrende:
|
||||
|
||||
* En belønning på 0 gis hvis agenten når flagget (posisjon = 0.5) på toppen av fjellet.
|
||||
* En belønning på -1 gis hvis agentens posisjon er mindre enn 0.5.
|
||||
|
||||
Episoden avsluttes hvis bilens posisjon er mer enn 0.5, eller hvis episodens lengde overstiger 200.
|
||||
## Instruksjoner
|
||||
|
||||
Tilpass vår forsterkningslæringsalgoritme for å løse Mountain Car-problemet. Start med eksisterende [notebook.ipynb](../../../../8-Reinforcement/2-Gym/notebook.ipynb)-kode, bytt ut miljøet, endre funksjonene for diskretisering av tilstander, og prøv å få den eksisterende algoritmen til å trene med minimale kodeendringer. Optimaliser resultatet ved å justere hyperparametere.
|
||||
|
||||
> **Merk**: Justering av hyperparametere vil sannsynligvis være nødvendig for at algoritmen skal konvergere.
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Eksemplarisk | Tilfredsstillende | Trenger forbedring |
|
||||
| -------- | --------- | -------- | ----------------- |
|
||||
| | Q-Learning-algoritmen er vellykket tilpasset fra CartPole-eksempelet, med minimale kodeendringer, og er i stand til å løse problemet med å fange flagget på under 200 steg. | En ny Q-Learning-algoritme er hentet fra Internett, men er godt dokumentert; eller eksisterende algoritme er tilpasset, men oppnår ikke ønskede resultater | Studenten klarte ikke å tilpasse noen algoritme vellykket, men har gjort betydelige fremskritt mot løsningen (implementert tilstands-diskretisering, Q-Tabell datastruktur, osv.) |
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
|
||||
"translation_date": "2025-09-05T22:11:33+00:00",
|
||||
"source_file": "8-Reinforcement/2-Gym/solution/Julia/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,15 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
|
||||
"translation_date": "2025-09-05T22:11:24+00:00",
|
||||
"source_file": "8-Reinforcement/2-Gym/solution/R/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,67 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "20ca019012b1725de956681d036d8b18",
|
||||
"translation_date": "2025-09-05T22:01:42+00:00",
|
||||
"source_file": "8-Reinforcement/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Introduksjon til forsterkende læring
|
||||
|
||||
Forsterkende læring, RL, regnes som en av de grunnleggende paradigmer innen maskinlæring, ved siden av veiledet læring og uveiledet læring. RL handler om beslutninger: å ta riktige beslutninger eller i det minste lære av dem.
|
||||
|
||||
Tenk deg at du har et simulert miljø, som aksjemarkedet. Hva skjer hvis du innfører en gitt regulering? Har det en positiv eller negativ effekt? Hvis noe negativt skjer, må du ta denne _negative forsterkningen_, lære av den og endre kurs. Hvis det er et positivt utfall, må du bygge videre på den _positive forsterkningen_.
|
||||
|
||||
|
||||
|
||||
> Peter og vennene hans må unnslippe den sultne ulven! Bilde av [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
## Regionalt tema: Peter og ulven (Russland)
|
||||
|
||||
[Peter og ulven](https://en.wikipedia.org/wiki/Peter_and_the_Wolf) er et musikalsk eventyr skrevet av den russiske komponisten [Sergej Prokofjev](https://en.wikipedia.org/wiki/Sergei_Prokofiev). Det er en historie om den unge pioneren Peter, som modig går ut av huset sitt til skogkanten for å jage ulven. I denne delen skal vi trene maskinlæringsalgoritmer som vil hjelpe Peter:
|
||||
|
||||
- **Utforske** området rundt og bygge et optimalt navigasjonskart.
|
||||
- **Lære** å bruke et skateboard og balansere på det, for å bevege seg raskere rundt.
|
||||
|
||||
[](https://www.youtube.com/watch?v=Fmi5zHg4QSM)
|
||||
|
||||
> 🎥 Klikk på bildet over for å høre Peter og ulven av Prokofjev
|
||||
|
||||
## Forsterkende læring
|
||||
|
||||
I tidligere deler har du sett to eksempler på maskinlæringsproblemer:
|
||||
|
||||
- **Veiledet**, der vi har datasett som foreslår eksempler på løsninger til problemet vi ønsker å løse. [Klassifisering](../4-Classification/README.md) og [regresjon](../2-Regression/README.md) er oppgaver innen veiledet læring.
|
||||
- **Uveiledet**, der vi ikke har merkede treningsdata. Hovedeksempelet på uveiledet læring er [Clustering](../5-Clustering/README.md).
|
||||
|
||||
I denne delen vil vi introdusere deg for en ny type læringsproblem som ikke krever merkede treningsdata. Det finnes flere typer slike problemer:
|
||||
|
||||
- **[Semi-veiledet læring](https://wikipedia.org/wiki/Semi-supervised_learning)**, der vi har mye umerkede data som kan brukes til å forhåndstrene modellen.
|
||||
- **[Forsterkende læring](https://wikipedia.org/wiki/Reinforcement_learning)**, der en agent lærer hvordan den skal oppføre seg ved å utføre eksperimenter i et simulert miljø.
|
||||
|
||||
### Eksempel - dataspill
|
||||
|
||||
Anta at du vil lære en datamaskin å spille et spill, som sjakk eller [Super Mario](https://wikipedia.org/wiki/Super_Mario). For at datamaskinen skal spille et spill, må den forutsi hvilken handling den skal ta i hver spilltilstand. Selv om dette kan virke som et klassifiseringsproblem, er det ikke det - fordi vi ikke har et datasett med tilstander og tilsvarende handlinger. Selv om vi kanskje har noen data, som eksisterende sjakkpartier eller opptak av spillere som spiller Super Mario, er det sannsynlig at disse dataene ikke dekker et stort nok antall mulige tilstander.
|
||||
|
||||
I stedet for å lete etter eksisterende spilldata, er **Forsterkende læring** (RL) basert på ideen om *å få datamaskinen til å spille* mange ganger og observere resultatet. For å bruke forsterkende læring trenger vi to ting:
|
||||
|
||||
- **Et miljø** og **en simulator** som lar oss spille et spill mange ganger. Denne simulatoren vil definere alle spillregler samt mulige tilstander og handlinger.
|
||||
|
||||
- **En belønningsfunksjon**, som forteller oss hvor godt vi gjorde det under hver handling eller spill.
|
||||
|
||||
Den største forskjellen mellom andre typer maskinlæring og RL er at i RL vet vi vanligvis ikke om vi vinner eller taper før vi er ferdige med spillet. Dermed kan vi ikke si om en bestemt handling alene er god eller ikke - vi mottar bare en belønning ved slutten av spillet. Målet vårt er å designe algoritmer som lar oss trene en modell under usikre forhold. Vi skal lære om en RL-algoritme kalt **Q-læring**.
|
||||
|
||||
## Leksjoner
|
||||
|
||||
1. [Introduksjon til forsterkende læring og Q-læring](1-QLearning/README.md)
|
||||
2. [Bruke et gymsimuleringsmiljø](2-Gym/README.md)
|
||||
|
||||
## Kreditering
|
||||
|
||||
"Introduksjon til forsterkende læring" ble skrevet med ♥️ av [Dmitry Soshnikov](http://soshnikov.com)
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,159 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "83320d6b6994909e35d830cebf214039",
|
||||
"translation_date": "2025-09-05T21:33:30+00:00",
|
||||
"source_file": "9-Real-World/1-Applications/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Postscript: Maskinlæring i den virkelige verden
|
||||
|
||||
|
||||
> Sketchnote av [Tomomi Imura](https://www.twitter.com/girlie_mac)
|
||||
|
||||
I dette kurset har du lært mange måter å forberede data for trening og lage maskinlæringsmodeller. Du har bygget en rekke klassiske regresjons-, klyngings-, klassifiserings-, naturlig språkbehandlings- og tidsseriemodeller. Gratulerer! Nå lurer du kanskje på hva alt dette skal brukes til... hva er de virkelige anvendelsene for disse modellene?
|
||||
|
||||
Selv om AI, som ofte bruker dyp læring, har fått mye oppmerksomhet i industrien, finnes det fortsatt verdifulle bruksområder for klassiske maskinlæringsmodeller. Du bruker kanskje noen av disse anvendelsene allerede i dag! I denne leksjonen skal du utforske hvordan åtte ulike industrier og fagområder bruker disse typene modeller for å gjøre sine applikasjoner mer effektive, pålitelige, intelligente og verdifulle for brukerne.
|
||||
|
||||
## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## 💰 Finans
|
||||
|
||||
Finanssektoren tilbyr mange muligheter for maskinlæring. Mange problemer i dette området egner seg godt til å bli modellert og løst ved hjelp av ML.
|
||||
|
||||
### Kredittkortsvindel
|
||||
|
||||
Vi lærte om [k-means klynging](../../5-Clustering/2-K-Means/README.md) tidligere i kurset, men hvordan kan det brukes til å løse problemer relatert til kredittkortsvindel?
|
||||
|
||||
K-means klynging er nyttig i en teknikk for kredittkortsvindel kalt **uteliggermåling**. Uteliggere, eller avvik i observasjoner om et datasett, kan fortelle oss om et kredittkort brukes på en normal måte eller om noe uvanlig skjer. Som vist i artikkelen nedenfor, kan du sortere kredittkortdata ved hjelp av en k-means klyngingsalgoritme og tilordne hver transaksjon til en klynge basert på hvor mye den skiller seg ut. Deretter kan du evaluere de mest risikable klyngene for å avgjøre om transaksjonene er svindel eller legitime.
|
||||
[Referanse](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.680.1195&rep=rep1&type=pdf)
|
||||
|
||||
### Formuesforvaltning
|
||||
|
||||
I formuesforvaltning håndterer en person eller firma investeringer på vegne av sine klienter. Jobben deres er å opprettholde og øke formuen på lang sikt, så det er viktig å velge investeringer som gir god avkastning.
|
||||
|
||||
En måte å evaluere hvordan en investering presterer på er gjennom statistisk regresjon. [Lineær regresjon](../../2-Regression/1-Tools/README.md) er et verdifullt verktøy for å forstå hvordan et fond presterer i forhold til en referanseindeks. Vi kan også finne ut om resultatene av regresjonen er statistisk signifikante, eller hvor mye de vil påvirke en klients investeringer. Du kan til og med utvide analysen ved hjelp av multippel regresjon, hvor flere risikofaktorer tas med i betraktning. For et eksempel på hvordan dette fungerer for et spesifikt fond, se artikkelen nedenfor om evaluering av fondsprestasjoner ved hjelp av regresjon.
|
||||
[Referanse](http://www.brightwoodventures.com/evaluating-fund-performance-using-regression/)
|
||||
|
||||
## 🎓 Utdanning
|
||||
|
||||
Utdanningssektoren er også et veldig interessant område hvor ML kan brukes. Det finnes spennende problemer å løse, som å oppdage juks på prøver eller essays, eller håndtere skjevheter, enten de er utilsiktede eller ikke, i vurderingsprosessen.
|
||||
|
||||
### Forutsi studentatferd
|
||||
|
||||
[Coursera](https://coursera.com), en leverandør av åpne nettkurs, har en flott teknologiblogg hvor de diskuterer mange ingeniørbeslutninger. I denne casestudien plottet de en regresjonslinje for å utforske en mulig korrelasjon mellom en lav NPS (Net Promoter Score)-vurdering og kursretensjon eller frafall.
|
||||
[Referanse](https://medium.com/coursera-engineering/controlled-regression-quantifying-the-impact-of-course-quality-on-learner-retention-31f956bd592a)
|
||||
|
||||
### Redusere skjevheter
|
||||
|
||||
[Grammarly](https://grammarly.com), en skriveassistent som sjekker for stave- og grammatikkfeil, bruker sofistikerte [naturlig språkbehandlingssystemer](../../6-NLP/README.md) i sine produkter. De publiserte en interessant casestudie i sin teknologiblogg om hvordan de håndterte kjønnsbias i maskinlæring, som du lærte om i vår [introduksjonsleksjon om rettferdighet](../../1-Introduction/3-fairness/README.md).
|
||||
[Referanse](https://www.grammarly.com/blog/engineering/mitigating-gender-bias-in-autocorrect/)
|
||||
|
||||
## 👜 Detaljhandel
|
||||
|
||||
Detaljhandelssektoren kan definitivt dra nytte av bruk av ML, med alt fra å skape en bedre kundereise til å optimalisere lagerbeholdning.
|
||||
|
||||
### Personalisere kundereisen
|
||||
|
||||
Hos Wayfair, et selskap som selger hjemmevarer som møbler, er det avgjørende å hjelpe kundene med å finne de riktige produktene for deres smak og behov. I denne artikkelen beskriver ingeniører fra selskapet hvordan de bruker ML og NLP for å "vise de riktige resultatene for kundene". Spesielt har deres Query Intent Engine blitt bygget for å bruke enhetsuttrekking, klassifiseringstrening, uttrekking av eiendeler og meninger, og sentimentmerking på kundeanmeldelser. Dette er et klassisk eksempel på hvordan NLP fungerer i netthandel.
|
||||
[Referanse](https://www.aboutwayfair.com/tech-innovation/how-we-use-machine-learning-and-natural-language-processing-to-empower-search)
|
||||
|
||||
### Lagerstyring
|
||||
|
||||
Innovative, smidige selskaper som [StitchFix](https://stitchfix.com), en abonnementstjeneste som sender klær til forbrukere, er sterkt avhengige av ML for anbefalinger og lagerstyring. Deres stylingteam samarbeider med deres innkjøpsteam, faktisk: "en av våre dataforskere eksperimenterte med en genetisk algoritme og brukte den på klær for å forutsi hva som ville være et vellykket klesplagg som ikke eksisterer i dag. Vi presenterte dette for innkjøpsteamet, og nå kan de bruke det som et verktøy."
|
||||
[Referanse](https://www.zdnet.com/article/how-stitch-fix-uses-machine-learning-to-master-the-science-of-styling/)
|
||||
|
||||
## 🏥 Helsevesen
|
||||
|
||||
Helsevesenet kan bruke ML til å optimalisere forskningsoppgaver og logistiske problemer som å forhindre gjeninnleggelser eller stoppe sykdomsspredning.
|
||||
|
||||
### Administrere kliniske studier
|
||||
|
||||
Toksisitet i kliniske studier er en stor bekymring for legemiddelprodusenter. Hvor mye toksisitet er akseptabelt? I denne studien førte analyser av ulike metoder for kliniske studier til utviklingen av en ny tilnærming for å forutsi sannsynligheten for utfall i kliniske studier. Spesielt var de i stand til å bruke random forest for å lage en [klassifiserer](../../4-Classification/README.md) som kan skille mellom grupper av legemidler.
|
||||
[Referanse](https://www.sciencedirect.com/science/article/pii/S2451945616302914)
|
||||
|
||||
### Administrere sykehusgjeninnleggelser
|
||||
|
||||
Sykehusbehandling er kostbart, spesielt når pasienter må gjeninnlegges. Denne artikkelen diskuterer et selskap som bruker ML for å forutsi potensialet for gjeninnleggelser ved hjelp av [klynging](../../5-Clustering/README.md)-algoritmer. Disse klyngene hjelper analytikere med å "oppdage grupper av gjeninnleggelser som kan ha en felles årsak".
|
||||
[Referanse](https://healthmanagement.org/c/healthmanagement/issuearticle/hospital-readmissions-and-machine-learning)
|
||||
|
||||
### Sykdomshåndtering
|
||||
|
||||
Den nylige pandemien har kastet lys over hvordan maskinlæring kan bidra til å stoppe spredningen av sykdommer. I denne artikkelen vil du kjenne igjen bruken av ARIMA, logistiske kurver, lineær regresjon og SARIMA. "Dette arbeidet er et forsøk på å beregne spredningshastigheten for dette viruset og dermed forutsi dødsfall, tilfriskninger og bekreftede tilfeller, slik at det kan hjelpe oss med å forberede oss bedre og overleve."
|
||||
[Referanse](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7979218/)
|
||||
|
||||
## 🌲 Økologi og grønn teknologi
|
||||
|
||||
Natur og økologi består av mange sensitive systemer hvor samspillet mellom dyr og natur kommer i fokus. Det er viktig å kunne måle disse systemene nøyaktig og handle riktig hvis noe skjer, som en skogbrann eller en nedgang i dyrepopulasjonen.
|
||||
|
||||
### Skogforvaltning
|
||||
|
||||
Du lærte om [forsterkende læring](../../8-Reinforcement/README.md) i tidligere leksjoner. Det kan være veldig nyttig når man prøver å forutsi mønstre i naturen. Spesielt kan det brukes til å spore økologiske problemer som skogbranner og spredning av invasive arter. I Canada brukte en gruppe forskere forsterkende læring for å bygge modeller for skogbrannens dynamikk basert på satellittbilder. Ved å bruke en innovativ "spatially spreading process (SSP)" forestilte de seg en skogbrann som "agenten ved enhver celle i landskapet." "Sett med handlinger brannen kan ta fra et sted på et gitt tidspunkt inkluderer å spre seg nord, sør, øst eller vest, eller ikke spre seg."
|
||||
|
||||
Denne tilnærmingen snur den vanlige RL-oppsettet siden dynamikken i den tilsvarende Markov Decision Process (MDP) er en kjent funksjon for umiddelbar spredning av skogbrann." Les mer om de klassiske algoritmene brukt av denne gruppen på lenken nedenfor.
|
||||
[Referanse](https://www.frontiersin.org/articles/10.3389/fict.2018.00006/full)
|
||||
|
||||
### Bevegelsessporing av dyr
|
||||
|
||||
Mens dyp læring har skapt en revolusjon i visuell sporing av dyrebevegelser (du kan bygge din egen [isbjørnsporer](https://docs.microsoft.com/learn/modules/build-ml-model-with-azure-stream-analytics/?WT.mc_id=academic-77952-leestott) her), har klassisk ML fortsatt en plass i denne oppgaven.
|
||||
|
||||
Sensorer for å spore bevegelser hos husdyr og IoT bruker denne typen visuell prosessering, men mer grunnleggende ML-teknikker er nyttige for å forhåndsbehandle data. For eksempel, i denne artikkelen ble sauers kroppsholdninger overvåket og analysert ved hjelp av ulike klassifiseringsalgoritmer. Du vil kanskje kjenne igjen ROC-kurven på side 335.
|
||||
[Referanse](https://druckhaus-hofmann.de/gallery/31-wj-feb-2020.pdf)
|
||||
|
||||
### ⚡️ Energistyring
|
||||
|
||||
I våre leksjoner om [tidsserieprognoser](../../7-TimeSeries/README.md) introduserte vi konseptet med smarte parkeringsmålere for å generere inntekter for en by basert på forståelse av tilbud og etterspørsel. Denne artikkelen diskuterer i detalj hvordan klynging, regresjon og tidsserieprognoser kombineres for å hjelpe med å forutsi fremtidig energibruk i Irland, basert på smarte målere.
|
||||
[Referanse](https://www-cdn.knime.com/sites/default/files/inline-images/knime_bigdata_energy_timeseries_whitepaper.pdf)
|
||||
|
||||
## 💼 Forsikring
|
||||
|
||||
Forsikringssektoren er en annen sektor som bruker ML for å konstruere og optimalisere levedyktige finansielle og aktuarielle modeller.
|
||||
|
||||
### Volatilitetsstyring
|
||||
|
||||
MetLife, en leverandør av livsforsikring, er åpen om hvordan de analyserer og reduserer volatilitet i sine finansielle modeller. I denne artikkelen vil du legge merke til visualiseringer av binær og ordinal klassifisering. Du vil også oppdage visualiseringer av prognoser.
|
||||
[Referanse](https://investments.metlife.com/content/dam/metlifecom/us/investments/insights/research-topics/macro-strategy/pdf/MetLifeInvestmentManagement_MachineLearnedRanking_070920.pdf)
|
||||
|
||||
## 🎨 Kunst, kultur og litteratur
|
||||
|
||||
Innen kunst, for eksempel journalistikk, finnes det mange interessante problemer. Å oppdage falske nyheter er et stort problem, da det har vist seg å påvirke folks meninger og til og med undergrave demokratier. Museer kan også dra nytte av bruk av ML i alt fra å finne koblinger mellom artefakter til ressursplanlegging.
|
||||
|
||||
### Oppdage falske nyheter
|
||||
|
||||
Å oppdage falske nyheter har blitt et katt-og-mus-spill i dagens medier. I denne artikkelen foreslår forskere at et system som kombinerer flere av ML-teknikkene vi har studert kan testes, og den beste modellen kan implementeres: "Dette systemet er basert på naturlig språkbehandling for å trekke ut funksjoner fra dataene, og deretter brukes disse funksjonene til opplæring av maskinlæringsklassifiserere som Naive Bayes, Support Vector Machine (SVM), Random Forest (RF), Stochastic Gradient Descent (SGD) og Logistic Regression (LR)."
|
||||
[Referanse](https://www.irjet.net/archives/V7/i6/IRJET-V7I6688.pdf)
|
||||
|
||||
Denne artikkelen viser hvordan kombinasjonen av ulike ML-domener kan gi interessante resultater som kan bidra til å stoppe spredningen av falske nyheter og forhindre reell skade; i dette tilfellet var motivasjonen spredningen av rykter om COVID-behandlinger som utløste voldelige opptøyer.
|
||||
|
||||
### Museum ML
|
||||
|
||||
Museer er på terskelen til en AI-revolusjon hvor katalogisering og digitalisering av samlinger og finne koblinger mellom artefakter blir enklere etter hvert som teknologien utvikler seg. Prosjekter som [In Codice Ratio](https://www.sciencedirect.com/science/article/abs/pii/S0306457321001035#:~:text=1.,studies%20over%20large%20historical%20sources.) hjelper med å låse opp mysteriene i utilgjengelige samlinger som Vatikanets arkiver. Men, den forretningsmessige siden av museer drar også nytte av ML-modeller.
|
||||
|
||||
For eksempel bygde Art Institute of Chicago modeller for å forutsi hva publikum er interessert i og når de vil besøke utstillinger. Målet er å skape individualiserte og optimaliserte besøksopplevelser hver gang brukeren besøker museet. "I regnskapsåret 2017 forutså modellen besøkstall og inntekter med en nøyaktighet på 1 prosent, sier Andrew Simnick, senior visepresident ved Art Institute."
|
||||
[Referanse](https://www.chicagobusiness.com/article/20180518/ISSUE01/180519840/art-institute-of-chicago-uses-data-to-make-exhibit-choices)
|
||||
|
||||
## 🏷 Markedsføring
|
||||
|
||||
### Kundesegmentering
|
||||
|
||||
De mest effektive markedsføringsstrategiene retter seg mot kunder på ulike måter basert på forskjellige grupperinger. I denne artikkelen diskuteres bruken av klyngingsalgoritmer for å støtte differensiert markedsføring. Differensiert markedsføring hjelper selskaper med å forbedre merkevaregjenkjenning, nå flere kunder og tjene mer penger.
|
||||
[Referanse](https://ai.inqline.com/machine-learning-for-marketing-customer-segmentation/)
|
||||
|
||||
## 🚀 Utfordring
|
||||
|
||||
Identifiser en annen sektor som drar nytte av noen av teknikkene du har lært i dette kurset, og oppdag hvordan den bruker ML.
|
||||
## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
## Gjennomgang og selvstudium
|
||||
|
||||
Wayfair sitt data science-team har flere interessante videoer om hvordan de bruker ML i selskapet sitt. Det er verdt [å ta en titt](https://www.youtube.com/channel/UCe2PjkQXqOuwkW1gw6Ameuw/videos)!
|
||||
|
||||
## Oppgave
|
||||
|
||||
[En ML skattejakt](assignment.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.
|
||||
@ -0,0 +1,27 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "fdebfcd0a3f12c9e2b436ded1aa79885",
|
||||
"translation_date": "2025-09-05T21:34:24+00:00",
|
||||
"source_file": "9-Real-World/1-Applications/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# En ML Skattejakt
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
I denne leksjonen lærte du om mange virkelige brukstilfeller som ble løst ved hjelp av klassisk ML. Selv om bruken av dyp læring, nye teknikker og verktøy innen AI, og utnyttelse av nevrale nettverk har bidratt til å akselerere utviklingen av verktøy for å hjelpe i disse sektorene, har klassisk ML ved bruk av teknikkene i dette pensumet fortsatt stor verdi.
|
||||
|
||||
I denne oppgaven skal du forestille deg at du deltar i en hackathon. Bruk det du har lært i pensumet til å foreslå en løsning ved hjelp av klassisk ML for å løse et problem i en av sektorene som ble diskutert i denne leksjonen. Lag en presentasjon der du diskuterer hvordan du vil implementere ideen din. Ekstrapoeng hvis du kan samle inn eksempeldata og bygge en ML-modell for å støtte konseptet ditt!
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Eksemplarisk | Tilfredsstillende | Trenger forbedring |
|
||||
| --------- | ------------------------------------------------------------------- | ------------------------------------------------ | ---------------------- |
|
||||
| | En PowerPoint-presentasjon blir presentert - bonus for å bygge en modell | En ikke-innovativ, grunnleggende presentasjon blir presentert | Arbeidet er ufullstendig |
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,25 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "91c6a180ef08e20cc15acfd2d6d6e164",
|
||||
"translation_date": "2025-09-05T21:37:15+00:00",
|
||||
"source_file": "9-Real-World/2-Debugging-ML-Models/assignment.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Utforsk Responsible AI (RAI) dashboard
|
||||
|
||||
## Instruksjoner
|
||||
|
||||
I denne leksjonen lærte du om RAI dashboard, en samling av komponenter bygget på "open-source"-verktøy for å hjelpe dataforskere med feilanalyse, datautforskning, vurdering av rettferdighet, modellfortolkning, kontrafaktiske/hva-hvis-vurderinger og kausalanalyse på AI-systemer. For denne oppgaven, utforsk noen av RAI dashboard sine eksempler [notebooks](https://github.com/Azure/RAI-vNext-Preview/tree/main/examples/notebooks) og rapporter funnene dine i et papir eller en presentasjon.
|
||||
|
||||
## Vurderingskriterier
|
||||
|
||||
| Kriterier | Fremragende | Tilfredsstillende | Trenger forbedring |
|
||||
| --------- | ----------- | ----------------- | ------------------ |
|
||||
| | Et papir eller PowerPoint-presentasjon blir levert som diskuterer RAI dashboard sine komponenter, notebook som ble kjørt, og konklusjonene som ble trukket fra å kjøre den | Et papir blir levert uten konklusjoner | Ingen papir blir levert |
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,32 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "5e069a0ac02a9606a69946c2b3c574a9",
|
||||
"translation_date": "2025-09-05T21:31:41+00:00",
|
||||
"source_file": "9-Real-World/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Postscript: Virkelige anvendelser av klassisk maskinlæring
|
||||
|
||||
I denne delen av læreplanen vil du bli introdusert for noen virkelige anvendelser av klassisk ML. Vi har søkt på internett for å finne forskningsartikler og artikler om applikasjoner som har brukt disse strategiene, og unngått nevrale nettverk, dyp læring og AI så mye som mulig. Lær om hvordan ML brukes i forretningssystemer, økologiske applikasjoner, finans, kunst og kultur, og mer.
|
||||
|
||||
|
||||
|
||||
> Foto av <a href="https://unsplash.com/@childeye?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Alexis Fauvet</a> på <a href="https://unsplash.com/s/photos/artificial-intelligence?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
|
||||
|
||||
## Leksjon
|
||||
|
||||
1. [Virkelige anvendelser for ML](1-Applications/README.md)
|
||||
2. [Feilsøking av modeller i maskinlæring ved bruk av Responsible AI dashboard-komponenter](2-Debugging-ML-Models/README.md)
|
||||
|
||||
## Kreditering
|
||||
|
||||
"Virkelige anvendelser" ble skrevet av et team av folk, inkludert [Jen Looper](https://twitter.com/jenlooper) og [Ornella Altunyan](https://twitter.com/ornelladotcom).
|
||||
|
||||
"Feilsøking av modeller i maskinlæring ved bruk av Responsible AI dashboard-komponenter" ble skrevet av [Ruth Yakubu](https://twitter.com/ruthieyakubu)
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,23 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "c06b12caf3c901eb3156e3dd5b0aea56",
|
||||
"translation_date": "2025-09-05T21:04:33+00:00",
|
||||
"source_file": "CODE_OF_CONDUCT.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Microsoft Open Source Code of Conduct
|
||||
|
||||
Dette prosjektet har tatt i bruk [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
|
||||
|
||||
Ressurser:
|
||||
|
||||
- [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/)
|
||||
- [Microsoft Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/)
|
||||
- Kontakt [opencode@microsoft.com](mailto:opencode@microsoft.com) ved spørsmål eller bekymringer
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,30 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "977ec5266dfd78ad1ce2bd8d46fccbda",
|
||||
"translation_date": "2025-09-05T21:03:17+00:00",
|
||||
"source_file": "CONTRIBUTING.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Bidra
|
||||
|
||||
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.
|
||||
|
||||
> Viktig: når du oversetter tekst i dette repoet, må du sørge for at du ikke bruker maskinoversettelse. Vi vil verifisere oversettelser via fellesskapet, så vennligst kun bidra med oversettelser til språk du er dyktig i.
|
||||
|
||||
Når du sender inn en pull request, vil en CLA-bot automatisk avgjøre om du trenger
|
||||
å gi en CLA og dekorere PR-en deretter (f.eks. etikett, kommentar). Følg bare
|
||||
instruksjonene gitt av boten. Du trenger kun å gjøre dette én gang på tvers av alle repositorier som bruker vår CLA.
|
||||
|
||||
Dette prosjektet har tatt i bruk [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
|
||||
For mer informasjon, se [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/)
|
||||
eller kontakt [opencode@microsoft.com](mailto:opencode@microsoft.com) med eventuelle spørsmål eller kommentarer.
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,177 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "612aef7a03204260e940131b09691977",
|
||||
"translation_date": "2025-09-05T21:01:50+00:00",
|
||||
"source_file": "README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
[](https://github.com/microsoft/ML-For-Beginners/blob/master/LICENSE)
|
||||
[](https://GitHub.com/microsoft/ML-For-Beginners/graphs/contributors/)
|
||||
[](https://GitHub.com/microsoft/ML-For-Beginners/issues/)
|
||||
[](https://GitHub.com/microsoft/ML-For-Beginners/pulls/)
|
||||
[](http://makeapullrequest.com)
|
||||
|
||||
[](https://GitHub.com/microsoft/ML-For-Beginners/watchers/)
|
||||
[](https://GitHub.com/microsoft/ML-For-Beginners/network/)
|
||||
[](https://GitHub.com/microsoft/ML-For-Beginners/stargazers/)
|
||||
|
||||
### 🌐 Støtte for flere språk
|
||||
|
||||
#### Støttet via GitHub Action (Automatisk og alltid oppdatert)
|
||||
|
||||
[French](../fr/README.md) | [Spanish](../es/README.md) | [German](../de/README.md) | [Russian](../ru/README.md) | [Arabic](../ar/README.md) | [Persian (Farsi)](../fa/README.md) | [Urdu](../ur/README.md) | [Chinese (Simplified)](../zh/README.md) | [Chinese (Traditional, Macau)](../mo/README.md) | [Chinese (Traditional, Hong Kong)](../hk/README.md) | [Chinese (Traditional, Taiwan)](../tw/README.md) | [Japanese](../ja/README.md) | [Korean](../ko/README.md) | [Hindi](../hi/README.md) | [Bengali](../bn/README.md) | [Marathi](../mr/README.md) | [Nepali](../ne/README.md) | [Punjabi (Gurmukhi)](../pa/README.md) | [Portuguese (Portugal)](../pt/README.md) | [Portuguese (Brazil)](../br/README.md) | [Italian](../it/README.md) | [Polish](../pl/README.md) | [Turkish](../tr/README.md) | [Greek](../el/README.md) | [Thai](../th/README.md) | [Swedish](../sv/README.md) | [Danish](../da/README.md) | [Norwegian](./README.md) | [Finnish](../fi/README.md) | [Dutch](../nl/README.md) | [Hebrew](../he/README.md) | [Vietnamese](../vi/README.md) | [Indonesian](../id/README.md) | [Malay](../ms/README.md) | [Tagalog (Filipino)](../tl/README.md) | [Swahili](../sw/README.md) | [Hungarian](../hu/README.md) | [Czech](../cs/README.md) | [Slovak](../sk/README.md) | [Romanian](../ro/README.md) | [Bulgarian](../bg/README.md) | [Serbian (Cyrillic)](../sr/README.md) | [Croatian](../hr/README.md) | [Slovenian](../sl/README.md) | [Ukrainian](../uk/README.md) | [Burmese (Myanmar)](../my/README.md)
|
||||
|
||||
#### Bli med i fellesskapet
|
||||
|
||||
[](https://discord.gg/kzRShWzttr)
|
||||
|
||||
# Maskinlæring for nybegynnere - Et pensum
|
||||
|
||||
> 🌍 Reis rundt i verden mens vi utforsker maskinlæring gjennom verdens kulturer 🌍
|
||||
|
||||
Cloud Advocates hos Microsoft er glade for å tilby et 12-ukers, 26-leksjons pensum om **maskinlæring**. I dette pensumet vil du lære om det som noen ganger kalles **klassisk maskinlæring**, hovedsakelig ved bruk av Scikit-learn som bibliotek og unngå dyp læring, som dekkes i vårt [AI for Beginners-pensum](https://aka.ms/ai4beginners). Kombiner disse leksjonene med vårt ['Data Science for Beginners'-pensum](https://aka.ms/ds4beginners), også!
|
||||
|
||||
Reis med oss rundt i verden mens vi bruker disse klassiske teknikkene på data fra mange områder av verden. Hver leksjon inkluderer quiz før og etter leksjonen, skriftlige instruksjoner for å fullføre leksjonen, en løsning, en oppgave og mer. Vår prosjektbaserte pedagogikk lar deg lære mens du bygger, en bevist måte å få nye ferdigheter til å sitte.
|
||||
|
||||
**✍️ Stor takk til våre forfattere** Jen Looper, Stephen Howell, Francesca Lazzeri, Tomomi Imura, Cassie Breviu, Dmitry Soshnikov, Chris Noring, Anirban Mukherjee, Ornella Altunyan, Ruth Yakubu og Amy Boyd
|
||||
|
||||
**🎨 Takk også til våre illustratører** Tomomi Imura, Dasani Madipalli og Jen Looper
|
||||
|
||||
**🙏 Spesiell takk 🙏 til våre Microsoft Student Ambassador-forfattere, anmeldere og innholdsbidragsytere**, spesielt Rishit Dagli, Muhammad Sakib Khan Inan, Rohan Raj, Alexandru Petrescu, Abhishek Jaiswal, Nawrin Tabassum, Ioan Samuila og Snigdha Agarwal
|
||||
|
||||
**🤩 Ekstra takknemlighet til Microsoft Student Ambassadors Eric Wanjau, Jasleen Sondhi og Vidushi Gupta for våre R-leksjoner!**
|
||||
|
||||
# Kom i gang
|
||||
|
||||
Følg disse trinnene:
|
||||
1. **Fork repoet**: Klikk på "Fork"-knappen øverst til høyre på denne siden.
|
||||
2. **Klon repoet**: `git clone https://github.com/microsoft/ML-For-Beginners.git`
|
||||
|
||||
> [finn alle tilleggsmaterialer for dette kurset i vår Microsoft Learn-samling](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
|
||||
|
||||
**[Studenter](https://aka.ms/student-page)**, for å bruke dette pensumet, fork hele repoet til din egen GitHub-konto og fullfør oppgavene alene eller med en gruppe:
|
||||
|
||||
- Start med en quiz før leksjonen.
|
||||
- Les leksjonen og fullfør aktivitetene, ta pauser og reflekter ved hver kunnskapssjekk.
|
||||
- Prøv å lage prosjektene ved å forstå leksjonene i stedet for å kjøre løsningskoden; men den koden er tilgjengelig i `/solution`-mappene i hver prosjektorienterte leksjon.
|
||||
- Ta quiz etter leksjonen.
|
||||
- Fullfør utfordringen.
|
||||
- Fullfør oppgaven.
|
||||
- Etter å ha fullført en leksjonsgruppe, besøk [Diskusjonsforumet](https://github.com/microsoft/ML-For-Beginners/discussions) og "lær høyt" ved å fylle ut den passende PAT-rubrikken. En 'PAT' er et Progress Assessment Tool som er en rubrikk du fyller ut for å fremme læringen din. Du kan også reagere på andre PAT-er slik at vi kan lære sammen.
|
||||
|
||||
> For videre studier anbefaler vi å følge disse [Microsoft Learn](https://docs.microsoft.com/en-us/users/jenlooper-2911/collections/k7o7tg1gp306q4?WT.mc_id=academic-77952-leestott)-modulene og læringsstiene.
|
||||
|
||||
**Lærere**, vi har [inkludert noen forslag](for-teachers.md) om hvordan du kan bruke dette pensumet.
|
||||
|
||||
---
|
||||
|
||||
## Videogjennomganger
|
||||
|
||||
Noen av leksjonene er tilgjengelige som korte videoer. Du finner alle disse i leksjonene, eller på [ML for Beginners-spillelisten på Microsoft Developer YouTube-kanalen](https://aka.ms/ml-beginners-videos) ved å klikke på bildet nedenfor.
|
||||
|
||||
[](https://aka.ms/ml-beginners-videos)
|
||||
|
||||
---
|
||||
|
||||
## Møt teamet
|
||||
|
||||
[](https://youtu.be/Tj1XWrDSYJU)
|
||||
|
||||
**Gif av** [Mohit Jaisal](https://linkedin.com/in/mohitjaisal)
|
||||
|
||||
> 🎥 Klikk på bildet ovenfor for en video om prosjektet og folkene som skapte det!
|
||||
|
||||
---
|
||||
|
||||
## Pedagogikk
|
||||
|
||||
Vi har valgt to pedagogiske prinsipper mens vi bygde dette pensumet: å sikre at det er praktisk **prosjektbasert** og at det inkluderer **hyppige quizer**. I tillegg har dette pensumet et felles **tema** for å gi det sammenheng.
|
||||
|
||||
Ved å sikre at innholdet er knyttet til prosjekter, blir prosessen mer engasjerende for studenter, og begrepsforståelsen vil bli styrket. I tillegg setter en lavterskelquiz før en klasse studentens intensjon mot å lære et emne, mens en andre quiz etter klassen sikrer ytterligere forståelse. Dette pensumet ble designet for å være fleksibelt og morsomt og kan tas i sin helhet eller delvis. Prosjektene starter små og blir stadig mer komplekse mot slutten av den 12-ukers syklusen. Dette pensumet inkluderer også et tillegg om virkelige applikasjoner av ML, som kan brukes som ekstra kreditt eller som grunnlag for diskusjon.
|
||||
|
||||
> Finn vår [Code of Conduct](CODE_OF_CONDUCT.md), [Contributing](CONTRIBUTING.md), og [Translation](TRANSLATIONS.md)-retningslinjer. Vi ønsker din konstruktive tilbakemelding velkommen!
|
||||
|
||||
## Hver leksjon inkluderer
|
||||
|
||||
- valgfri sketchnote
|
||||
- valgfri tilleggsvideo
|
||||
- videogjennomgang (noen leksjoner)
|
||||
- [quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
- skriftlig leksjon
|
||||
- for prosjektbaserte leksjoner, trinnvise guider for hvordan du bygger prosjektet
|
||||
- kunnskapssjekker
|
||||
- en utfordring
|
||||
- tilleggslesing
|
||||
- oppgave
|
||||
- [quiz etter leksjonen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
> **En merknad om språk**: Disse leksjonene er hovedsakelig skrevet i Python, men mange er også tilgjengelige i R. For å fullføre en R-leksjon, gå til `/solution`-mappen og se etter R-leksjoner. De inkluderer en .rmd-utvidelse som representerer en **R Markdown**-fil som enkelt kan defineres som en innbygging av `kodeblokker` (av R eller andre språk) og en `YAML-header` (som styrer hvordan utdata formateres, som PDF) i et `Markdown-dokument`. Som sådan fungerer det som et eksemplarisk forfatterrammeverk for datavitenskap siden det lar deg kombinere koden din, dens utdata og tankene dine ved å skrive dem ned i Markdown. Dessuten kan R Markdown-dokumenter gjengis til utdataformater som PDF, HTML eller Word.
|
||||
|
||||
> **En merknad om quizer**: Alle quizer er inneholdt i [Quiz App-mappen](../../quiz-app), for totalt 52 quizer med tre spørsmål hver. De er lenket fra leksjonene, men quiz-appen kan kjøres lokalt; følg instruksjonene i `quiz-app`-mappen for å være vert lokalt eller distribuere til Azure.
|
||||
|
||||
| Leksjonsnummer | Emne | Leksjonsgruppe | Læringsmål | Lenket leksjon | Forfatter |
|
||||
| :-----------: | :------------------------------------------------------------: | :-------------------------------------------------: | ------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------: |
|
||||
| 01 | Introduksjon til maskinlæring | [Introduksjon](1-Introduction/README.md) | Lær de grunnleggende konseptene bak maskinlæring | [Leksjon](1-Introduction/1-intro-to-ML/README.md) | Muhammad |
|
||||
| 02 | Historien til maskinlæring | [Introduksjon](1-Introduction/README.md) | Lær historien bak dette feltet | [Leksjon](1-Introduction/2-history-of-ML/README.md) | Jen og Amy |
|
||||
| 03 | Rettferdighet og maskinlæring | [Introduksjon](1-Introduction/README.md) | Hva er de viktige filosofiske spørsmålene rundt rettferdighet som studenter bør vurdere når de bygger og bruker ML-modeller? | [Leksjon](1-Introduction/3-fairness/README.md) | Tomomi |
|
||||
| 04 | Teknikker for maskinlæring | [Introduksjon](1-Introduction/README.md) | Hvilke teknikker bruker ML-forskere for å bygge ML-modeller? | [Leksjon](1-Introduction/4-techniques-of-ML/README.md) | Chris og Jen |
|
||||
| 05 | Introduksjon til regresjon | [Regresjon](2-Regression/README.md) | Kom i gang med Python og Scikit-learn for regresjonsmodeller |
|
||||
<ul><li>[Python](2-Regression/1-Tools/README.md)</li><li>[R](../../2-Regression/1-Tools/solution/R/lesson_1.html)</li></ul> | <ul><li>Jen</li><li>Eric Wanjau</li></ul> |
|
||||
| 06 | Nordamerikanske gresskarpriser 🎃 | [Regresjon](2-Regression/README.md) | Visualiser og rengjør data som forberedelse til ML | <ul><li>[Python](2-Regression/2-Data/README.md)</li><li>[R](../../2-Regression/2-Data/solution/R/lesson_2.html)</li></ul> | <ul><li>Jen</li><li>Eric Wanjau</li></ul> |
|
||||
| 07 | Nordamerikanske gresskarpriser 🎃 | [Regresjon](2-Regression/README.md) | Bygg lineære og polynomiske regresjonsmodeller | <ul><li>[Python](2-Regression/3-Linear/README.md)</li><li>[R](../../2-Regression/3-Linear/solution/R/lesson_3.html)</li></ul> | <ul><li>Jen og Dmitry</li><li>Eric Wanjau</li></ul> |
|
||||
| 08 | Nordamerikanske gresskarpriser 🎃 | [Regresjon](2-Regression/README.md) | Bygg en logistisk regresjonsmodell | <ul><li>[Python](2-Regression/4-Logistic/README.md) </li><li>[R](../../2-Regression/4-Logistic/solution/R/lesson_4.html)</li></ul> | <ul><li>Jen</li><li>Eric Wanjau</li></ul> |
|
||||
| 09 | En webapp 🔌 | [Webapp](3-Web-App/README.md) | Bygg en webapp for å bruke din trente modell | [Python](3-Web-App/1-Web-App/README.md) | Jen |
|
||||
| 10 | Introduksjon til klassifisering | [Klassifisering](4-Classification/README.md) | Rengjør, forbered og visualiser dataene dine; introduksjon til klassifisering | <ul><li> [Python](4-Classification/1-Introduction/README.md) </li><li>[R](../../4-Classification/1-Introduction/solution/R/lesson_10.html) | <ul><li>Jen og Cassie</li><li>Eric Wanjau</li></ul> |
|
||||
| 11 | Deilige asiatiske og indiske retter 🍜 | [Klassifisering](4-Classification/README.md) | Introduksjon til klassifikatorer | <ul><li> [Python](4-Classification/2-Classifiers-1/README.md)</li><li>[R](../../4-Classification/2-Classifiers-1/solution/R/lesson_11.html) | <ul><li>Jen og Cassie</li><li>Eric Wanjau</li></ul> |
|
||||
| 12 | Deilige asiatiske og indiske retter 🍜 | [Klassifisering](4-Classification/README.md) | Flere klassifikatorer | <ul><li> [Python](4-Classification/3-Classifiers-2/README.md)</li><li>[R](../../4-Classification/3-Classifiers-2/solution/R/lesson_12.html) | <ul><li>Jen og Cassie</li><li>Eric Wanjau</li></ul> |
|
||||
| 13 | Deilige asiatiske og indiske retter 🍜 | [Klassifisering](4-Classification/README.md) | Bygg en anbefalingswebapp ved hjelp av modellen din | [Python](4-Classification/4-Applied/README.md) | Jen |
|
||||
| 14 | Introduksjon til klynging | [Klynging](5-Clustering/README.md) | Rengjør, forbered og visualiser dataene dine; introduksjon til klynging | <ul><li> [Python](5-Clustering/1-Visualize/README.md)</li><li>[R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | <ul><li>Jen</li><li>Eric Wanjau</li></ul> |
|
||||
| 15 | Utforsking av nigerianske musikksmaker 🎧 | [Klynging](5-Clustering/README.md) | Utforsk K-Means klyngemetoden | <ul><li> [Python](5-Clustering/2-K-Means/README.md)</li><li>[R](../../5-Clustering/2-K-Means/solution/R/lesson_15.html) | <ul><li>Jen</li><li>Eric Wanjau</li></ul> |
|
||||
| 16 | Introduksjon til naturlig språkbehandling ☕️ | [Naturlig språkbehandling](6-NLP/README.md) | Lær det grunnleggende om NLP ved å bygge en enkel bot | [Python](6-NLP/1-Introduction-to-NLP/README.md) | Stephen |
|
||||
| 17 | Vanlige NLP-oppgaver ☕️ | [Naturlig språkbehandling](6-NLP/README.md) | Fordyp deg i NLP ved å forstå vanlige oppgaver knyttet til språkstrukturer | [Python](6-NLP/2-Tasks/README.md) | Stephen |
|
||||
| 18 | Oversettelse og sentimentanalyse ♥️ | [Naturlig språkbehandling](6-NLP/README.md) | Oversettelse og sentimentanalyse med Jane Austen | [Python](6-NLP/3-Translation-Sentiment/README.md) | Stephen |
|
||||
| 19 | Romantiske hoteller i Europa ♥️ | [Naturlig språkbehandling](6-NLP/README.md) | Sentimentanalyse med hotellanmeldelser 1 | [Python](6-NLP/4-Hotel-Reviews-1/README.md) | Stephen |
|
||||
| 20 | Romantiske hoteller i Europa ♥️ | [Naturlig språkbehandling](6-NLP/README.md) | Sentimentanalyse med hotellanmeldelser 2 | [Python](6-NLP/5-Hotel-Reviews-2/README.md) | Stephen |
|
||||
| 21 | Introduksjon til tidsserieprognoser | [Tidsserier](7-TimeSeries/README.md) | Introduksjon til tidsserieprognoser | [Python](7-TimeSeries/1-Introduction/README.md) | Francesca |
|
||||
| 22 | ⚡️ Verdens strømforbruk ⚡️ - tidsserieprognoser med ARIMA | [Tidsserier](7-TimeSeries/README.md) | Tidsserieprognoser med ARIMA | [Python](7-TimeSeries/2-ARIMA/README.md) | Francesca |
|
||||
| 23 | ⚡️ Verdens strømforbruk ⚡️ - tidsserieprognoser med SVR | [Tidsserier](7-TimeSeries/README.md) | Tidsserieprognoser med Support Vector Regressor | [Python](7-TimeSeries/3-SVR/README.md) | Anirban |
|
||||
| 24 | Introduksjon til forsterkende læring | [Forsterkende læring](8-Reinforcement/README.md) | Introduksjon til forsterkende læring med Q-Learning | [Python](8-Reinforcement/1-QLearning/README.md) | Dmitry |
|
||||
| 25 | Hjelp Peter å unngå ulven! 🐺 | [Forsterkende læring](8-Reinforcement/README.md) | Forsterkende læring med Gym | [Python](8-Reinforcement/2-Gym/README.md) | Dmitry |
|
||||
| Postscript | Virkelige ML-scenarier og applikasjoner | [ML i praksis](9-Real-World/README.md) | Interessante og avslørende virkelige applikasjoner av klassisk ML | [Leksjon](9-Real-World/1-Applications/README.md) | Team |
|
||||
| Postscript | Modellfeilsøking i ML med RAI-dashboard | [ML i praksis](9-Real-World/README.md) | Modellfeilsøking i maskinlæring ved bruk av Responsible AI-dashboardkomponenter | [Leksjon](9-Real-World/2-Debugging-ML-Models/README.md) | Ruth Yakubu |
|
||||
|
||||
> [finn alle tilleggsmaterialer for dette kurset i vår Microsoft Learn-samling](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
|
||||
|
||||
## Offline tilgang
|
||||
|
||||
Du kan kjøre denne dokumentasjonen offline ved å bruke [Docsify](https://docsify.js.org/#/). Fork dette repoet, [installer Docsify](https://docsify.js.org/#/quickstart) på din lokale maskin, og deretter i rotmappen av dette repoet, skriv `docsify serve`. Nettstedet vil bli servert på port 3000 på din localhost: `localhost:3000`.
|
||||
|
||||
## PDF-er
|
||||
|
||||
Finn en PDF av pensum med lenker [her](https://microsoft.github.io/ML-For-Beginners/pdf/readme.pdf).
|
||||
|
||||
## 🎒 Andre kurs
|
||||
|
||||
Teamet vårt produserer andre kurs! Sjekk ut:
|
||||
|
||||
- [Generativ AI for nybegynnere](https://aka.ms/genai-beginners)
|
||||
- [Generativ AI for nybegynnere .NET](https://github.com/microsoft/Generative-AI-for-beginners-dotnet)
|
||||
- [Generativ AI med JavaScript](https://github.com/microsoft/generative-ai-with-javascript)
|
||||
- [Generativ AI med Java](https://github.com/microsoft/Generative-AI-for-beginners-java)
|
||||
- [AI for nybegynnere](https://aka.ms/ai-beginners)
|
||||
- [Data Science for nybegynnere](https://aka.ms/datascience-beginners)
|
||||
- [ML for nybegynnere](https://aka.ms/ml-beginners)
|
||||
- [Cybersikkerhet for nybegynnere](https://github.com/microsoft/Security-101)
|
||||
- [Webutvikling for nybegynnere](https://aka.ms/webdev-beginners)
|
||||
- [IoT for nybegynnere](https://aka.ms/iot-beginners)
|
||||
- [XR-utvikling for nybegynnere](https://github.com/microsoft/xr-development-for-beginners)
|
||||
- [Mestre GitHub Copilot for parprogrammering](https://github.com/microsoft/Mastering-GitHub-Copilot-for-Paired-Programming)
|
||||
- [Mestre GitHub Copilot for C#/.NET-utviklere](https://github.com/microsoft/mastering-github-copilot-for-dotnet-csharp-developers)
|
||||
- [Velg ditt eget Copilot-eventyr](https://github.com/microsoft/CopilotAdventures)
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,51 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "5e1b8da31aae9cca3d53ad243fa3365a",
|
||||
"translation_date": "2025-09-05T21:03:45+00:00",
|
||||
"source_file": "SECURITY.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
## Sikkerhet
|
||||
|
||||
Microsoft tar sikkerheten til våre programvareprodukter og tjenester på alvor, inkludert alle kildekoderepositorier som administreres gjennom våre GitHub-organisasjoner, som inkluderer [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), og [våre GitHub-organisasjoner](https://opensource.microsoft.com/).
|
||||
|
||||
Hvis du mener at du har funnet en sikkerhetssårbarhet i et Microsoft-eid repositorium som oppfyller [Microsofts definisjon av en sikkerhetssårbarhet](https://docs.microsoft.com/previous-versions/tn-archive/cc751383(v=technet.10)?WT.mc_id=academic-77952-leestott), vennligst rapporter det til oss som beskrevet nedenfor.
|
||||
|
||||
## Rapportering av sikkerhetsproblemer
|
||||
|
||||
**Vennligst ikke rapporter sikkerhetssårbarheter gjennom offentlige GitHub-issues.**
|
||||
|
||||
Rapporter dem i stedet til Microsoft Security Response Center (MSRC) på [https://msrc.microsoft.com/create-report](https://msrc.microsoft.com/create-report).
|
||||
|
||||
Hvis du foretrekker å sende inn uten å logge inn, kan du sende e-post til [secure@microsoft.com](mailto:secure@microsoft.com). Hvis mulig, krypter meldingen din med vår PGP-nøkkel; du kan laste den ned fra [Microsoft Security Response Center PGP Key-siden](https://www.microsoft.com/en-us/msrc/pgp-key-msrc).
|
||||
|
||||
Du bør motta et svar innen 24 timer. Hvis du av en eller annen grunn ikke gjør det, vennligst følg opp via e-post for å sikre at vi mottok din opprinnelige melding. Tilleggsinformasjon finner du på [microsoft.com/msrc](https://www.microsoft.com/msrc).
|
||||
|
||||
Vennligst inkluder den forespurte informasjonen nedenfor (så mye du kan gi) for å hjelpe oss med å forstå naturen og omfanget av det mulige problemet:
|
||||
|
||||
* Type problem (f.eks. buffer overflow, SQL-injeksjon, cross-site scripting, etc.)
|
||||
* Fullstendige stier til kildefil(er) relatert til manifestasjonen av problemet
|
||||
* Plasseringen av den berørte kildekoden (tag/branch/commit eller direkte URL)
|
||||
* Eventuell spesiell konfigurasjon som kreves for å gjenskape problemet
|
||||
* Trinnvise instruksjoner for å gjenskape problemet
|
||||
* Proof-of-concept eller utnyttelseskode (hvis mulig)
|
||||
* Innvirkning av problemet, inkludert hvordan en angriper kan utnytte det
|
||||
|
||||
Denne informasjonen vil hjelpe oss med å prioritere rapporten din raskere.
|
||||
|
||||
Hvis du rapporterer for en bug bounty, kan mer komplette rapporter bidra til en høyere belønning. Besøk vår [Microsoft Bug Bounty Program](https://microsoft.com/msrc/bounty)-side for mer informasjon om våre aktive programmer.
|
||||
|
||||
## Foretrukne språk
|
||||
|
||||
Vi foretrekker all kommunikasjon på engelsk.
|
||||
|
||||
## Retningslinjer
|
||||
|
||||
Microsoft følger prinsippet om [Koordinert sårbarhetsavsløring](https://www.microsoft.com/en-us/msrc/cvd).
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,26 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "872be8bc1b93ef1dd9ac3d6e8f99f6ab",
|
||||
"translation_date": "2025-09-05T21:02:59+00:00",
|
||||
"source_file": "SUPPORT.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Støtte
|
||||
## Hvordan rapportere problemer og få hjelp
|
||||
|
||||
Dette prosjektet bruker GitHub Issues for å spore feil og funksjonsforespørsler. Vennligst søk blant eksisterende
|
||||
problemer før du rapporterer nye for å unngå duplikater. For nye problemer, rapporter feilen eller
|
||||
funksjonsforespørselen som en ny Issue.
|
||||
|
||||
For hjelp og spørsmål om bruk av dette prosjektet, opprett en Issue.
|
||||
|
||||
## Microsofts støttepolicy
|
||||
|
||||
Støtte for dette arkivet er begrenset til ressursene som er oppført ovenfor.
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,57 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "68dd06c685f6ce840e0acfa313352e7c",
|
||||
"translation_date": "2025-09-05T21:31:12+00:00",
|
||||
"source_file": "docs/_sidebar.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
- Introduksjon
|
||||
- [Introduksjon til maskinlæring](../1-Introduction/1-intro-to-ML/README.md)
|
||||
- [Historien om maskinlæring](../1-Introduction/2-history-of-ML/README.md)
|
||||
- [Maskinlæring og rettferdighet](../1-Introduction/3-fairness/README.md)
|
||||
- [Teknikker innen maskinlæring](../1-Introduction/4-techniques-of-ML/README.md)
|
||||
|
||||
- Regresjon
|
||||
- [Verktøyene i faget](../2-Regression/1-Tools/README.md)
|
||||
- [Data](../2-Regression/2-Data/README.md)
|
||||
- [Lineær regresjon](../2-Regression/3-Linear/README.md)
|
||||
- [Logistisk regresjon](../2-Regression/4-Logistic/README.md)
|
||||
|
||||
- Bygg en webapp
|
||||
- [Webapp](../3-Web-App/1-Web-App/README.md)
|
||||
|
||||
- Klassifisering
|
||||
- [Introduksjon til klassifisering](../4-Classification/1-Introduction/README.md)
|
||||
- [Klassifikatorer 1](../4-Classification/2-Classifiers-1/README.md)
|
||||
- [Klassifikatorer 2](../4-Classification/3-Classifiers-2/README.md)
|
||||
- [Anvendt maskinlæring](../4-Classification/4-Applied/README.md)
|
||||
|
||||
- Klynging
|
||||
- [Visualiser dataene dine](../5-Clustering/1-Visualize/README.md)
|
||||
- [K-Means](../5-Clustering/2-K-Means/README.md)
|
||||
|
||||
- NLP
|
||||
- [Introduksjon til NLP](../6-NLP/1-Introduction-to-NLP/README.md)
|
||||
- [NLP-oppgaver](../6-NLP/2-Tasks/README.md)
|
||||
- [Oversettelse og sentimentanalyse](../6-NLP/3-Translation-Sentiment/README.md)
|
||||
- [Hotellanmeldelser 1](../6-NLP/4-Hotel-Reviews-1/README.md)
|
||||
- [Hotellanmeldelser 2](../6-NLP/5-Hotel-Reviews-2/README.md)
|
||||
|
||||
- Tidsserieprognoser
|
||||
- [Introduksjon til tidsserieprognoser](../7-TimeSeries/1-Introduction/README.md)
|
||||
- [ARIMA](../7-TimeSeries/2-ARIMA/README.md)
|
||||
- [SVR](../7-TimeSeries/3-SVR/README.md)
|
||||
|
||||
- Forsterkende læring
|
||||
- [Q-Læring](../8-Reinforcement/1-QLearning/README.md)
|
||||
- [Gym](../8-Reinforcement/2-Gym/README.md)
|
||||
|
||||
- Maskinlæring i den virkelige verden
|
||||
- [Applikasjoner](../9-Real-World/1-Applications/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.
|
||||
@ -0,0 +1,37 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "b37de02054fa6c0438ede6fabe1fdfb8",
|
||||
"translation_date": "2025-09-05T21:04:15+00:00",
|
||||
"source_file": "for-teachers.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
## For lærere
|
||||
|
||||
Ønsker du å bruke dette pensumet i klasserommet ditt? Vær så god!
|
||||
|
||||
Faktisk kan du bruke det direkte på GitHub ved å bruke GitHub Classroom.
|
||||
|
||||
For å gjøre det, må du forkere dette repoet. Du må opprette et repo for hver leksjon, så du må trekke ut hver mappe til et eget repo. På den måten kan [GitHub Classroom](https://classroom.github.com/classrooms) hente hver leksjon separat.
|
||||
|
||||
Disse [fullstendige instruksjonene](https://github.blog/2020-03-18-set-up-your-digital-classroom-with-github-classroom/) gir deg en idé om hvordan du kan sette opp klasserommet ditt.
|
||||
|
||||
## Bruke repoet som det er
|
||||
|
||||
Hvis du ønsker å bruke dette repoet slik det står nå, uten å bruke GitHub Classroom, kan det også gjøres. Du må kommunisere med studentene dine om hvilken leksjon dere skal jobbe med sammen.
|
||||
|
||||
I et online format (Zoom, Teams eller andre) kan du opprette grupperom for quizene og veilede studentene for å hjelpe dem med å forberede seg på læring. Deretter kan du invitere studentene til quizene og be dem sende inn svarene som 'issues' på et bestemt tidspunkt. Du kan gjøre det samme med oppgaver, hvis du ønsker at studentene skal jobbe sammen i det åpne.
|
||||
|
||||
Hvis du foretrekker et mer privat format, kan du be studentene dine om å forkere pensumet, leksjon for leksjon, til sine egne private GitHub-repoer og gi deg tilgang. Deretter kan de fullføre quizene og oppgavene privat og sende dem til deg via issues på ditt klasseromsrepo.
|
||||
|
||||
Det finnes mange måter å få dette til å fungere i et online klasseromsformat. Gi oss gjerne beskjed om hva som fungerer best for deg!
|
||||
|
||||
## Gi oss dine tanker!
|
||||
|
||||
Vi ønsker å gjøre dette pensumet nyttig for deg og dine studenter. Gi oss gjerne [tilbakemelding](https://forms.microsoft.com/Pages/ResponsePage.aspx?id=v4j5cvGGr0GRqy180BHbR2humCsRZhxNuI79cm6n0hRUQzRVVU9VVlU5UlFLWTRLWlkyQUxORTg5WS4u).
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,126 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "6d130dffca5db70d7e615f926cb1ad4c",
|
||||
"translation_date": "2025-09-05T21:48:45+00:00",
|
||||
"source_file": "quiz-app/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
# Quizer
|
||||
|
||||
Disse quizene er forhånds- og etterforelesningsquizene for ML-læreplanen på https://aka.ms/ml-beginners
|
||||
|
||||
## Prosjektoppsett
|
||||
|
||||
```
|
||||
npm install
|
||||
```
|
||||
|
||||
### Kompilerer og oppdaterer automatisk for utvikling
|
||||
|
||||
```
|
||||
npm run serve
|
||||
```
|
||||
|
||||
### Kompilerer og minimerer for produksjon
|
||||
|
||||
```
|
||||
npm run build
|
||||
```
|
||||
|
||||
### Linter og fikser filer
|
||||
|
||||
```
|
||||
npm run lint
|
||||
```
|
||||
|
||||
### Tilpass konfigurasjon
|
||||
|
||||
Se [Konfigurasjonsreferanse](https://cli.vuejs.org/config/).
|
||||
|
||||
Kreditering: Takk til den originale versjonen av denne quiz-appen: https://github.com/arpan45/simple-quiz-vue
|
||||
|
||||
## Distribuere til Azure
|
||||
|
||||
Her er en steg-for-steg guide for å komme i gang:
|
||||
|
||||
1. Fork en GitHub-repositorium
|
||||
Sørg for at koden til din statiske webapp er i ditt GitHub-repositorium. Fork dette repositoriet.
|
||||
|
||||
2. Opprett en Azure Static Web App
|
||||
- Opprett en [Azure-konto](http://azure.microsoft.com)
|
||||
- Gå til [Azure-portalen](https://portal.azure.com)
|
||||
- Klikk på "Opprett en ressurs" og søk etter "Static Web App".
|
||||
- Klikk "Opprett".
|
||||
|
||||
3. Konfigurer den statiske webappen
|
||||
- Grunnleggende: Abonnement: Velg ditt Azure-abonnement.
|
||||
- Ressursgruppe: Opprett en ny ressursgruppe eller bruk en eksisterende.
|
||||
- Navn: Gi et navn til din statiske webapp.
|
||||
- Region: Velg regionen nærmest brukerne dine.
|
||||
|
||||
- #### Distribusjonsdetaljer:
|
||||
- Kilde: Velg "GitHub".
|
||||
- GitHub-konto: Autoriser Azure til å få tilgang til din GitHub-konto.
|
||||
- Organisasjon: Velg din GitHub-organisasjon.
|
||||
- Repositorium: Velg repositoriet som inneholder din statiske webapp.
|
||||
- Gren: Velg grenen du vil distribuere fra.
|
||||
|
||||
- #### Byggdetaljer:
|
||||
- Byggforhåndsinnstillinger: Velg rammeverket appen din er bygget med (f.eks. React, Angular, Vue, osv.).
|
||||
- App-plassering: Angi mappen som inneholder koden til appen din (f.eks. / hvis den er i roten).
|
||||
- API-plassering: Hvis du har en API, spesifiser dens plassering (valgfritt).
|
||||
- Utdata-plassering: Angi mappen der byggeutdataene genereres (f.eks. build eller dist).
|
||||
|
||||
4. Gjennomgå og opprett
|
||||
Gjennomgå innstillingene dine og klikk "Opprett". Azure vil sette opp nødvendige ressurser og opprette en GitHub Actions-arbeidsflyt i ditt repositorium.
|
||||
|
||||
5. GitHub Actions-arbeidsflyt
|
||||
Azure vil automatisk opprette en GitHub Actions-arbeidsflytfil i ditt repositorium (.github/workflows/azure-static-web-apps-<name>.yml). Denne arbeidsflyten vil håndtere bygge- og distribusjonsprosessen.
|
||||
|
||||
6. Overvåk distribusjonen
|
||||
Gå til "Actions"-fanen i ditt GitHub-repositorium.
|
||||
Du bør se en arbeidsflyt som kjører. Denne arbeidsflyten vil bygge og distribuere din statiske webapp til Azure.
|
||||
Når arbeidsflyten er fullført, vil appen din være live på den oppgitte Azure-URL-en.
|
||||
|
||||
### Eksempel på arbeidsflytfil
|
||||
|
||||
Her er et eksempel på hvordan GitHub Actions-arbeidsflytfilen kan se ut:
|
||||
name: Azure Static Web Apps CI/CD
|
||||
```
|
||||
on:
|
||||
push:
|
||||
branches:
|
||||
- main
|
||||
pull_request:
|
||||
types: [opened, synchronize, reopened, closed]
|
||||
branches:
|
||||
- main
|
||||
|
||||
jobs:
|
||||
build_and_deploy_job:
|
||||
runs-on: ubuntu-latest
|
||||
name: Build and Deploy Job
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
- name: Build And Deploy
|
||||
id: builddeploy
|
||||
uses: Azure/static-web-apps-deploy@v1
|
||||
with:
|
||||
azure_static_web_apps_api_token: ${{ secrets.AZURE_STATIC_WEB_APPS_API_TOKEN }}
|
||||
repo_token: ${{ secrets.GITHUB_TOKEN }}
|
||||
action: "upload"
|
||||
app_location: "/quiz-app" # App source code path
|
||||
api_location: ""API source code path optional
|
||||
output_location: "dist" #Built app content directory - optional
|
||||
```
|
||||
|
||||
### Tilleggsressurser
|
||||
- [Azure Static Web Apps Dokumentasjon](https://learn.microsoft.com/azure/static-web-apps/getting-started)
|
||||
- [GitHub Actions Dokumentasjon](https://docs.github.com/actions/use-cases-and-examples/deploying/deploying-to-azure-static-web-app)
|
||||
|
||||
---
|
||||
|
||||
**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.
|
||||
@ -0,0 +1,21 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "a88d5918c1b9da69a40d917a0840c497",
|
||||
"translation_date": "2025-09-05T21:56:51+00:00",
|
||||
"source_file": "sketchnotes/README.md",
|
||||
"language_code": "no"
|
||||
}
|
||||
-->
|
||||
Alle sketchnotes for pensum kan lastes ned her.
|
||||
|
||||
🖨 For utskrift i høy oppløsning er TIFF-versjonene tilgjengelige på [dette repoet](https://github.com/girliemac/a-picture-is-worth-a-1000-words/tree/main/ml/tiff).
|
||||
|
||||
🎨 Laget av: [Tomomi Imura](https://github.com/girliemac) (Twitter: [@girlie_mac](https://twitter.com/girlie_mac))
|
||||
|
||||
[](https://creativecommons.org/licenses/by-sa/4.0/)
|
||||
|
||||
---
|
||||
|
||||
**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 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.
|
||||
@ -0,0 +1,159 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "69389392fa6346e0dfa30f664b7b6fec",
|
||||
"translation_date": "2025-09-05T21:42:42+00:00",
|
||||
"source_file": "1-Introduction/1-intro-to-ML/README.md",
|
||||
"language_code": "sv"
|
||||
}
|
||||
-->
|
||||
# Introduktion till maskininlärning
|
||||
|
||||
## [Quiz före föreläsning](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
---
|
||||
|
||||
[](https://youtu.be/6mSx_KJxcHI "ML för nybörjare - Introduktion till maskininlärning för nybörjare")
|
||||
|
||||
> 🎥 Klicka på bilden ovan för en kort video som går igenom denna lektion.
|
||||
|
||||
Välkommen till denna kurs om klassisk maskininlärning för nybörjare! Oavsett om du är helt ny inom detta ämne eller en erfaren ML-praktiker som vill fräscha upp dina kunskaper, är vi glada att ha dig med! Vi vill skapa en vänlig startpunkt för dina studier i maskininlärning och välkomnar gärna din [feedback](https://github.com/microsoft/ML-For-Beginners/discussions).
|
||||
|
||||
[](https://youtu.be/h0e2HAPTGF4 "Introduktion till ML")
|
||||
|
||||
> 🎥 Klicka på bilden ovan för en video: MIT:s John Guttag introducerar maskininlärning
|
||||
|
||||
---
|
||||
## Komma igång med maskininlärning
|
||||
|
||||
Innan du börjar med detta kursmaterial behöver du ha din dator konfigurerad och redo att köra notebooks lokalt.
|
||||
|
||||
- **Konfigurera din dator med dessa videor**. Använd följande länkar för att lära dig [hur du installerar Python](https://youtu.be/CXZYvNRIAKM) på ditt system och [ställer in en textredigerare](https://youtu.be/EU8eayHWoZg) för utveckling.
|
||||
- **Lär dig Python**. Det rekommenderas också att ha en grundläggande förståelse för [Python](https://docs.microsoft.com/learn/paths/python-language/?WT.mc_id=academic-77952-leestott), ett programmeringsspråk som är användbart för dataforskare och som vi använder i denna kurs.
|
||||
- **Lär dig Node.js och JavaScript**. Vi använder också JavaScript några gånger i denna kurs när vi bygger webbappar, så du behöver ha [node](https://nodejs.org) och [npm](https://www.npmjs.com/) installerade, samt [Visual Studio Code](https://code.visualstudio.com/) tillgängligt för både Python- och JavaScript-utveckling.
|
||||
- **Skapa ett GitHub-konto**. Eftersom du hittade oss här på [GitHub](https://github.com), har du kanske redan ett konto, men om inte, skapa ett och fork:a sedan detta kursmaterial för att använda det själv. (Ge oss gärna en stjärna också 😊)
|
||||
- **Utforska Scikit-learn**. Bekanta dig med [Scikit-learn](https://scikit-learn.org/stable/user_guide.html), en uppsättning ML-bibliotek som vi refererar till i dessa lektioner.
|
||||
|
||||
---
|
||||
## Vad är maskininlärning?
|
||||
|
||||
Begreppet 'maskininlärning' är ett av de mest populära och frekvent använda termerna idag. Det är inte osannolikt att du har hört detta begrepp åtminstone en gång om du har någon form av bekantskap med teknik, oavsett vilket område du arbetar inom. Mekaniken bakom maskininlärning är dock ett mysterium för de flesta. För en nybörjare inom maskininlärning kan ämnet ibland kännas överväldigande. Därför är det viktigt att förstå vad maskininlärning faktiskt är och att lära sig om det steg för steg, genom praktiska exempel.
|
||||
|
||||
---
|
||||
## Hypekurvan
|
||||
|
||||
|
||||
|
||||
> Google Trends visar den senaste 'hypekurvan' för termen 'maskininlärning'
|
||||
|
||||
---
|
||||
## Ett mystiskt universum
|
||||
|
||||
Vi lever i ett universum fullt av fascinerande mysterier. Stora vetenskapsmän som Stephen Hawking, Albert Einstein och många fler har ägnat sina liv åt att söka meningsfull information som avslöjar mysterierna i världen omkring oss. Detta är människans lärandevillkor: ett barn lär sig nya saker och upptäcker strukturen i sin värld år för år när det växer upp.
|
||||
|
||||
---
|
||||
## Barnets hjärna
|
||||
|
||||
Ett barns hjärna och sinnen uppfattar fakta från sin omgivning och lär sig gradvis de dolda mönstren i livet, vilket hjälper barnet att skapa logiska regler för att identifiera inlärda mönster. Den mänskliga hjärnans inlärningsprocess gör människor till världens mest sofistikerade levande varelse. Att kontinuerligt lära sig genom att upptäcka dolda mönster och sedan innovera på dessa mönster gör att vi kan bli bättre och bättre under hela vår livstid. Denna inlärningsförmåga och utvecklingskapacitet är relaterad till ett koncept som kallas [hjärnplasticitet](https://www.simplypsychology.org/brain-plasticity.html). Ytligt sett kan vi dra vissa motiverande likheter mellan den mänskliga hjärnans inlärningsprocess och koncepten inom maskininlärning.
|
||||
|
||||
---
|
||||
## Den mänskliga hjärnan
|
||||
|
||||
Den [mänskliga hjärnan](https://www.livescience.com/29365-human-brain.html) uppfattar saker från den verkliga världen, bearbetar den uppfattade informationen, fattar rationella beslut och utför vissa handlingar baserat på omständigheterna. Detta är vad vi kallar att bete sig intelligent. När vi programmerar en kopia av den intelligenta beteendeprocessen till en maskin kallas det artificiell intelligens (AI).
|
||||
|
||||
---
|
||||
## Några termer
|
||||
|
||||
Även om termerna kan förväxlas är maskininlärning (ML) en viktig delmängd av artificiell intelligens. **ML handlar om att använda specialiserade algoritmer för att upptäcka meningsfull information och hitta dolda mönster från uppfattad data för att stödja den rationella beslutsprocessen**.
|
||||
|
||||
---
|
||||
## AI, ML, djupinlärning
|
||||
|
||||
|
||||
|
||||
> En diagram som visar relationerna mellan AI, ML, djupinlärning och data science. Infografik av [Jen Looper](https://twitter.com/jenlooper) inspirerad av [denna grafik](https://softwareengineering.stackexchange.com/questions/366996/distinction-between-ai-ml-neural-networks-deep-learning-and-data-mining)
|
||||
|
||||
---
|
||||
## Koncept att täcka
|
||||
|
||||
I detta kursmaterial kommer vi att täcka endast kärnkoncepten inom maskininlärning som en nybörjare måste känna till. Vi täcker det vi kallar 'klassisk maskininlärning' främst med hjälp av Scikit-learn, ett utmärkt bibliotek som många studenter använder för att lära sig grunderna. För att förstå bredare koncept inom artificiell intelligens eller djupinlärning är en stark grundläggande kunskap om maskininlärning oumbärlig, och därför vill vi erbjuda det här.
|
||||
|
||||
---
|
||||
## I denna kurs kommer du att lära dig:
|
||||
|
||||
- kärnkoncept inom maskininlärning
|
||||
- maskininlärningens historia
|
||||
- ML och rättvisa
|
||||
- regressionstekniker inom ML
|
||||
- klassificeringstekniker inom ML
|
||||
- klustringstekniker inom ML
|
||||
- tekniker för naturlig språkbehandling inom ML
|
||||
- tekniker för tidsserieprognoser inom ML
|
||||
- förstärkningsinlärning
|
||||
- verkliga tillämpningar av ML
|
||||
|
||||
---
|
||||
## Vad vi inte kommer att täcka
|
||||
|
||||
- djupinlärning
|
||||
- neurala nätverk
|
||||
- AI
|
||||
|
||||
För att skapa en bättre inlärningsupplevelse kommer vi att undvika komplexiteten i neurala nätverk, 'djupinlärning' - flerskiktad modellbyggnad med neurala nätverk - och AI, som vi kommer att diskutera i ett annat kursmaterial. Vi kommer också att erbjuda ett kommande kursmaterial om data science för att fokusera på den aspekten av detta större område.
|
||||
|
||||
---
|
||||
## Varför studera maskininlärning?
|
||||
|
||||
Maskininlärning, ur ett systemperspektiv, definieras som skapandet av automatiserade system som kan lära sig dolda mönster från data för att hjälpa till att fatta intelligenta beslut.
|
||||
|
||||
Denna motivation är löst inspirerad av hur den mänskliga hjärnan lär sig vissa saker baserat på data den uppfattar från omvärlden.
|
||||
|
||||
✅ Fundera en stund på varför ett företag skulle vilja använda strategier för maskininlärning istället för att skapa en hårdkodad regelbaserad motor.
|
||||
|
||||
---
|
||||
## Tillämpningar av maskininlärning
|
||||
|
||||
Tillämpningar av maskininlärning finns nu nästan överallt och är lika allestädes närvarande som den data som flödar runt i våra samhällen, genererad av våra smartphones, uppkopplade enheter och andra system. Med tanke på den enorma potentialen hos moderna maskininlärningsalgoritmer har forskare utforskat deras förmåga att lösa multidimensionella och tvärvetenskapliga verkliga problem med stora positiva resultat.
|
||||
|
||||
---
|
||||
## Exempel på tillämpad ML
|
||||
|
||||
**Du kan använda maskininlärning på många sätt**:
|
||||
|
||||
- För att förutsäga sannolikheten för sjukdom utifrån en patients medicinska historia eller rapporter.
|
||||
- För att använda väderdata för att förutsäga väderhändelser.
|
||||
- För att förstå känslan i en text.
|
||||
- För att upptäcka falska nyheter och stoppa spridningen av propaganda.
|
||||
|
||||
Finans, ekonomi, geovetenskap, rymdforskning, biomedicinsk teknik, kognitiv vetenskap och till och med humaniora har anpassat maskininlärning för att lösa de arbetskrävande, databehandlingsintensiva problemen inom sina områden.
|
||||
|
||||
---
|
||||
## Slutsats
|
||||
|
||||
Maskininlärning automatiserar processen att upptäcka mönster genom att hitta meningsfulla insikter från verklig eller genererad data. Det har visat sig vara mycket värdefullt inom affärs-, hälso- och finansiella tillämpningar, bland andra.
|
||||
|
||||
I en nära framtid kommer förståelsen av grunderna i maskininlärning att bli ett måste för människor inom alla områden på grund av dess utbredda användning.
|
||||
|
||||
---
|
||||
# 🚀 Utmaning
|
||||
|
||||
Skissa, på papper eller med hjälp av en onlineapp som [Excalidraw](https://excalidraw.com/), din förståelse av skillnaderna mellan AI, ML, djupinlärning och data science. Lägg till några idéer om problem som var och en av dessa tekniker är bra på att lösa.
|
||||
|
||||
# [Quiz efter föreläsning](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
---
|
||||
# Granskning & Självstudier
|
||||
|
||||
För att lära dig mer om hur du kan arbeta med ML-algoritmer i molnet, följ denna [Lärväg](https://docs.microsoft.com/learn/paths/create-no-code-predictive-models-azure-machine-learning/?WT.mc_id=academic-77952-leestott).
|
||||
|
||||
Ta en [Lärväg](https://docs.microsoft.com/learn/modules/introduction-to-machine-learning/?WT.mc_id=academic-77952-leestott) om grunderna i ML.
|
||||
|
||||
---
|
||||
# Uppgift
|
||||
|
||||
[Kom igång](assignment.md)
|
||||
|
||||
---
|
||||
|
||||
**Ansvarsfriskrivning**:
|
||||
Detta dokument har översatts med hjälp av AI-översättningstjänsten [Co-op Translator](https://github.com/Azure/co-op-translator). Även om vi strävar efter noggrannhet, vänligen notera att automatiska översättningar kan innehålla fel eller felaktigheter. Det ursprungliga dokumentet på sitt ursprungliga språk bör betraktas som den auktoritativa källan. För kritisk information rekommenderas professionell mänsklig översättning. Vi ansvarar inte för eventuella missförstånd eller feltolkningar som uppstår vid användning av denna översättning.
|
||||
@ -0,0 +1,23 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "4c4698044bb8af52cfb6388a4ee0e53b",
|
||||
"translation_date": "2025-09-05T21:43:40+00:00",
|
||||
"source_file": "1-Introduction/1-intro-to-ML/assignment.md",
|
||||
"language_code": "sv"
|
||||
}
|
||||
-->
|
||||
# Kom igång
|
||||
|
||||
## Instruktioner
|
||||
|
||||
I denna uppgift utan betyg ska du fräscha upp dina kunskaper i Python och få din miljö igång så att du kan köra notebooks.
|
||||
|
||||
Ta denna [Python Learning Path](https://docs.microsoft.com/learn/paths/python-language/?WT.mc_id=academic-77952-leestott), och sätt sedan upp dina system genom att gå igenom dessa introduktionsvideor:
|
||||
|
||||
https://www.youtube.com/playlist?list=PLlrxD0HtieHhS8VzuMCfQD4uJ9yne1mE6
|
||||
|
||||
---
|
||||
|
||||
**Ansvarsfriskrivning**:
|
||||
Detta dokument har översatts med hjälp av AI-översättningstjänsten [Co-op Translator](https://github.com/Azure/co-op-translator). Även om vi strävar efter noggrannhet, bör du vara medveten om att automatiserade översättningar kan innehålla fel eller brister. Det ursprungliga dokumentet på dess originalspråk bör betraktas som den auktoritativa källan. För kritisk information rekommenderas professionell mänsklig översättning. Vi ansvarar inte för eventuella missförstånd eller feltolkningar som uppstår vid användning av denna översättning.
|
||||
@ -0,0 +1,164 @@
|
||||
<!--
|
||||
CO_OP_TRANSLATOR_METADATA:
|
||||
{
|
||||
"original_hash": "6a05fec147e734c3e6bfa54505648e2b",
|
||||
"translation_date": "2025-09-05T21:44:44+00:00",
|
||||
"source_file": "1-Introduction/2-history-of-ML/README.md",
|
||||
"language_code": "sv"
|
||||
}
|
||||
-->
|
||||
# Historien om maskininlärning
|
||||
|
||||
|
||||
> Sketchnote av [Tomomi Imura](https://www.twitter.com/girlie_mac)
|
||||
|
||||
## [Quiz före föreläsningen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
---
|
||||
|
||||
[](https://youtu.be/N6wxM4wZ7V0 "ML för nybörjare - Historien om maskininlärning")
|
||||
|
||||
> 🎥 Klicka på bilden ovan för en kort video som går igenom denna lektion.
|
||||
|
||||
I denna lektion kommer vi att gå igenom de viktigaste milstolparna i historien om maskininlärning och artificiell intelligens.
|
||||
|
||||
Historien om artificiell intelligens (AI) som forskningsområde är nära sammanflätad med historien om maskininlärning, eftersom de algoritmer och tekniska framsteg som ligger till grund för ML bidrog till utvecklingen av AI. Det är bra att komma ihåg att även om dessa områden som separata forskningsfält började ta form på 1950-talet, föregicks och överlappades denna era av viktiga [algoritmiska, statistiska, matematiska, beräkningsmässiga och tekniska upptäckter](https://wikipedia.org/wiki/Timeline_of_machine_learning). Faktum är att människor har funderat på dessa frågor i [hundratals år](https://wikipedia.org/wiki/History_of_artificial_intelligence): denna artikel diskuterar de historiska intellektuella grunderna för idén om en "tänkande maskin."
|
||||
|
||||
---
|
||||
## Viktiga upptäckter
|
||||
|
||||
- 1763, 1812 [Bayes sats](https://wikipedia.org/wiki/Bayes%27_theorem) och dess föregångare. Denna sats och dess tillämpningar ligger till grund för inferens och beskriver sannolikheten för att en händelse inträffar baserat på tidigare kunskap.
|
||||
- 1805 [Minsta kvadratmetoden](https://wikipedia.org/wiki/Least_squares) av den franske matematikern Adrien-Marie Legendre. Denna teori, som du kommer att lära dig om i vår Regression-enhet, hjälper till med dataanpassning.
|
||||
- 1913 [Markovkedjor](https://wikipedia.org/wiki/Markov_chain), uppkallad efter den ryske matematikern Andrey Markov, används för att beskriva en sekvens av möjliga händelser baserat på ett tidigare tillstånd.
|
||||
- 1957 [Perceptron](https://wikipedia.org/wiki/Perceptron) är en typ av linjär klassificerare uppfunnen av den amerikanske psykologen Frank Rosenblatt som ligger till grund för framsteg inom djupinlärning.
|
||||
|
||||
---
|
||||
|
||||
- 1967 [Närmaste granne](https://wikipedia.org/wiki/Nearest_neighbor) är en algoritm som ursprungligen designades för att kartlägga rutter. Inom ML används den för att upptäcka mönster.
|
||||
- 1970 [Backpropagation](https://wikipedia.org/wiki/Backpropagation) används för att träna [feedforward-nätverk](https://wikipedia.org/wiki/Feedforward_neural_network).
|
||||
- 1982 [Recurrent Neural Networks](https://wikipedia.org/wiki/Recurrent_neural_network) är artificiella neurala nätverk som härstammar från feedforward-nätverk och skapar temporala grafer.
|
||||
|
||||
✅ Gör lite research. Vilka andra datum sticker ut som avgörande i historien om ML och AI?
|
||||
|
||||
---
|
||||
## 1950: Maskiner som tänker
|
||||
|
||||
Alan Turing, en verkligen enastående person som [av allmänheten 2019](https://wikipedia.org/wiki/Icons:_The_Greatest_Person_of_the_20th_Century) röstades fram som 1900-talets största vetenskapsman, anses ha hjälpt till att lägga grunden för konceptet "en maskin som kan tänka." Han brottades med skeptiker och sitt eget behov av empiriska bevis för detta koncept, bland annat genom att skapa [Turingtestet](https://www.bbc.com/news/technology-18475646), som du kommer att utforska i våra NLP-lektioner.
|
||||
|
||||
---
|
||||
## 1956: Dartmouth Summer Research Project
|
||||
|
||||
"Dartmouth Summer Research Project on artificial intelligence var en avgörande händelse för artificiell intelligens som forskningsområde," och det var här termen "artificiell intelligens" myntades ([källa](https://250.dartmouth.edu/highlights/artificial-intelligence-ai-coined-dartmouth)).
|
||||
|
||||
> Varje aspekt av lärande eller någon annan egenskap hos intelligens kan i princip beskrivas så exakt att en maskin kan göras för att simulera den.
|
||||
|
||||
---
|
||||
|
||||
Huvudforskaren, matematikprofessorn John McCarthy, hoppades "att gå vidare på grundval av hypotesen att varje aspekt av lärande eller någon annan egenskap hos intelligens i princip kan beskrivas så exakt att en maskin kan göras för att simulera den." Deltagarna inkluderade en annan framstående person inom området, Marvin Minsky.
|
||||
|
||||
Workshoppen anses ha initierat och uppmuntrat flera diskussioner, inklusive "framväxten av symboliska metoder, system fokuserade på begränsade domäner (tidiga expertsystem) och deduktiva system kontra induktiva system." ([källa](https://wikipedia.org/wiki/Dartmouth_workshop)).
|
||||
|
||||
---
|
||||
## 1956 - 1974: "De gyllene åren"
|
||||
|
||||
Från 1950-talet till mitten av 70-talet var optimismen hög kring hoppet att AI kunde lösa många problem. 1967 uttalade Marvin Minsky självsäkert att "Inom en generation ... kommer problemet med att skapa 'artificiell intelligens' i stort sett att vara löst." (Minsky, Marvin (1967), Computation: Finite and Infinite Machines, Englewood Cliffs, N.J.: Prentice-Hall)
|
||||
|
||||
Forskning inom naturlig språkbehandling blomstrade, sökning förfinades och blev mer kraftfull, och konceptet "mikrovärldar" skapades, där enkla uppgifter utfördes med hjälp av instruktioner på vanligt språk.
|
||||
|
||||
---
|
||||
|
||||
Forskningen finansierades väl av statliga organ, framsteg gjordes inom beräkning och algoritmer, och prototyper av intelligenta maskiner byggdes. Några av dessa maskiner inkluderar:
|
||||
|
||||
* [Shakey the robot](https://wikipedia.org/wiki/Shakey_the_robot), som kunde manövrera och besluta hur uppgifter skulle utföras "intelligent".
|
||||
|
||||
|
||||
> Shakey år 1972
|
||||
|
||||
---
|
||||
|
||||
* Eliza, en tidig "chatterbot", kunde samtala med människor och fungera som en primitiv "terapeut". Du kommer att lära dig mer om Eliza i NLP-lektionerna.
|
||||
|
||||
|
||||
> En version av Eliza, en chatbot
|
||||
|
||||
---
|
||||
|
||||
* "Blocks world" var ett exempel på en mikrovärld där block kunde staplas och sorteras, och experiment i att lära maskiner att fatta beslut kunde testas. Framsteg byggda med bibliotek som [SHRDLU](https://wikipedia.org/wiki/SHRDLU) hjälpte till att driva språkbehandling framåt.
|
||||
|
||||
[](https://www.youtube.com/watch?v=QAJz4YKUwqw "blocks world med SHRDLU")
|
||||
|
||||
> 🎥 Klicka på bilden ovan för en video: Blocks world med SHRDLU
|
||||
|
||||
---
|
||||
## 1974 - 1980: "AI-vintern"
|
||||
|
||||
I mitten av 1970-talet blev det uppenbart att komplexiteten i att skapa "intelligenta maskiner" hade underskattats och att dess löften, givet den tillgängliga beräkningskraften, hade överdrivits. Finansieringen torkade upp och förtroendet för området minskade. Några problem som påverkade förtroendet inkluderade:
|
||||
---
|
||||
- **Begränsningar**. Beräkningskraften var för begränsad.
|
||||
- **Kombinatorisk explosion**. Antalet parametrar som behövde tränas växte exponentiellt när mer krävdes av datorer, utan en parallell utveckling av beräkningskraft och kapacitet.
|
||||
- **Brist på data**. Det fanns en brist på data som hindrade processen att testa, utveckla och förfina algoritmer.
|
||||
- **Ställer vi rätt frågor?**. Själva frågorna som ställdes började ifrågasättas. Forskare började möta kritik kring sina tillvägagångssätt:
|
||||
- Turingtestet ifrågasattes bland annat genom teorin om "den kinesiska rummet", som hävdade att "programmering av en digital dator kan få den att verka förstå språk men kan inte producera verklig förståelse." ([källa](https://plato.stanford.edu/entries/chinese-room/))
|
||||
- Etiken kring att introducera artificiella intelligenser som "terapeuten" ELIZA i samhället utmanades.
|
||||
|
||||
---
|
||||
|
||||
Samtidigt började olika AI-skolor bildas. En dikotomi etablerades mellan ["scruffy" vs. "neat AI"](https://wikipedia.org/wiki/Neats_and_scruffies) metoder. _Scruffy_-labb justerade program i timmar tills de fick önskade resultat. _Neat_-labb "fokuserade på logik och formell problemlösning". ELIZA och SHRDLU var välkända _scruffy_-system. På 1980-talet, när efterfrågan på att göra ML-system reproducerbara ökade, tog _neat_-metoden gradvis ledningen eftersom dess resultat är mer förklarbara.
|
||||
|
||||
---
|
||||
## 1980-talets expertsystem
|
||||
|
||||
När området växte blev dess nytta för företag tydligare, och på 1980-talet ökade också spridningen av "expertsystem". "Expertsystem var bland de första verkligt framgångsrika formerna av artificiell intelligens (AI)-programvara." ([källa](https://wikipedia.org/wiki/Expert_system)).
|
||||
|
||||
Denna typ av system är faktiskt _hybrid_, bestående delvis av en regelmotor som definierar affärskrav och en inferensmotor som utnyttjar regelsystemet för att härleda nya fakta.
|
||||
|
||||
Denna era såg också ökat fokus på neurala nätverk.
|
||||
|
||||
---
|
||||
## 1987 - 1993: AI "kyla"
|
||||
|
||||
Spridningen av specialiserad hårdvara för expertsystem hade den olyckliga effekten att bli för specialiserad. Framväxten av persondatorer konkurrerade också med dessa stora, specialiserade, centraliserade system. Demokratiseringen av databehandling hade börjat, och den banade så småningom väg för den moderna explosionen av big data.
|
||||
|
||||
---
|
||||
## 1993 - 2011
|
||||
|
||||
Denna epok såg en ny era för ML och AI att kunna lösa några av de problem som tidigare orsakats av bristen på data och beräkningskraft. Mängden data började snabbt öka och bli mer tillgänglig, på gott och ont, särskilt med framväxten av smarttelefonen runt 2007. Beräkningskraften expanderade exponentiellt, och algoritmer utvecklades parallellt. Fältet började mogna när de fria dagarna från det förflutna började kristalliseras till en verklig disciplin.
|
||||
|
||||
---
|
||||
## Nu
|
||||
|
||||
Idag berör maskininlärning och AI nästan alla delar av våra liv. Denna era kräver noggrann förståelse för riskerna och de potentiella effekterna av dessa algoritmer på människors liv. Som Microsofts Brad Smith har sagt, "Informationsteknologi väcker frågor som går till kärnan av grundläggande mänskliga rättigheter som integritet och yttrandefrihet. Dessa frågor ökar ansvaret för teknikföretag som skapar dessa produkter. Enligt vår uppfattning kräver de också genomtänkt statlig reglering och utveckling av normer kring acceptabla användningar" ([källa](https://www.technologyreview.com/2019/12/18/102365/the-future-of-ais-impact-on-society/)).
|
||||
|
||||
---
|
||||
|
||||
Det återstår att se vad framtiden har att erbjuda, men det är viktigt att förstå dessa datorsystem och den programvara och de algoritmer de kör. Vi hoppas att denna kursplan hjälper dig att få en bättre förståelse så att du kan bestämma själv.
|
||||
|
||||
[](https://www.youtube.com/watch?v=mTtDfKgLm54 "Historien om djupinlärning")
|
||||
> 🎥 Klicka på bilden ovan för en video: Yann LeCun diskuterar historien om djupinlärning i denna föreläsning
|
||||
|
||||
---
|
||||
## 🚀Utmaning
|
||||
|
||||
Gräv djupare i ett av dessa historiska ögonblick och lär dig mer om personerna bakom dem. Det finns fascinerande karaktärer, och ingen vetenskaplig upptäckt har någonsin skapats i ett kulturellt vakuum. Vad upptäcker du?
|
||||
|
||||
## [Quiz efter föreläsningen](https://ff-quizzes.netlify.app/en/ml/)
|
||||
|
||||
---
|
||||
## Granskning & Självstudier
|
||||
|
||||
Här är saker att titta på och lyssna på:
|
||||
|
||||
[Denna podcast där Amy Boyd diskuterar AI:s utveckling](http://runasradio.com/Shows/Show/739)
|
||||
|
||||
[](https://www.youtube.com/watch?v=EJt3_bFYKss "Historien om AI av Amy Boyd")
|
||||
|
||||
---
|
||||
|
||||
## Uppgift
|
||||
|
||||
[Skapa en tidslinje](assignment.md)
|
||||
|
||||
---
|
||||
|
||||
**Ansvarsfriskrivning**:
|
||||
Detta dokument har översatts med hjälp av AI-översättningstjänsten [Co-op Translator](https://github.com/Azure/co-op-translator). Även om vi strävar efter noggrannhet, bör det noteras att automatiska översättningar kan innehålla fel eller felaktigheter. Det ursprungliga dokumentet på dess originalspråk bör betraktas som den auktoritativa källan. För kritisk information rekommenderas professionell mänsklig översättning. Vi ansvarar inte för eventuella missförstånd eller feltolkningar som uppstår vid användning av denna översättning.
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue