> ### [Denne lektion findes på R!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
> ### [Denne lektion findes også i R!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
### Introduktion
Indtil nu har du udforsket, hvad regression er med prøve-data indsamlet fra græskarpris-datasættet, som vi vil bruge igennem hele denne lektion. Du har også visualiseret det ved hjælp af Matplotlib.
Indtil nu har du undersøgt, hvad regression er med prøve data indsamlet fra græskarprisdatasetet, som vi vil bruge igennem denne lektion. Du har også visualiseret det ved hjælp af Matplotlib.
Nu er du klar til at dykke dybere ned i regression inden for ML. Mens visualisering gør det muligt at forstå data, kommer den egentlige kraft ved maskinlæring fra _træning af modeller_. Modeller trænes på historiske data for automatisk at fange dataafhængigheder, og de giver dig mulighed for at forudsige resultater for nye data, som modellen ikke har set før.
Nu er du klar til at dykke dybere ned i regression for ML. Mens visualisering giver dig mulighed for at forstå data, kommer den virkelige styrke ved Maskinlæring fra _at træne modeller_. Modeller trænes på historiske data for automatisk at fange dataafhængigheder, og de giver dig mulighed for at forudsige resultater for nye data, som modellen ikke har set før.
I denne lektion vil du lære mere om to typer regression: _basal lineær regression_ og _polynomiel regression_, sammen med noget af den matematik, der ligger til grund for disse teknikker. Disse modeller vil give os mulighed for at forudsige græskarpriser afhængigt af forskellige inputdata.
I denne lektion vil du lære mere om to typer regression: _basis lineær regression_ og _polynomiel regression_, sammen med noget af den matematik, der ligger til grund for disse teknikker. Disse modeller vil gøre det muligt for os at forudsige græskarpriser afhængigt af forskellige inputdata.
[](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression")
[](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression")
> 🎥 Klik på billedet ovenfor for en kort videooversigt over lineær regression.
> I hele dette pensum antager vi minimal matematikkundskab og søger at gøre det tilgængeligt for studerende med baggrund fra andre felter, så hold øje med noter, 🧮 forklaringer, diagrammer og andre læringsværktøjer til hjælp med forståelsen.
> Gennem hele dette pensum antager vi minimal kendskab til matematik og søger at gøre det tilgængeligt for studerende fra andre fagområder, så hold øje med noter, 🧮 opkald, diagrammer og andre læringsværktøjer for at hjælpe forståelsen.
### Forudsætning
Du bør nu være bekendt med strukturen i græskardataene, som vi undersøger. Du kan finde det forudindlæst og forudrense i denne lektions _notebook.ipynb_-fil. I filen vises græskarprisen pr. bushel i en ny data frame. Sørg for, at du kan køre disse notebooks i kerner i Visual Studio Code.
Du bør nu være fortrolig med strukturen af græskardataene, som vi undersøger. Du finder dem forudindlæst og renset i denne lektions _notebook.ipynb_-fil. I filen vises græskarprisen per bushel i en ny data frame. Sørg for, at du kan køre disse notebooks i kerner i Visual Studio Code.
### Forberedelse
Som en påmindelse læser du disse data ind for at kunne stille spørgsmål til dem.
Som en påmindelse,indlæser du disse data for at kunne stille spørgsmål til dem.
- Hvornår er det bedste tidspunkt at købe græskar?
- Hvilken pris kan jeg forvente for en kasse miniaturegræskar?
- Skal jeg købe dem i halvbushel-kurve eller i 1 1/9 bushel-kasser?
- Skal jeg købe dem i halvbustkurve eller i 1 1/9 bushel kasser?
Lad os fortsætte med at grave i disse data.
Lad os blive ved med at grave i disse data.
I den forrige lektion oprettede du en Pandas data frame og fyldte den med en del af det oprindelige datasæt, standardiseret prisen pr. bushel. Ved at gøre det var du dog kun i stand til at samle omkring 400 datapunktoplysninger og kun for efterårsmånederne.
I den foregående lektion oprettede du en Pandas data frame og fyldte den med en del af det oprindelige datasæt, hvor priserne blev standardiseret pr. bushel. Ved at gøre det kunne du dog kun samle omkring 400 datapunkter og kun for efterårsmånederne.
Tag et kig på de data, vi forudindlæste i denne lektions ledsagende notebook. Dataene er forudindlæst, og et indledende spredningsdiagram er tegnet for at vise månedsdata. Måske kan vi få lidt mere indsigt i dataenes natur ved at rense det yderligere.
Tag et kig på dataene, som vi forudindlæste i denne lektions ledsagende notebook. Dataene er forindlæst, og et initialt spredningsdiagram er vist for månedsdata. Måske kan vi få lidt flere detaljer om dataenes natur ved at rense dem mere.
## En lineær regressionslinje
Som du lærte i Lektion 1, er målet med en lineær regressionsøvelse at kunne plotte en linje for at:
Som du lærte i Lektion 1, er målet med en lineær regressionsøvelse at kunne plotte en linje til at:
- **Vise variabelrelationer**. Vise forholdet mellem variable
- **Foretage forudsigelser**. Foretage præcise forudsigelser om, hvor et nyt datapunkt vil falde i forhold til den linje.
- **Vis variable relationer**. Vis forholdet mellem variable
- **Foretage forudsigelser**. Lav nøjagtige forudsigelser om, hvor et nyt datapunkt vil falde i forhold til den linje.
Det er typisk for **Minste Kvadraters Regression** at tegne denne type linje. Udtrykket "Minste Kvadrater" henviser til processen med at minimere den samlede fejl i vores model. For hvert datapunkt måler vi den lodrette afstand (kaldet residual) mellem det faktiske punkt og vores regressionslinje.
Det er typisk for **Mindste Kvadraters Regression** at tegne denne type linje. Udtrykket "Mindste Kvadraters" refererer til processen med at minimere den samlede fejl i vores model. For hvert datapunkt måler vi den lodrette afstand (kaldet residual) mellem det faktiske punkt og vores regressionslinje.
Vi kvadrerer disse afstande af to hovedårsager:
1. **Størrelse frem for retning:** Vi vil behandle en fejl på -5 på samme måde som en fejl på +5. Kvadrering gør alle værdier positive.
2. **Straffe for afvigere:** Kvadrering giver større vægt til større fejl og tvinger linjen til at holde sig tættere på punkter, som er langt væk.
2. **Straffe Udliggere:** Kvadrering giver større vægt til større fejl, hvilket tvinger linjen til at være tættere på punkter, der ligger langt væk.
Derefter lægger vi alle disse kvadrerede værdier sammen. Vores mål er at finde den specifikke linje, hvor dette endelige summen er mindst (mindste mulige værdi)—deraf navnet "Minste Kvadrater".
Vi lægger så alle disse kvadrerede værdier sammen. Vores mål er at finde den specifikke linje, hvor dette endelige sum er mindst (den mindste mulige værdi)—deraf navnet "Mindste Kvadraters".
> **🧮 Vis mig matematikken**
>
> Denne linje, kaldet _den bedste tilpassede linje_, kan udtrykkes ved [en ligning](https://en.wikipedia.org/wiki/Simple_linear_regression):
>
> **🧮 Vis mig matematikken**
>
> Denne linje, kaldet _line of best fit_, kan udtrykkes ved [et ligning](https://en.wikipedia.org/wiki/Simple_linear_regression):
>
> ```
> Y = a + bX
> ```
>
> `X` er den 'forklarende variabel'. `Y` er den 'afhængige variabel'. Hældningen af linjen er `b` og `a` er skæringspunktet med y-aksen, hvilket henviser til værdien af `Y` når `X = 0`.
> Først beregnes hældningen `b`. Infografik af [Jen Looper](https://twitter.com/jenlooper)
>
> Med andre ord, og med henvisning til vores græskardatas oprindelige spørgsmål: "forudsig prisen på et græskar pr. bushel efter måned", ville `X` referere til prisen og `Y` henvise til salgs-måneden.
> Beregn værdien af Y. Hvis du betaler omkring 4 $, må det være april! Infografik af [Jen Looper](https://twitter.com/jenlooper)
>
> Matematikken, der beregner linjen, skal demonstrere hældningen på linjen, som også afhænger af skæringspunktet, eller hvor `Y` er placeret, når `X = 0`.
>
> Du kan se beregningsmetoden for disse værdier på [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html) websitet. Besøg også [denne mindst-kvadrater-lommeregner](https://www.mathsisfun.com/data/least-squares-calculator.html) for at se, hvordan værdiernes tal påvirker linjen.
>
> `X` er den 'forklarende variabel'. `Y` er den 'afhængige variabel'. Linjens hældning er `b` og `a` er y-aksens skæringspunkt, hvilket refererer til værdien af `Y`, når `X = 0`.
> Først beregnes hældningen `b`. Infografik af [Jen Looper](https://twitter.com/jenlooper)
>
> Med andre ord, og med henvisning til vores græskardata oprindelige spørgsmål: "forudsig prisen på et græskar per bushel pr. måned", ville `X` referere til prisen og `Y` ville referere til salgs måneden.
> Beregn værdien af Y. Hvis du betaler omkring $4, må det være april! Infografik af [Jen Looper](https://twitter.com/jenlooper)
>
> Den matematik, der beregner linjen, skal demonstrere linjens hældning, som også afhænger af skæringspunktet, eller hvor `Y` befinder sig, når `X = 0`.
>
> Du kan iagttage metoden til beregning af disse værdier på webstedet [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html). Besøg også [denne Mindste Kvadraters regnemaskine](https://www.mathsisfun.com/data/least-squares-calculator.html) for at se, hvordan talværdier påvirker linjen.
## Korrelation
Et begreb mere at forstå er **Korrelationskoefficienten** mellem givne X- og Y-variable. Ved hjælp af et spredningsdiagram kan du hurtigt visualisere denne koefficient. En graf med datapunkter spredt i en pæn linje har høj korrelation, mens en graf med datapunkter spredt overalt mellem X og Y har lav korrelation.
Endnu et begreb, der skal forstås, er **korrelationskoefficienten** mellem givne X og Y variable. Ved at bruge et spredningsdiagram kan du hurtigt visualisere denne koefficient. En plot med datapunkter, der er spredt i en pæn linje, har høj korrelation, men en plot med datapunkter spredt tilfældigt mellem X og Y har lav korrelation.
En god lineær regressionsmodel vil være en, der har en høj (tættere på 1 end 0) korrelationskoefficient ved brug af Minste Kvadraters-regressionsmetoden med en regressionslinje.
En god lineær regressionsmodel vil være en, der har en høj (tættere på 1 end 0) korrelationskoefficient ved brug af Mindste Kvadraters Regression med en regressionslinje.
✅ Kør notebook'en til denne lektion og se på spredningsdiagrammet for måned og pris. Virker dataene, der forbinder måned til pris for græskarsalg, til at have høj eller lav korrelation baseret på din visuelle fortolkning af spredningsdiagrammet? Ændres det, hvis du bruger en mere finmasket måling i stedet for `Month`, f.eks. *dag på året* (dvs. antal dage siden årets start)?
✅ Kør notebook'en, der ledsager denne lektion, og se på spredningsdiagrammet fra måned til pris. Ser data, der forbinder måned og pris for græskar salg, ud til at have høj eller lav korrelation ifølge din visuelle fortolkning af spredningsdiagrammet? Ændrer det sig, hvis du bruger en mere finmasket måling i stedet for `Month`, fx *dag i året* (dvs. antal dage siden årets start)?
I koden nedenfor antager vi, at vi har renset dataene og opnået en data frame kaldet `new_pumpkins`, som ligner følgende:
I koden nedenfor vil vi antage, at vi har renset dataene og opnået en data frame kaldet `new_pumpkins`, der ligner følgende:
ID | Måned | DagPåÅret | Sort | By | Pakke | Lav Pris | Høj Pris | Pris
> Koden til at rense dataene findes i [`notebook.ipynb`](notebook.ipynb). Vi har udført de samme rensningsskridt som i den foregående lektion og har beregnet `DayOfYear` kolonnen ved hjælp af følgende udtryk:
> Koden til at rense dataene findes i [`notebook.ipynb`](notebook.ipynb). Vi har foretaget de samme rensetrin som i den tidligere lektion og har beregnet kolonnen `DayOfYear` ved hjælp af følgende udtryk:
Nu hvor du har en forståelse for matematikken bag lineær regression, lad os oprette en regressionsmodel for at se, om vi kan forudsige, hvilken pakke med græskar der vil have de bedste priser. En person, der køber græskar til en ferie-græskarmark, kunne have brug for denne information for at optimere deres køb af græskarpakker til markedet.
## Søger efter korrelation
Nu hvor du har en forståelse af matematikken bag lineær regression, lad os oprette en regressionsmodel for at se, om vi kan forudsige, hvilken pakke af græskar der vil have de bedste græskarpriser. Nogen, der køber græskar til en feriegræskarmark, vil måske bruge disse oplysninger til at optimere deres køb af græskarpakker til marken.
## Leder efter korrelation
[](https://youtu.be/uoRq-lW2eQo "ML for beginners - Looking for Correlation: The Key to Linear Regression")
[](https://youtu.be/uoRq-lW2eQo "ML for beginners - Looking for Correlation: The Key to Linear Regression")
> 🎥 Klik på billedet ovenfor for en kort videooversigt over korrelation.
Fra den foregående lektion har du sandsynligvis set, at gennemsnitsprisen for forskellige måneder ser sådan ud:
Fra den forrige lektion har du sandsynligvis set, at gennemsnitsprisen for forskellige måneder ser sådan ud:
<imgalt="Gennemsnitspris efter måned" src="../../../../translated_images/da/barchart.a833ea9194346d76.webp"width="50%"/>
<imgalt="Average price by month" src="../../../../translated_images/da/barchart.a833ea9194346d76.webp"width="50%"/>
Dette tyder på, at der burde være en vis korrelation, og vi kan prøve at træne en lineær regressionsmodel til at forudsige forholdet mellem `Month` og `Price`, eller mellem `DayOfYear` og `Price`. Her er spredningsdiagrammet, der viser sidstnævnte forhold:
Dette antyder, at der bør være en vis korrelation, og vi kan prøve at træne en lineær regressionsmodel for at forudsige forholdet mellem `Month` og `Price`, eller mellem `DayOfYear` og `Price`. Her er spredningsdiagrammet, der viser det sidste forhold:
<imgalt="Spredningsdiagram over pris vs. dag på året" src="../../../../translated_images/da/scatter-dayofyear.bc171c189c9fd553.webp"width="50%"/>
<imgalt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/da/scatter-dayofyear.bc171c189c9fd553.webp"width="50%"/>
Lad os se, om der er en korrelation ved hjælp af `corr` funktionen:
Lad os se, om der er korrelation ved hjælp af `corr` funktionen:
Det ser ud til, at korrelationen er ret lille, -0.15 for `Month` og -0.17 for `DayOfMonth`, men der kunne være en anden vigtig sammenhæng. Det ser ud til, at der er forskellige grupper af priser svarende til forskellige græskarsorter. For at bekræfte denne hypotese, lad os plotte hver græskarkategori med en anden farve. Ved at sende en `ax` parameter til `scatter` plotting-funktionen kan vi plotte alle punkter på samme graf:
Det ser ud til, at korrelationen er ret lille, -0,15 for `Month` og -0,17 for `DayOfMonth`, men der kunne være en anden vigtig sammenhæng. Det ser ud til, at der er forskellige klynger af priser, der svarer til forskellige græskartyper. For at bekræfte denne hypotese, lad os plotte hver græskarkategori med en forskellig farve. Ved at sende en `ax` parameter til `scatter` plotfunktionen kan vi plotte alle punkter i det samme diagram:
```python
ax=None
@ -140,113 +139,114 @@ for i,var in enumerate(new_pumpkins['Variety'].unique()):
<imgalt="Spredningsdiagram over pris vs. dag på året" src="../../../../translated_images/da/pie-pumpkins-scatter.d14f9804a53f927e.webp"width="50%"/>
<imgalt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/da/pie-pumpkins-scatter.d14f9804a53f927e.webp"width="50%"/>
Hvis vi nu beregner korrelationen mellem `Price` og `DayOfYear` ved hjælp af `corr` funktionen, får vi noget i retning af `-0.27` - hvilket betyder, at det giver mening at træne en forudsigelsesmodel.
Hvis vi nu beregner korrelationen mellem `Price` og `DayOfYear` ved hjælp af `corr` funktionen, får vi noget i retning af `-0.27` - hvilket betyder, at træning af en forudsigelsesmodel giver mening.
> Før vi træner en lineær regressionsmodel, er det vigtigt at sikre, at vores data er rensede. Lineær regression fungerer ikke godt med manglende værdier, så det giver mening at fjerne alle tomme celler:
> Før du træner en lineær regressionsmodel, er det vigtigt at sikre, at vores data er rene. Lineær regression fungerer ikke godt med manglende værdier, derfor giver det mening at fjerne alle tomme celler:
```python
pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info()
```
En anden tilgang ville være at udfylde de tomme værdier med gennemsnitsværdier fra den tilsvarende kolonne.
## Simpel lineær regression
En anden tilgang ville være at udfylde disse tomme værdier med gennemsnitsværdier fra den tilsvarende kolonne.
## Simple Lineær Regression
[](https://youtu.be/e4c_UP2fSjg "ML for beginners - Linear and Polynomial Regression using Scikit-learn")
[](https://youtu.be/e4c_UP2fSjg "ML for beginners - Linear and Polynomial Regression using Scikit-learn")
> 🎥 Klik på billedet ovenfor for en kort videooversigt over lineær og polynomiel regression.
For at træne vores lineære regressionsmodel vil vi bruge **Scikit-learn** biblioteket.
For at træne vores Lineær Regressionsmodel vil vi bruge **Scikit-learn** biblioteket.
```python
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
```
Vi starter med at adskille inputværdier (features) og den forventede output (label) i separate numpy-arrays:
Vi starter med at adskille inputværdierne (funktioner) og det forventede output (etiket) i separate numpy-arrays:
```python
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price']
```
> Bemærk, at vi var nødt til at udføre `reshape` på inputdataene, for at Linear Regression-pakken kunne forstå dem korrekt. Lineær Regression forventer et 2D-array som input, hvor hver række af arrayet svarer til en vektor af inputfunktioner. I vores tilfælde, da vi kun har én input, har vi brug for et array med form N×1, hvor N er datamængdens størrelse.
Derefter skal vi splitte dataene op i trænings- og testdatasæt, så vi kan validere vores model efter træning:
> Bemærk, at vi var nødt til at udføre `reshape` på inputdataene, for at Linear Regression-pakken kunne forstå det korrekt. Lineær Regression forventer et 2D-array som input, hvor hver række i arrayet svarer til en vektor af inputfunktioner. I vores tilfælde, hvor vi kun har én input - har vi brug for et array med form N×1, hvor N er datasætstørrelsen.
Dernæst skal vi opdele dataene i trænings- og testdatasæt, så vi kan validere vores model efter træning:
```python
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```
Endelig tager træningen af den faktiske lineære regressionsmodel kun to kodelinjer. Vi definerer et `LinearRegression`-objekt og fitter det til vores data ved hjælp af `fit`-metoden:
Endelig tager træningen af den faktiske Lineær Regression-model kun to kode linjer. Vi definerer `LinearRegression`-objektet og tilpasser det til vores data ved brug af `fit`metoden:
```python
lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)
```
`LinearRegression`-objektet efter `fit`-ning indeholder alle koefficienterne for regressionen, som kan tilgås ved hjælp af `.coef_`-egenskaben. I vores tilfælde er der kun én koefficient, som burde være omkring `-0.017`. Det betyder, at priserne tilsyneladende falder lidt over tid, men ikke for meget, omkring 2 cent per dag. Vi kan også tilgå skæringspunktet for regressionen med Y-aksen ved hjælp af `lin_reg.intercept_` - det vil være omkring `21` i vores tilfælde, hvilket angiver prisen i begyndelsen af året.
`LinearRegression`-objektet efter at være blevet `fit`-tet indeholder alle regressionskoefficienterne, som kan tilgås via `.coef_`-egenskaben. I vores tilfælde er der kun én koefficient, som skulle være omkring `-0.017`. Det betyder, at priserne ser ud til at falde en smule med tiden, men ikke meget, cirka 2 cent per dag. Vi kan også tilgå skæringspunktet med Y-aksen via `lin_reg.intercept_` - det vil være omkring `21` i vores tilfælde, hvilket indikerer prisen i begyndelsen af året.
For at se hvor nøjagtig vores model er, kan vi forudsige priser på et testdatasæt, og derefter måle hvor tæt vores forudsigelser er på de forventede værdier. Dette kan gøres ved hjælp af mean square error (MSE) målemetrik, som er gennemsnittet af alle kvadrerede forskelle mellem forventede og forudsagte værdier.
For at se, hvor præcis vores model er, kan vi forudsige priser på et testdatasæt, og derefter måle, hvor tæt vores forudsigelser er på de forventede værdier. Dette kan gøres ved hjælp af root mean square error (RMSE) metrikken, som er kvadratroden af gennemsnittet af alle kvadrerede forskelle mellem forventet og forudsagt værdi.
Vores fejl ser ud til at være omkring 2 point, hvilket er ~17%. Ikke så godt. En anden indikator for modellens kvalitet er **determinationskoefficienten**, som kan opnås på denne måde:
Vores fejl ser ud til at være omkring 2 point, hvilket er ca. 17%. Ikke særlig godt. En anden indikator for modellens kvalitet er **determinationskoefficienten**, som kan opnås sådan her:
```python
score = lin_reg.score(X_train,y_train)
print('Model determination: ', score)
```
Hvis værdien er 0, betyder det, at modellen ikke tager inputdata i betragtning, og fungerer som den *værste lineære forudsigelse*, som simpelthen er gennemsnitsværdien af resultatet. Værdien 1 betyder, at vi perfekt kan forudsige alle forventede output. I vores tilfælde er koefficienten omkring 0,06, hvilket er ganske lavt.
Hvis værdien er 0, betyder det, at modellen ikke tager inputdata i betragtning og fungerer som den *værste lineære forudsigelse*, som blot er middelværdien af resultatet. Værdien 1 betyder, at vi kan forudsige alle forventede outputs perfekt. I vores tilfælde er koefficienten omkring 0.06, hvilket er ret lavt.
Vi kan også plotte testdata sammen med regressionslinjen for bedre at se, hvordan regressionen fungerer i vores tilfælde:
Vi kan også plotte testdataene sammen med regressionslinjen for bedre at se, hvordan regressionen fungerer i vores tilfælde:
En anden type lineær regression er polynomiel regression. Selvom der nogle gange er et lineært forhold mellem variabler - jo større græskar i volumen, desto højere pris - kan disse forhold til tider ikke plottes som et plan eller en lige linje.
En anden type lineær regression er polynomial regression. Mens der nogle gange er et lineært forhold mellem variabler – jo større græskar i volumen, jo højere pris – kan disse forhold nogle gange ikke plottes som et plan eller en ret linje.
✅ Her er [nogle flere eksempler](https://online.stat.psu.edu/stat501/lesson/9/9.8) på data, som kunne bruge polynomiel regression
✅ Her er [nogle flere eksempler](https://online.stat.psu.edu/stat501/lesson/9/9.8) på data, som kunne bruge polynomial regression.
Tag endnu et kig på forholdet mellem Dato og Pris. Ser dette scatterplot ud som om det nødvendigvis skal analyseres med en lige linje? Kan priser ikke svinge? I dette tilfælde kan du prøve polynomiel regression.
Tag et kig på forholdet mellem Dato og Pris. Ser dette scatterplot ud som om, det nødvendigvis skal analyseres med en lige linje? Kan priserne ikke svinge? I dette tilfælde kan du prøve polynomial regression.
✅ Polynomier er matematiske udtryk, som kan bestå af en eller flere variable og koefficienter
✅ Polynomier er matematiske udtryk, som kan bestå af en eller flere variable og koefficienter.
Polynomiel regression skaber en buet linje for bedre at tilpasse ikke-lineære data. I vores tilfælde, hvis vi medtager et kvadreret `DayOfYear`-variabel i inputdata, bør vi kunne tilpasse vores data med en parabolsk kurve, som vil have et minimum på et bestemt tidspunkt i løbet af året.
Polynomial regression laver en buet linje for bedre at passe til ikke-lineære data. I vores tilfælde, hvis vi inkluderer en kvadreret `DayOfYear`-variabel i inputdata, burde vi kunne tilpasse vores data med en parabolsk kurve, som vil have et minimum på et bestemt tidspunkt i løbet af året.
Scikit-learn inkluderer en nyttig [pipeline API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) til at kombinere forskellige trin i databehandlingen sammen. En **pipeline** er en kæde af **estimators**. I vores tilfælde vil vi skabe en pipeline, der først tilføjer polynomielle features til vores model, og derefter træner regressionen:
Scikit-learn inkluderer et nyttigt [pipeline API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) til at kombinere forskellige trin i databehandling. En **pipeline** er en kæde af **estimators**. I vores tilfælde vil vi oprette en pipeline, der først tilføjer polynomial features til vores model og derefter træner regressionen:
```python
from sklearn.preprocessing import PolynomialFeatures
At bruge `PolynomialFeatures(2)` betyder, at vi vil inkludere alle andengrads polynomier fra inputdata. I vores tilfælde betyder det blot `DayOfYear`<sup>2</sup>, men givet to inputvariable X og Y, vil dette tilføje X<sup>2</sup>, XY og Y<sup>2</sup>. Vi kan også bruge polynomier af højere grad, hvis vi ønsker det.
At bruge `PolynomialFeatures(2)` betyder, at vi vil inkludere alle andengradspolynomier fra inputdata. I vores tilfælde vil det bare betyde `DayOfYear`<sup>2</sup>, men givet to inputvariabler X og Y, vil dette tilføje X<sup>2</sup>, XY og Y<sup>2</sup>. Vi kan også bruge polynomier med højere grad, hvis vi ønsker.
Pipelines kan bruges på samme måde som det oprindelige `LinearRegression`-objekt, dvs. vi kan `fit` pipelinen og derefter bruge `predict` til at få forudsigelsesresultater. Her er grafen, der viser testdata og tilpasningskurven:
Pipelines kan bruges på samme måde som det originale `LinearRegression` objekt, dvs. vi kan `fit` pipelinen og derefter bruge `predict` til at få forudsigelserne. Her er grafen, der viser testdata og tilpasningskurven:
Med polynomiel regression kan vi opnå lidt lavere MSE og højere determination, men ikke signifikant. Vi skal tage andre features i betragtning!
Ved at bruge polynomial regression kan vi opnå en lidt lavere MSE og højere determinationskoefficient, men ikke signifikant. Vi skal tage andre features i betragtning!
> Du kan se, at de laveste græskarpriser observeres et sted omkring Halloween. Hvordan kan du forklare dette?
> Du kan se, at de laveste priser på græskar observeres omkring Halloween. Hvordan kan du forklare det?
🎃 Tillykke, du har netop skabt en model, der kan hjælpe med at forudsige prisen på tærtegræskar. Du kan sikkert gentage den samme procedure for alle græskartyper, men det ville være kedeligt. Lad os nu lære, hvordan vi tager græskarvariant i betragtning i vores model!
🎃 Tillykke, du har netop skabt en model, der kan hjælpe med at forudsige prisen på dessertgræskar. Du kan sandsynligvis gentage samme procedure for alle græskar-typer, men det ville være besværligt. Lad os nu lære, hvordan vi tager græskartype i betragtning i vores model!
## Kategoriske Features
I en ideel verden vil vi kunne forudsige priser for forskellige græskarvarianter ved hjælp af den samme model. Men `Variety`-kolonnen er lidt anderledes end kolonner som `Month`, fordi den indeholder ikke-numeriske værdier. Sådanne kolonner kaldes **kategoriske**.
I den ideelle verden ønsker vi at kunne forudsige priser for forskellige græskarsorter med samme model. Dog er kolonnen `Variety` lidt anderledes end kolonner som `Month`, fordi den indeholder ikke-numeriske værdier. Sådanne kolonner kaldes **kategoriske**.
[](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression")
[](https://youtu.be/DYGliioIAE0 "ML for begyndere - Kategoriske Feature Forudsigelser med Lineær Regression")
> 🎥 Klik på billedet ovenfor for en kort videooversigt over brugen af kategoriske features.
> 🎥 Klik på billedet ovenfor for en kort videooversigt om brug af kategoriske features.
Her kan du se, hvordan gennemsnitsprisen afhænger af variant:
Her kan du se, hvordan gennemsnitsprisen afhænger af sort:
<imgalt="Average price by variety"src="../../../../translated_images/da/price-by-variety.744a2f9925d9bcb4.webp"width="50%"/>
For at tage variant i betragtning, skal vi først konvertere den til numerisk form, eller **encode** den. Der er flere måder, vi kan gøre det på:
For at tage sort i betragtning skal vi først konvertere den til numerisk form eller **kode** den. Der er flere måder at gøre det på:
* Simpel **numerisk encoding** bygger en tabel over forskellige varianter og erstatter derefter variantnavnet med et indeks i tabellen. Dette er ikke den bedste ide for lineær regression, fordi lineær regression tager den faktiske numeriske værdi af indekset og lægger det til resultatet, multipliceret med en koefficient. I vores tilfælde er forholdet mellem indeksnummer og pris tydeligt ikke-lineært, selv hvis vi sørger for, at indeksene er ordnet på en bestemt måde.
* **One-hot encoding**vil erstatte `Variety`-kolonnen med 4 forskellige kolonner, en for hver variant. Hver kolonne vil indeholde `1`, hvis den tilsvarende række er af den givne variant, og `0` ellers. Det betyder, at der vil være fire koefficienter i lineær regression, én for hver græskarvariant, ansvarlig for "startpris" (eller snarere "ekstra pris") for netop denne variant.
* Simpel **numerisk kodning** bygger en tabel over forskellige sorter og erstatter så sortens navn med et indeks i denne tabel. Dette er ikke den bedste idé for lineær regression, fordi lineær regression tager den faktiske numeriske værdi af indekset og lægger det til resultatet vægtet med en koefficient. I vores tilfælde er forholdet mellem indeksnummer og pris klart ikke-lineært, selv hvis vi sørger for, at indeksene er ordnet på en bestemt måde.
* **One-hot encoding** erstatter`Variety`-kolonnen med 4 forskellige kolonner, én for hver sort. Hver kolonne indeholder `1`, hvis den tilsvarende række er af den pågældende sort, og `0` ellers. Det betyder, at der vil være fire koefficienter i den lineære regression, én for hver græskartype, som er ansvarlige for "startpris" (eller rettere "ekstra pris") for netop den sort.
Koden nedenfor viser, hvordan vi kan one-hot encode en variant:
Koden nedenfor viser, hvordan vi kan one-hot kode en sort:
```python
pd.get_dummies(new_pumpkins['Variety'])
```
ID | FAIRYTALE | MINIATURE | MIXED HEIRLOOM VARIETIES | PIE TYPE
For at træne lineær regression ved brug af one-hot encoded variant som input, skal vi blot initialisere `X` og `y` data korrekt:
For at træne lineær regression med one-hot kodet sort som input behøver vi bare at initialisere `X` og `y` korrekt:
```python
X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price']
```
Resten af koden er den samme, som vi brugte ovenfor til at træne lineær regression. Hvis du prøver det, vil du se, at mean squared error er omtrent det samme, men vi får en meget højere determinationskoefficient (~77%). For at få endnu mere præcise forudsigelser kan vi tage flere kategoriske features i betragtning, såvel som numeriske features, såsom `Month` eller `DayOfYear`. For at få et stort array af features kan vi bruge `join`:
Resten af koden er den samme som den, vi brugte ovenfor til at træne Lineær Regression. Hvis du prøver det, vil du se, at mean squared error er cirka den samme, men vi får en meget højere determinationskoefficient (~77%). For at få endnu mere præcise forudsigelser kan vi tage flere kategoriske features samt numeriske features som `Month` eller `DayOfYear` i betragtning. For at få en stor samlet feature-array kan vi bruge `join`:
```python
X = pd.get_dummies(new_pumpkins['Variety']) \
@ -319,25 +319,25 @@ X = pd.get_dummies(new_pumpkins['Variety']) \
.join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']
```
Her tager vi også højde for `City` og `Package` type, hvilket giver os MSE 2.84 (10%) og determinationskoefficient 0.94!
Her tager vi også hensyn til `City` og `Package`-type, hvilket giver os MSE 2,84 (10%) og determination 0,94!
## At samle det hele
## Sæt det hele sammen
For at lave den bedste model kan vi bruge kombinerede (one-hot encoded kategoriske + numeriske) data fra ovenstående eksempel sammen med polynomiel regression. Her er den komplette kode for din bekvemmelighed:
For at lave den bedste model kan vi bruge kombinerede (one-hot kodede kategoriske + numeriske) data fra ovenstående eksempel sammen med polynomial regression. Her er det komplette kodeeksempel for din bekvemmelighed:
```python
# opsæt træningsdata
# opret træningsdata
X = pd.get_dummies(new_pumpkins['Variety']) \
.join(new_pumpkins['Month']) \
.join(pd.get_dummies(new_pumpkins['City'])) \
.join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']
# lav trænings- og testopdeling
# lav trænings-testopdeling
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
Dette skulle give os den bedste determinationskoefficient på næsten 97%, og MSE=2,23 (~8% fejl i forudsigelsen).
Dette burde give os den bedste determinationskoefficient på næsten 97%, og MSE=2.23 (~8% fejl i forudsigelse).
| Model | MSE | Determination |
|-------|-----|---------------|
| `DayOfYear` Lineær | 2,77 (17,2%) | 0,07 |
| `DayOfYear` Polynomiel | 2,73 (17,0%) | 0,08 |
| `Variety` Lineær | 5,24 (19,7%) | 0,77 |
| Alle features Lineær | 2,84 (10,5%) | 0,94 |
| Alle features Polynomiel | 2,23 (8,25%) | 0,97 |
| `DayOfYear` Lineær | 2.77 (17.2%) | 0.07 |
| `DayOfYear` Polynomiel | 2.73 (17.0%) | 0.08 |
| `Variety` Lineær | 5.24 (19.7%) | 0.77 |
| Alle features Lineær | 2.84 (10.5%) | 0.94 |
| Alle features Polynomiel | 2.23 (8.25%) | 0.97 |
🏆 Godt klaret! Du har skabt fire regressionsmodeller i én lektion og forbedret modelkvaliteten til 97%. I den sidste sektion om regression vil du lære om logistisk regression til bestemmelse af kategorier.
🏆 Godt gået! Du har lavet fire regressionsmodeller i én lektion og forbedret modelkvaliteten til 97%. I den sidste del om regression vil du lære om logistisk regression til at bestemme kategorier.
---
## 🚀Udfordring
@ -371,7 +371,7 @@ Test flere forskellige variable i denne notesbog for at se, hvordan korrelation
## [Quiz efter lektionen](https://ff-quizzes.netlify.app/en/ml/)
## Gennemgang & Selvstudie
## Review & Selvlæring
I denne lektion lærte vi om lineær regression. Der findes andre vigtige typer regression. Læs om Stepwise, Ridge, Lasso og Elasticnet teknikker. Et godt kursus at studere for at lære mere er [Stanford Statistical Learning course](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning)
@ -383,5 +383,5 @@ I denne lektion lærte vi om lineær regression. Der findes andre vigtige typer
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Ansvarsfraskrivelse**:
Dette dokument er blevet oversat ved hjælp af AI-oversættelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selvom vi bestræber os på nøjagtighed, bedes du være opmærksom på, at automatiske oversættelser kan indeholde fejl eller unøjagtigheder. Det oprindelige dokument på dets modersmål bør betragtes som den autoritative kilde. For kritisk information anbefales professionel menneskelig oversættelse. Vi påtager os intet ansvar for eventuelle misforståelser eller fejltolkninger, der opstår som følge af brugen af denne oversættelse.
Dette dokument er oversat ved hjælp af AI-oversættelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selvom vi bestræber os på nøjagtighed, bedes du være opmærksom på, at automatiserede oversættelser kan indeholde fejl eller unøjagtigheder. Det originale dokument på dets modersmål bør betragtes som den autoritative kilde. For kritisk information anbefales en professionel menneskelig oversættelse. Vi påtager os intet ansvar for misforståelser eller fejltolkninger, der opstår som følge af brugen af denne oversættelse.
I denne lektion vil du bruge det datasæt, du gemte fra den sidste lektion, fyldt med balancerede og rene data om køkkener.
I denne lektion vil du bruge datasættet, du gemte fra sidste lektion, fyldt med balancerede, rene data om køkkener.
Du vil bruge dette datasæt med en række klassifikatorer til _at forudsige et givet nationalt køkken baseret på en gruppe ingredienser_. Mens du gør dette, vil du lære mere om nogle af de måder, algoritmer kan bruges til klassifikationsopgaver.
Du vil bruge dette datasæt med en række klassifikatorer til at _forudsige en given national køkken baseret på en gruppe ingredienser_. Mens du gør det, vil du lære mere om nogle af de måder, algoritmer kan udnyttes til klassifikationsopgaver.
## [Quiz før lektionen](https://ff-quizzes.netlify.app/en/ml/)
Forudsat at du har gennemført [Lektion 1](../1-Introduction/README.md), skal du sikre dig, at en _cleaned_cuisines.csv_-fil findes i rodmappen `/data` for disse fire lektioner.
Forudsat at du har gennemført [Lektion 1](../1-Introduction/README.md), skal du sikre dig, at en _cleaned_cuisines.csv_-fil findes i den øverste `/data`-mappe til disse fire lektioner.
## Øvelse - forudsige et nationalt køkken
1. Arbejd i denne lektions _notebook.ipynb_-mappe, og importer filen sammen med Pandas-biblioteket:
1. Arbejd i denne lektions _notebook.ipynb_ mappe, importer den fil sammen med Pandas-biblioteket:
```python
import pandas as pd
@ -40,7 +40,7 @@ Forudsat at du har gennemført [Lektion 1](../1-Introduction/README.md), skal du
import numpy as np
```
1. Del X- og y-koordinaterne op i to dataframes til træning. `cuisine` kan være labels-dataframen:
1. Del X og y koordinaterne i to dataframes til træning. `cuisine` kan være labels dataframe:
```python
cuisines_label_df = cuisines_df['cuisine']
@ -58,14 +58,14 @@ Forudsat at du har gennemført [Lektion 1](../1-Introduction/README.md), skal du
Name: cuisine, dtype: object
```
1. Fjern kolonnen `Unnamed: 0` og kolonnen `cuisine` ved at kalde `drop()`. Gem resten af dataene som træningsfunktioner:
1. Drop den `Unnamed: 0` kolonne og `cuisine` kolonnen ved at kalde `drop()`. Gem resten af dataene som trænbar features:
@ -79,71 +79,71 @@ Nu er du klar til at træne din model!
## Valg af klassifikator
Nu hvor dine data er rene og klar til træning, skal du beslutte, hvilken algoritme du vil bruge til opgaven.
Nu hvor dine data er rene og klar til træning, skal du beslutte, hvilken algoritme der skal bruges til opgaven.
Scikit-learn grupperer klassifikation under Supervised Learning, og i den kategori finder du mange måder at klassificere på. [Udvalget](https://scikit-learn.org/stable/supervised_learning.html) kan virke overvældende ved første øjekast. Følgende metoder inkluderer alle klassifikationsteknikker:
Scikit-learn grupperer klassifikation under Superviseret læring, og i den kategori finder du mange måder at klassificere på. [Variationerne](https://scikit-learn.org/stable/supervised_learning.html) kan virke overvældende ved første øjekast. Følgende metoder indeholder alle klassifikationsteknikker:
- Lineære modeller
- Support Vector Machines
- Stokastisk gradientnedstigning
- Stochastic Gradient Descent
- Nærmeste naboer
- Gaussian-processer
- Gaussiske processer
- Beslutningstræer
- Ensemble-metoder (voting Classifier)
- Multiclass- og multioutput-algoritmer (multiclass- og multilabel-klassifikation, multiclass-multioutput-klassifikation)
- Ensemblemetoder (votingsklassifikator)
- Multiklasse- og multioutput-algoritmer (multiklasse- og multilabel-klassifikation, multiklasse-multioutput-klassifikation)
> Du kan også bruge [neural netværk til at klassificere data](https://scikit-learn.org/stable/modules/neural_networks_supervised.html#classification), men det ligger uden for denne lektions omfang.
> Du kan også bruge [neurale netværk til at klassificere data](https://scikit-learn.org/stable/modules/neural_networks_supervised.html#classification), men det er uden for omfanget af denne lektion.
### Hvilken klassifikator skal du vælge?
### Hvilken klassifikator skal man vælge?
Så, hvilken klassifikator skal du vælge? Ofte kan det være en god idé at prøve flere og se, hvilken der giver det bedste resultat. Scikit-learn tilbyder en [side-by-side sammenligning](https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html) på et oprettet datasæt, hvor KNeighbors, SVC på to måder, GaussianProcessClassifier, DecisionTreeClassifier, RandomForestClassifier, MLPClassifier, AdaBoostClassifier, GaussianNB og QuadraticDiscriminationAnalysis sammenlignes og visualiseres:
Så, hvilken klassifikator skal du vælge? Det er ofte en god idé at prøve flere og se efter et godt resultat som test. Scikit-learn tilbyder en [side-om-side sammenligning](https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html) på et oprettet datasæt, der sammenligner KNeighbors, SVC på to måder, GaussianProcessClassifier, DecisionTreeClassifier, RandomForestClassifier, MLPClassifier, AdaBoostClassifier, GaussianNB og QuadraticDiscrinationAnalysis, med visualiserede resultater:
> Diagrammer genereret fra Scikit-learns dokumentation
> Diagrammer genereret i Scikit-learns dokumentation
> AutoML løser dette problem elegant ved at køre disse sammenligninger i skyen, så du kan vælge den bedste algoritme til dine data. Prøv det [her](https://docs.microsoft.com/learn/modules/automate-model-selection-with-azure-automl/?WT.mc_id=academic-77952-leestott)
> AutoML løser dette problem flot ved at køre disse sammenligninger i skyen, så du kan vælge den bedste algoritme til dine data. Prøv det [her](https://docs.microsoft.com/learn/modules/automate-model-selection-with-azure-automl/?WT.mc_id=academic-77952-leestott)
### En bedre tilgang
En bedre tilgang end blot at gætte er at følge ideerne på dette downloadbare [ML Cheat Sheet](https://docs.microsoft.com/azure/machine-learning/algorithm-cheat-sheet?WT.mc_id=academic-77952-leestott). Her opdager vi, at vi for vores multiclass-problem har nogle valgmuligheder:
En bedre måde end at gætte vildt er at følge ideerne i dette downloadbare [ML Cheat sheet](https://docs.microsoft.com/azure/machine-learning/algorithm-cheat-sheet?WT.mc_id=academic-77952-leestott). Her opdager vi, at for vores multiklasse-problem har vi nogle valg:
> En sektion af Microsofts Algorithm Cheat Sheet, der beskriver muligheder for multiclass-klassifikation
> Et uddrag af Microsofts Algorithm Cheat Sheet, der detaljerer multiklasseklassifikationsmuligheder
✅ Download dette cheat sheet, print det ud, og hæng det op på din væg!
### Overvejelser
### Begrundelse
Lad os se, om vi kan ræsonnere os frem til forskellige tilgange givet de begrænsninger, vi har:
Lad os se, om vi kan begrunde forskellige tilgange ud fra de begrænsninger, vi har:
- **Neural netværk er for tunge**. Givet vores rene, men minimale datasæt, og det faktum at vi kører træning lokalt via notebooks, er neural netværk for tunge til denne opgave.
- **Ingen to-klassifikator**. Vi bruger ikke en to-klassifikator, så det udelukker one-vs-all.
- **Beslutningstræ eller logistisk regression kunne fungere**. Et beslutningstræ kunne fungere, eller logistisk regression for multiclass-data.
- **Multiclass Boosted Decision Trees løser et andet problem**. Multiclass Boosted Decision Tree er mest egnet til ikke-parametriske opgaver, f.eks. opgaver designet til at opbygge rangeringer, så det er ikke nyttigt for os.
- **Neurale netværk er for tunge**. Givet vores rene, men minimale datasæt, og at vi kører træning lokalt via notebooks, er neurale netværk for tunge til denne opgave.
- **Ingen to-klasse klassifikator**. Vi bruger ikke en to-klasse klassifikator, så det udelukker one-vs-all.
- **Beslutningstræ eller logistisk regression kunne fungere**. Et beslutningstræ kunne fungere, eller logistisk regression til multiklasse data.
- **Multiklasse Boosted Decision Trees løser et andet problem**. Det multiklasse boosted decision tree er mest egnet til ikke-parametriske opgaver, fx opgaver designet til at bygge ranglister, så det er ikke nyttigt for os.
### Brug af Scikit-learn
### Brug af Scikit-learn
Vi vil bruge Scikit-learn til at analysere vores data. Der er dog mange måder at bruge logistisk regression i Scikit-learn. Se på [parametrene, der kan angives](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
Vi vil bruge Scikit-learn til at analysere vores data. Der er dog mange måder at bruge logistisk regression i Scikit-learn på. Tag et kig på [parametrene, der kan gives](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
Grundlæggende er der to vigtige parametre - `multi_class` og `solver` - som vi skal angive, når vi beder Scikit-learn om at udføre en logistisk regression. `multi_class`-værdien anvender en bestemt adfærd. Værdien af solver angiver, hvilken algoritme der skal bruges. Ikke alle solvers kan kombineres med alle `multi_class`-værdier.
Grundlæggende er der to vigtige parametre - `multi_class` og `solver` - som vi skal specificere, når vi beder Scikit-learn om at udføre logistisk regression. `multi_class`-værdien angiver en bestemt opførsel. Værdien af solver er, hvilken algoritme der skal bruges. Ikke alle solvere kan kombineres med alle `multi_class`værdier.
Ifølge dokumentationen, i multiclass-tilfældet, træningsalgoritmen:
Ifølge dokumentationen bruger træningsalgoritmen i multiklasse tilfælde:
- **Bruger one-vs-rest (OvR)-skemaet**, hvis `multi_class`-indstillingen er sat til `ovr`
- **Bruger krydsentropitab**, hvis `multi_class`-indstillingen er sat til `multinomial`. (I øjeblikket understøttes `multinomial`-indstillingen kun af ‘lbfgs’, ‘sag’, ‘saga’ og ‘newton-cg’-solvers.)
- **Bruger one-vs-rest (OvR) skemaet**, hvis `multi_class`-optionen sættes til `ovr`
- **Bruger kryds-entropi-tab**, hvis `multi_class`-optionen sættes til `multinomial`. (I øjeblikket understøtter `multinomial` kun ‘lbfgs’, ‘sag’, ‘saga’ og ‘newton-cg’ solvere.)"
> 🎓 'Skemaet' her kan enten være 'ovr' (one-vs-rest) eller 'multinomial'. Da logistisk regression egentlig er designet til at understøtte binær klassifikation, giver disse skemaer den mulighed for bedre at håndtere multiclass-klassifikationsopgaver. [kilde](https://machinelearningmastery.com/one-vs-rest-and-one-vs-one-for-multi-class-classification/)
> 🎓 ‘Skemaet’ her kan enten være ‘ovr’ (one-vs-rest) eller ‘multinomial’. Da logistisk regression er designet til binær klassifikation, tillader disse skemaer den at håndtere multiklasse klassifikationsopgaver bedre. [kilde](https://machinelearningmastery.com/one-vs-rest-and-one-vs-one-for-multi-class-classification/)
> 🎓 'Solveren' defineres som "den algoritme, der skal bruges i optimeringsproblemet". [kilde](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
> 🎓 ‘Solver’ defineres som "algoritmen til brug i optimeringsproblemet". [kilde](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
Scikit-learn tilbyder denne tabel til at forklare, hvordan solvers håndterer forskellige udfordringer præsenteret af forskellige typer datastrukturer:
Scikit-learn tilbyder denne tabel for at forklare, hvordan solvere håndterer forskellige udfordringer præsenteret af forskellige datatyper:
Da du bruger multiclass-tilfældet, skal du vælge, hvilket _skema_ du vil bruge, og hvilken _solver_ du vil angive. Brug LogisticRegression med en multiclass-indstilling og **liblinear**-solveren til at træne.
Da du bruger multiklasse-tilfældet, skal du vælge hvilket _skema_ der skal bruges, og hvilken _solver_ der skal sættes. Brug LogisticRegression med en multiklasse-indstilling og **liblinear** solver til træning.
1. Opret en logistisk regression med multi_class sat til `ovr` og solver sat til `liblinear`:
@ -163,9 +163,11 @@ Da du bruger multiclass-tilfældet, skal du vælge, hvilket _skema_ du vil bruge
print ("Accuracy is {}".format(accuracy))
```
✅ Prøv en anden solver som `lbfgs`, som ofte er angivet som standard
> Bemærk, brug Pandas [`ravel`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.ravel.html)-funktionen til at flade dine data ud, når det er nødvendigt.
Nøjagtigheden er god ved over **80%**!
✅ Prøv en anden solver som `lbfgs`, som ofte sættes som standard
> Bemærk, brug Pandas [`ravel`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.ravel.html) funktion til at flade dine data ud, når det er nødvendigt.
Præcisionen er god med over **80%**!
1. Du kan se denne model i aktion ved at teste en række data (#50):
@ -174,7 +176,7 @@ Nøjagtigheden er god ved over **80%**!
@ -182,8 +184,7 @@ Nøjagtigheden er god ved over **80%**!
```
✅ Prøv et andet rækkenummer og tjek resultaterne
1. Gå dybere, og undersøg nøjagtigheden af denne forudsigelse:
1. Hvis du graver dybere, kan du tjekke nøjagtigheden af denne forudsigelse:
```python
test= X_test.iloc[50].values.reshape(-1, 1).T
@ -195,7 +196,7 @@ Nøjagtigheden er god ved over **80%**!
topPrediction.head()
```
Resultatet bliver udskrevet - indisk køkken er dens bedste gæt, med god sandsynlighed:
Resultatet bliver printet - Indisk køkken er det bedste bud, med god sandsynlighed:
| | 0 |
| -------: | -------: |
@ -205,9 +206,9 @@ Nøjagtigheden er god ved over **80%**!
| korean | 0.017277 |
| thai | 0.007634 |
✅ Kan du forklare, hvorfor modellen er ret sikker på, at dette er et indisk køkken?
✅ Kan du forklare, hvorfor modellen er ret sikker på, at dette er indisk køkken?
1. Få flere detaljer ved at udskrive en klassifikationsrapport, som du gjorde i regression-lektionerne:
1. Få flere detaljer ved at printe en klassifikationsrapport, som du gjorde i regressionslektionerne:
```python
y_pred = model.predict(X_test)
@ -221,24 +222,26 @@ Nøjagtigheden er god ved over **80%**!
| japanese | 0.70 | 0.75 | 0.72 | 220 |
| korean | 0.86 | 0.76 | 0.81 | 242 |
| thai | 0.79 | 0.85 | 0.82 | 254 |
| accuracy | 0.80|1199 | | |
| accuracy | | |0.80|1199 |
| macro avg | 0.80 | 0.80 | 0.80 | 1199 |
| weighted avg | 0.80 | 0.80 | 0.80 | 1199 |
## 🚀Udfordring
I denne lektion brugte du dine rensede data til at bygge en maskinlæringsmodel, der kan forudsige en national køkkenstil baseret på en række ingredienser. Tag dig tid til at læse om de mange muligheder, Scikit-learn tilbyder til at klassificere data. Gå dybere ned i konceptet 'solver' for at forstå, hvad der sker bag kulisserne.
I denne lektion brugte du dine rensede data til at bygge en maskinlæringsmodel, der kan forudsige en national ret baseret på en række ingredienser. Tag dig tid til at læse igennem de mange muligheder, Scikit-learn tilbyder til klassificering af data. Undersøg nærmere konceptet ’solver’ for at forstå, hvad der sker bag kulisserne.
## [Quiz efter lektionen](https://ff-quizzes.netlify.app/en/ml/)
## Gennemgang & Selvstudie
Undersøg lidt mere om matematikken bag logistisk regression i [denne lektion](https://people.eecs.berkeley.edu/~russell/classes/cs194/f11/lectures/CS194%20Fall%202011%20Lecture%2006.pdf)
Grav lidt dybere i matematikken bag logistisk regression i [denne lektion](https://people.eecs.berkeley.edu/~russell/classes/cs194/f11/lectures/CS194%20Fall%202011%20Lecture%2006.pdf)
## Opgave
[Undersøg solvers](assignment.md)
[Studér solverne](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Ansvarsfraskrivelse**:
Dette dokument er blevet oversat ved hjælp af AI-oversættelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selvom vi bestræber os på nøjagtighed, skal du være opmærksom på, at automatiserede oversættelser kan indeholde fejl eller unøjagtigheder. Det originale dokument på dets oprindelige sprog bør betragtes som den autoritative kilde. For kritisk information anbefales professionel menneskelig oversættelse. Vi påtager os ikke ansvar for eventuelle misforståelser eller fejltolkninger, der måtte opstå som følge af brugen af denne oversættelse.
Dette dokument er blevet oversat ved hjælp af AI-oversættelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Mens vi stræber efter nøjagtighed, bedes du være opmærksom på, at automatiserede oversættelser kan indeholde fejl eller unøjagtigheder. Det oprindelige dokument på dets modersmål bør betragtes som den autoritative kilde. For kritisk information anbefales professionel menneskelig oversættelse. Vi påtager os intet ansvar for misforståelser eller fejltolkninger som følge af brugen af denne oversættelse.
> Dette repository indeholder 50+ sprogoversættelser, hvilket betydeligt øger downloadstørrelsen. For at klone uden oversættelser, brug sparse checkout:
> Dette repository inkluderer over 50 sprogoversættelser, hvilket øger downloadstørrelsen betydeligt. For at klone uden oversættelser, brug sparse checkout:
>
> **Bash / macOS / Linux:**
> ```bash
@ -33,138 +33,138 @@
> git sparse-checkout set --no-cone "/*" "!translations" "!translated_images"
> ```
>
> Dette giver dig alt, hvad du behøver for at gennemføre kurset med en langt hurtigere download.
> Dette giver dig alt, hvad du behøver for at gennemføre kurset med en meget hurtigere download.
Vi har en Discord-serie med læring om AI i gang, lær mere og deltag hos [Learn with AI Series](https://aka.ms/learnwithai/discord) fra 18. - 30. september 2025. Du vil få tips og tricks til brug af GitHub Copilot til Data Science.
Vi har en Discord "learn with AI"-serie i gang, lær mere og deltag hos [Learn with AI Series](https://aka.ms/learnwithai/discord) fra 18. til 30. september 2025. Du vil få tips og tricks til brug af GitHub Copilot til Data Science.
# Maskinlæring for begyndere - Et pensum
# Maskinlæring for Begyndere - En Curriculum
> 🌍 Rejs rundt i verden, mens vi udforsker maskinlæring gennem verdens kulturer 🌍
> 🌍 Rejs verden rundt, mens vi udforsker Maskinlæring gennem verdens kulturer 🌍
Cloud Advocates hos Microsoft er glade for at kunne tilbyde et 12-ugers, 26-lektioners pensum udelukkende om **Maskinlæring**. I dette pensum lærer du om det, der undertiden kaldes **klassisk maskinlæring**, primært ved brug af Scikit-learn som bibliotek og uden dyb læring, som dækkes i vores [AI for Beginners' pensum](https://aka.ms/ai4beginners). Kombiner disse lektioner med vores ['Data Science for Beginners' pensum](https://aka.ms/ds4beginners) også!
Cloud Advocates hos Microsoft tilbyder et 12-ugers, 26-lektions curriculum, der handler om **Maskinlæring**. I dette curriculum lærer du om det, der nogle gange kaldes **klassisk maskinlæring**, hvor vi primært bruger Scikit-learn som bibliotek og undgår dyb læring, som dækkes i vores [AI for Beginners' curriculum](https://aka.ms/ai4beginners). Kombinér disse lektioner med vores ['Data Science for Beginners' curriculum](https://aka.ms/ds4beginners), også!
Rejs med os rundt i verden, mens vi anvender disse klassiske teknikker på data fra mange områder i verden. Hver lektion indeholder quiz før og efter lektionen, skriftlige instruktioner til at gennemføre lektionen, en løsning, en opgave og mere. Vores projektbaserede pædagogik gør det muligt for dig at lære ved at bygge, en bevist metode til at fastholde nye færdigheder.
Rejs med os verden rundt, mens vi anvender disse klassiske teknikker på data fra mange områder i verden. Hver lektion inkluderer før- og efter-lektionsquizzer, skrevne instruktioner til at gennemføre lektionen, en løsning, en opgave og mere. Vores projektbaserede pædagogik tillader dig at lære mens du bygger, en gennemprøvet måde for nye færdigheder at 'faste'.
**✍️ Store tak til vores forfattere** Jen Looper, Stephen Howell, Francesca Lazzeri, Tomomi Imura, Cassie Breviu, Dmitry Soshnikov, Chris Noring, Anirban Mukherjee, Ornella Altunyan, Ruth Yakubu og Amy Boyd
**✍️ Hjertelig tak til vores forfattere** Jen Looper, Stephen Howell, Francesca Lazzeri, Tomomi Imura, Cassie Breviu, Dmitry Soshnikov, Chris Noring, Anirban Mukherjee, Ornella Altunyan, Ruth Yakubu og Amy Boyd
**🎨 Tak også til vores illustratorer** Tomomi Imura, Dasani Madipalli og Jen Looper
**🙏 Særlige tak 🙏 til vores Microsoft Student Ambassador-forfattere, anmeldere og indholdsbidragsydere**, navnlig Rishit Dagli, Muhammad Sakib Khan Inan, Rohan Raj, Alexandru Petrescu, Abhishek Jaiswal, Nawrin Tabassum, Ioan Samuila og Snigdha Agarwal
**🙏 Særlige tak 🙏 til vores Microsoft Student Ambassador forfattere, anmeldere og indholdsmedvirkende**, især Rishit Dagli, Muhammad Sakib Khan Inan, Rohan Raj, Alexandru Petrescu, Abhishek Jaiswal, Nawrin Tabassum, Ioan Samuila og Snigdha Agarwal
**🤩 Ekstra tak til Microsoft Student Ambassadors Eric Wanjau, Jasleen Sondhi og Vidushi Gupta for vores R-lektioner!**
**🤩 Ekstra tak til Microsoft Student Ambassadors Eric Wanjau, Jasleen Sondhi og Vidushi Gupta for vores Rlektioner!**
# Kom godt i gang
# Kom Godt I Gang
Følg disse trin:
1. **Foretag en fork af repository:** Klik på "Fork" knappen øverst til højre på denne side.
> [find alle yderligere ressourcer til dette kursus i vores Microsoft Learn-samling](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
> [find alle yderligere ressourcer til dette kursus i vores Microsoft Learnsamling](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
> 🔧 **Brug for hjælp?** Se vores [Fejlfinding Guide](TROUBLESHOOTING.md) for løsninger på almindelige problemer med installation, opsætning og kørsel af lektioner.
> 🔧 **Bruger du hjælp?** Se vores [Fejlfinding Guide](TROUBLESHOOTING.md) for løsninger på almindelige problemer med installation, opsætning og udørelse af lektioner.
**[Studerende](https://aka.ms/student-page)**, for at bruge dette pensum, fork hele repoet til din egen GitHub-konto og gennemfør øvelserne på egen hånd eller i grupper:
**[Studerende](https://aka.ms/student-page)**, for at bruge dette curriculum, forke hele repoet til din egen GitHub konto og fuldfør øvelserne på egen hånd eller i gruppe:
- Start med en quiz før forelæsningen.
- Læs forelæsningen og gennemfør aktiviteterne, stop op og reflekter ved hver videnskontrol.
- Prøv at skabe projekterne ved at forstå lektionerne i stedet for blot at køre løsningskoden; dog er denne kode tilgængelig i `/solution`mapperne i hver projektorienteret lektion.
- Tag quizzen efter forelæsningen.
- Gennemfør udfordringen.
- Gennemfør opgaven.
- Efter gennemførelse af en lektion-gruppe, besøg [Diskussionsforumet](https://github.com/microsoft/ML-For-Beginners/discussions) og "lær højt" ved at udfylde den relevante PAT-vurdering. En 'PAT' er et Progress Assessment Tool, som er en vurdering du udfylder for at fremme din læring. Du kan også reagere på andre PAT’er, så vi kan lære sammen.
- Start med en for-forelæsning quiz.
- Læs forelæsningen og fuldfør aktiviteterne, stop op og reflekter ved hver videnscheck.
- Prøv at skabe projekterne ved at forstå lektionerne frem for blot at køre løsningskoden; dog er løsningskoden tilgængelig i `/solution`-mapperne i hver projektorienteret lektion.
- Tag efter-forelæsnings quiz.
- Fuldfør udfordringen.
- Fuldfør opgaven.
- Efter at have fuldført en lektiongruppe, besøg [Discussion Board](https://github.com/microsoft/ML-For-Beginners/discussions) og "lær højt" ved at udfylde den relevante PAT rubric. En 'PAT' er et Progress Assessment Tool, som er et skema du udfylder for at fremme din læring. Du kan også reagerer på andre PAT'er, så vi kan lære sammen.
> Til yderligere studier anbefaler vi at følge disse [Microsoft Learn](https://docs.microsoft.com/en-us/users/jenlooper-2911/collections/k7o7tg1gp306q4?WT.mc_id=academic-77952-leestott) moduler og læringsveje.
**Undervisere**, vi har [inkluderet nogle forslag](for-teachers.md) til hvordan man kan bruge dette pensum.
**Lærere**, vi har [inkluderet nogle forslag](for-teachers.md) til, hvordan man bruger dette curriculum.
---
## Video-gennemgange
## Videogennemgange
Nogle af lektionerne er tilgængelige som korte videoer. Du kan finde alle disse integreret i lektionerne eller på [ML for Beginners playlisterne på Microsoft Developer YouTube kanalen](https://aka.ms/ml-beginners-videos) ved at klikke på billedet nedenfor.
Nogle af lektionerne findes som kortformede videoer. Du kan finde alle disse inline i lektionerne eller på [ML for Beginners playlisten på Microsoft Developer YouTube-kanalen](https://aka.ms/ml-beginners-videos) ved at klikke på billedet nedenfor.
[](https://aka.ms/ml-beginners-videos)
> 🎥 Klik på billedet ovenfor for en video om projektet og de folk, der skabte det!
> 🎥 Klik på billedet ovenfor for en video om projektet og de personer, der skabte det!
---
## Pædagogik
Vi har valgt to pædagogiske principper, mens vi byggede dette pensum: at sikre at det er praktisk og **projektbaseret**, samt at inkludere **hyppige quizzer**. Desuden har dette pensum et fælles **tema** for at skabe sammenhæng.
Vi har valgt to pædagogiske principper mens vi bygger dette curriculum: at sikre, at det er håndgribeligt **projektbaseret** og at det inkluderer **hyppige quizzer**. Derudover har dette curriculum et fælles **tema** for at give sammenhæng.
Ved at sikre, at indholdet passer til projekter, bliver processen mere engagerende for studerende og fastholdelse af begreber forbedres. Derudover sætter en lavt indsats quiz før en klasse den studerendes intention om at lære et emne, mens en anden quiz efter klassen sikrer yderligere fastholdelse. Dette pensum er designet til at være fleksibelt og sjovt, og kan tages helt eller delvist. Projekterne starter småt og bliver mere komplekse hen mod slutningen af den 12-ugers cyklus. Dette pensum indeholder også et efterskrift om virkelige anvendelser af ML, som kan benyttes som ekstra point eller som diskussionsgrundlag.
Ved at sikre, at indholdet stemmer overens med projekter, bliver processen mere engagerende for studerende, og fastholdelse af begreber øges. Derudover sætter en lavrisiko quiz før en lektion intentionen hos den studerende om at lære et emne, mens en anden quiz efter lektion sikrer yderligere fastholdelse. Dette curriculum er designet til at være fleksibelt og sjovt og kan tages som helhed eller delvist. Projekterne starter små og bliver mere komplekse mod slutningen af den 12-ugers cyklus. Dette curriculum omfatter også et efterspil om virkelige anvendelser af ML, som kan bruges som ekstrakredit eller som grundlag for diskussion.
> Find vores [Adfærdskodeks](CODE_OF_CONDUCT.md), [Bidragsretningslinjer](CONTRIBUTING.md), [Oversættelser](..) og [Fejlfinding](TROUBLESHOOTING.md). Vi byder velkommen til din konstruktive feedback!
> Find vores [Adfærdsregler](CODE_OF_CONDUCT.md), [Bidrag](CONTRIBUTING.md), [Oversættelser](..), og [Fejlfinding](TROUBLESHOOTING.md) retningslinjer. Vi byder din konstruktive feedback velkommen!
## Hver lektion indeholder
- valgfri skitse-notat
- valgfrit skitse-notat
- valgfri supplerende video
- video-gennemgang (kun nogle lektioner)
- [quiz før forelæsning](https://ff-quizzes.netlify.app/en/ml/)
- skriftlig lektion
- for projektbaserede lektioner, trin-for-trin vejledninger til at bygge projektet
- for projektbaserede lektioner, trin-for-trin vejledninger til, hvordan man bygger projektet
- videnschecks
- en udfordring
- supplerende læsning
- opgave
- [quiz efter forelæsning](https://ff-quizzes.netlify.app/en/ml/)
> **En note om sprog**: Disse lektioner er primært skrevet i Python, men mange findes også på R. For at gennemføre en R-lektion skal du gå til `/solution`-mappen og kigge efter R-lektioner. De inkluderer en .rmd-udvidelse, som repræsenterer en **R Markdown**-fil, der kan defineres som en indlejring af `kodeblokke` (af R eller andre sprog) og en `YAML-header` (der styrer, hvordan output såsom PDF formateres) i et `Markdown-dokument`. Som sådan fungerer det som en eksemplarisk forfatterramme til datalogi, da det giver dig mulighed for at kombinere din kode, dens output og dine tanker ved at lade dig skrive dem ned i Markdown. Desuden kan R Markdown-dokumenter gengives til outputformater såsom PDF, HTML eller Word.
> **En note om quizzer**: Alle quizzer findes i [Quiz App-mappen](../../quiz-app), i alt 52 quizzer med tre spørgsmål hver. De er linket fra lektionerne, men quizappen kan køre lokalt; følg instruktionerne i `quiz-app`-mappen for at hoste lokalt eller implementere til Azure.
| 01 | Introduktion til maskinlæring | [Introduction](1-Introduction/README.md) | Lær de grundlæggende begreber bag maskinlæring | [Lesson](1-Introduction/1-intro-to-ML/README.md) | Muhammad |
| 02 | Maskinlæringens historie | [Introduction](1-Introduction/README.md) | Lær historien bag dette felt | [Lesson](1-Introduction/2-history-of-ML/README.md) | Jen and Amy |
| 03 | Retfærdighed og maskinlæring | [Introduction](1-Introduction/README.md) | Hvad er de vigtige filosofiske spørgsmål om retfærdighed, som elever bør overveje, når de bygger og anvender ML-modeller? | [Lesson](1-Introduction/3-fairness/README.md) | Tomomi |
| 04 | Teknikker til maskinlæring | [Introduction](1-Introduction/README.md) | Hvilke teknikker bruger ML-forskere til at bygge ML-modeller? | [Lesson](1-Introduction/4-techniques-of-ML/README.md) | Chris and Jen |
| 05 | Introduktion til regression | [Regression](2-Regression/README.md) | Kom i gang med Python og Scikit-learn til regressionsmodeller | [Python](2-Regression/1-Tools/README.md) • [R](../../2-Regression/1-Tools/solution/R/lesson_1.html) | Jen • Eric Wanjau |
| 06 | Nordamerikanske græskarpriser 🎃 | [Regression](2-Regression/README.md) | Visualiser og rengør data som forberedelse til ML | [Python](2-Regression/2-Data/README.md) • [R](../../2-Regression/2-Data/solution/R/lesson_2.html) | Jen • Eric Wanjau |
| 07 | Nordamerikanske græskarpriser 🎃 | [Regression](2-Regression/README.md) | Byg lineære og polynomiske regressionsmodeller | [Python](2-Regression/3-Linear/README.md) • [R](../../2-Regression/3-Linear/solution/R/lesson_3.html) | Jen and Dmitry • Eric Wanjau |
| 08 | Nordamerikanske græskarpriser 🎃 | [Regression](2-Regression/README.md) | Byg en logistisk regressionsmodel | [Python](2-Regression/4-Logistic/README.md) • [R](../../2-Regression/4-Logistic/solution/R/lesson_4.html) | Jen • Eric Wanjau |
| 09 | En Web App 🔌 | [Web App](3-Web-App/README.md) | Byg en webapp til at bruge din trænede model | [Python](3-Web-App/1-Web-App/README.md) | Jen |
| 10 | Introduktion til klassificering | [Classification](4-Classification/README.md) | Rengør, forbered og visualiser dine data; introduktion til klassificering | [Python](4-Classification/1-Introduction/README.md) • [R](../../4-Classification/1-Introduction/solution/R/lesson_10.html) | Jen and Cassie • Eric Wanjau |
| 11 | Lækre asiatiske og indiske køkkener 🍜 | [Classification](4-Classification/README.md) | Introduktion til klassifikatorer | [Python](4-Classification/2-Classifiers-1/README.md) • [R](../../4-Classification/2-Classifiers-1/solution/R/lesson_11.html) | Jen and Cassie • Eric Wanjau |
| 12 | Lækre asiatiske og indiske køkkener 🍜 | [Classification](4-Classification/README.md) | Flere klassifikatorer | [Python](4-Classification/3-Classifiers-2/README.md) • [R](../../4-Classification/3-Classifiers-2/solution/R/lesson_12.html) | Jen and Cassie • Eric Wanjau |
| 13 | Lækre asiatiske og indiske køkkener 🍜 | [Classification](4-Classification/README.md) | Byg en anbefalings-webapp ved hjælp af din model | [Python](4-Classification/4-Applied/README.md) | Jen |
| 14 | Introduktion til clustering | [Clustering](5-Clustering/README.md) | Rengør, forbered og visualiser dine data; introduktion til clustering | [Python](5-Clustering/1-Visualize/README.md) • [R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | Jen • Eric Wanjau |
| 15 | Udforskning af nigerianske musiksmag 🎧 | [Clustering](5-Clustering/README.md) | Udforsk K-Means clustering metoden | [Python](5-Clustering/2-K-Means/README.md) • [R](../../5-Clustering/2-K-Means/solution/R/lesson_15.html) | Jen • Eric Wanjau |
| 16 | Introduktion til naturlig sprogbehandling ☕️ | [Natural language processing](6-NLP/README.md) | Lær det grundlæggende om NLP ved at bygge en simpel bot | [Python](6-NLP/1-Introduction-to-NLP/README.md) | Stephen |
| 17 | Almindelige NLP-opgaver ☕️ | [Natural language processing](6-NLP/README.md) | Udvid din NLP-viden ved at forstå almindelige opgaver, der kræves, når man arbejder med sproglige strukturer | [Python](6-NLP/2-Tasks/README.md) | Stephen |
| 18 | Oversættelse og sentimentanalyse ♥️ | [Natural language processing](6-NLP/README.md) | Oversættelse og sentimentanalyse med Jane Austen | [Python](6-NLP/3-Translation-Sentiment/README.md) | Stephen |
| 19 | Romantiske hoteller i Europa ♥️ | [Natural language processing](6-NLP/README.md) | Sentimentanalyse med hotelanmeldelser 1 | [Python](6-NLP/4-Hotel-Reviews-1/README.md) | Stephen |
| 20 | Romantiske hoteller i Europa ♥️ | [Natural language processing](6-NLP/README.md) | Sentimentanalyse med hotelanmeldelser 2 | [Python](6-NLP/5-Hotel-Reviews-2/README.md) | Stephen |
| 21 | Introduktion til tidsseriefremskrivning | [Time series](7-TimeSeries/README.md) | Introduktion til tidsseriefremskrivning | [Python](7-TimeSeries/1-Introduction/README.md) | Francesca |
| 22 | ⚡️ Verdens strømforbrug ⚡️ - tidsseriefremskrivning med ARIMA | [Time series](7-TimeSeries/README.md) | Tidsseriefremskrivning med ARIMA | [Python](7-TimeSeries/2-ARIMA/README.md) | Francesca |
| 23 | ⚡️ Verdens strømforbrug ⚡️ - tidsseriefremskrivning med SVR | [Time series](7-TimeSeries/README.md) | Tidsseriefremskrivning med Support Vector Regressor | [Python](7-TimeSeries/3-SVR/README.md) | Anirban |
| 24 | Introduktion til reinforcement learning | [Reinforcement learning](8-Reinforcement/README.md) | Introduktion til reinforcement learning med Q-Learning | [Python](8-Reinforcement/1-QLearning/README.md) | Dmitry |
> **En note om sprog**: Disse lektioner er primært skrevet i Python, men mange findes også på R. For at gennemføre en R-lektion, gå til `/solution` mappen og se efter R-lektioner. De inkluderer en .rmd-udvidelse, som repræsenterer en **R Markdown** fil, hvilket enkelt kan defineres som en indlejring af `kodeblokke` (fra R eller andre sprog) og en `YAML header` (der styrer, hvordan output formateres som PDF) i et `Markdown dokument`. Som sådan tjener det som en eksemplarisk forfatterramme for datalogi, da det tillader dig at kombinere din kode, dens output og dine tanker ved at lade dig skrive dem ned i Markdown. Desuden kan R Markdown dokumenter gengives til outputformater som PDF, HTML eller Word.
> **En note om quizzer**: Alle quizzer findes i [Quiz App folder](../../quiz-app), i alt 52 quizzer med tre spørgsmål hver. De er linket fra lektionerne, men quiz app'en kan køres lokalt; følg instruktionen i `quiz-app` mappen for lokalt at hoste eller deployere til Azure.
| 01 | Introduktion til maskinlæring | [Introduktion](1-Introduction/README.md) | Lær de grundlæggende begreber bag maskinlæring | [Lektion](1-Introduction/1-intro-to-ML/README.md) | Muhammad |
| 02 | Maskinlæringens historie | [Introduktion](1-Introduction/README.md) | Lær historien bag dette felt | [Lektion](1-Introduction/2-history-of-ML/README.md) | Jen og Amy |
| 03 | Retfærdighed og maskinlæring | [Introduktion](1-Introduction/README.md) | Hvilke vigtige filosofiske spørgsmål om retfærdighed bør elever overveje, når de bygger og anvender ML-modeller?| [Lektion](1-Introduction/3-fairness/README.md) | Tomomi |
| 04 | Teknikker til maskinlæring | [Introduktion](1-Introduction/README.md) | Hvilke teknikker bruger ML-forskere til at bygge ML-modeller? | [Lektion](1-Introduction/4-techniques-of-ML/README.md) | Chris og Jen |
| 05 | Introduktion til regression | [Regression](2-Regression/README.md) | Kom godt i gang med Python og Scikit-learn til regressionsmodeller | [Python](2-Regression/1-Tools/README.md) • [R](../../2-Regression/1-Tools/solution/R/lesson_1.html) | Jen • Eric Wanjau |
| 06 | Nordamerikanske græskarpriser 🎃 | [Regression](2-Regression/README.md) | Visualiser og rengør data som forberedelse til ML | [Python](2-Regression/2-Data/README.md) • [R](../../2-Regression/2-Data/solution/R/lesson_2.html) | Jen • Eric Wanjau |
| 07 | Nordamerikanske græskarpriser 🎃 | [Regression](2-Regression/README.md) | Byg lineære og polynomielle regressionsmodeller | [Python](2-Regression/3-Linear/README.md) • [R](../../2-Regression/3-Linear/solution/R/lesson_3.html) | Jen og Dmitry • Eric Wanjau |
| 08 | Nordamerikanske græskarpriser 🎃 | [Regression](2-Regression/README.md) | Byg en logistisk regressionsmodel | [Python](2-Regression/4-Logistic/README.md) • [R](../../2-Regression/4-Logistic/solution/R/lesson_4.html) | Jen • Eric Wanjau |
| 09 | En webapp 🔌 | [Web App](3-Web-App/README.md) | Byg en webapp til at bruge din trænede model | [Python](3-Web-App/1-Web-App/README.md) | Jen |
| 10 | Introduktion til klassificering | [Classification](4-Classification/README.md) | Rengør, forbered og visualiser dine data; introduktion til klassificering | [Python](4-Classification/1-Introduction/README.md) • [R](../../4-Classification/1-Introduction/solution/R/lesson_10.html) | Jen og Cassie • Eric Wanjau |
| 11 | Lækker asiatisk og indisk madkultur 🍜 | [Classification](4-Classification/README.md) | Introduktion til klassifikatorer | [Python](4-Classification/2-Classifiers-1/README.md) • [R](../../4-Classification/2-Classifiers-1/solution/R/lesson_11.html) | Jen og Cassie • Eric Wanjau |
| 12 | Lækker asiatisk og indisk madkultur 🍜 | [Classification](4-Classification/README.md) | Flere klassifikatorer | [Python](4-Classification/3-Classifiers-2/README.md) • [R](../../4-Classification/3-Classifiers-2/solution/R/lesson_12.html) | Jen og Cassie • Eric Wanjau |
| 13 | Lækker asiatisk og indisk madkultur 🍜 | [Classification](4-Classification/README.md) | Byg en anbefalings-webapp ved hjælp af din model | [Python](4-Classification/4-Applied/README.md) | Jen |
| 14 | Introduktion til clustering | [Clustering](5-Clustering/README.md) | Rengør, forbered og visualiser dine data; introduktion til clustering | [Python](5-Clustering/1-Visualize/README.md) • [R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | Jen • Eric Wanjau |
| 15 | Udforskning af nigerianske musiksmag 🎧 | [Clustering](5-Clustering/README.md) | Udforsk K-Means clustering metoden | [Python](5-Clustering/2-K-Means/README.md) • [R](../../5-Clustering/2-K-Means/solution/R/lesson_15.html) | Jen • Eric Wanjau |
| 16 | Introduktion til naturlig sprogbehandling ☕️ | [Natural language processing](6-NLP/README.md) | Lær det grundlæggende om NLP ved at bygge en simpel bot | [Python](6-NLP/1-Introduction-to-NLP/README.md) | Stephen |
| 17 | Almindelige NLP-opgaver ☕️ | [Natural language processing](6-NLP/README.md) | Uddyb din NLP-viden ved at forstå almindelige opgaver ved håndtering af sproglige strukturer | [Python](6-NLP/2-Tasks/README.md) | Stephen |
| 18 | Oversættelse og sentimentanalyse ♥️ | [Natural language processing](6-NLP/README.md) | Oversættelse og sentimentanalyse med Jane Austen | [Python](6-NLP/3-Translation-Sentiment/README.md) | Stephen |
| 19 | Romantiske hoteller i Europa ♥️ | [Natural language processing](6-NLP/README.md) | Sentimentanalyse med hotelanmeldelser 1 | [Python](6-NLP/4-Hotel-Reviews-1/README.md) | Stephen |
| 20 | Romantiske hoteller i Europa ♥️ | [Natural language processing](6-NLP/README.md) | Sentimentanalyse med hotelanmeldelser 2 | [Python](6-NLP/5-Hotel-Reviews-2/README.md) | Stephen |
| 21 | Introduktion til tidseriefremskrivning | [Time series](7-TimeSeries/README.md) | Introduktion til tidseriefremskrivning | [Python](7-TimeSeries/1-Introduction/README.md) | Francesca |
| 22 | ⚡️ Verdens energiforbrug ⚡️ - tidseriefremskrivning med ARIMA | [Time series](7-TimeSeries/README.md) | Tidseriefremskrivning med ARIMA | [Python](7-TimeSeries/2-ARIMA/README.md) | Francesca |
| 23 | ⚡️ Verdens energiforbrug ⚡️ - tidseriefremskrivning med SVR | [Time series](7-TimeSeries/README.md) | Tidseriefremskrivning med Support Vector Regressor | [Python](7-TimeSeries/3-SVR/README.md) | Anirban |
| 24 | Introduktion til reinforcement learning | [Reinforcement learning](8-Reinforcement/README.md) | Introduktion til reinforcement learning med Q-Learning | [Python](8-Reinforcement/1-QLearning/README.md) | Dmitry |
| 25 | Hjælp Peter med at undgå ulven! 🐺 | [Reinforcement learning](8-Reinforcement/README.md) | Reinforcement learning Gym | [Python](8-Reinforcement/2-Gym/README.md) | Dmitry |
| Postscript | Virkelige ML-scenarier og applikationer | [ML in the Wild](9-Real-World/README.md) | Interessante og oplysende virkelige applikationer af klassisk ML | [Lesson](9-Real-World/1-Applications/README.md) | Team |
| Postscript | Modelafhjælpning i ML ved hjælp af RAI dashboard | [ML in the Wild](9-Real-World/README.md) | Modelafhjælpning i maskinlæring ved brug af Responsible AI dashboard-komponenter | [Lesson](9-Real-World/2-Debugging-ML-Models/README.md) | Ruth Yakubu |
| Postscript | Virkelige ML-scenarier og -anvendelser | [ML in the Wild](9-Real-World/README.md) | Interessante og afslørende virkelige anvendelser af klassisk ML | [Lektion](9-Real-World/1-Applications/README.md) | Team |
| Postscript | Modeldebugging i ML ved brug af RAI dashboard | [ML in the Wild](9-Real-World/README.md) | Modeldebugging i maskinlæring ved brug af Responsible AI dashboard komponenter | [Lektion](9-Real-World/2-Debugging-ML-Models/README.md) | Ruth Yakubu |
> [find alle yderligere ressourcer til dette kursus i vores Microsoft Learn-samling](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
## Offline adgang
Du kan køre denne dokumentation offline ved at bruge [Docsify](https://docsify.js.org/#/). Fork dette repo, [installer Docsify](https://docsify.js.org/#/quickstart) på din lokale maskine, og i rodmappen til dette repo, skriv `docsify serve`. Websitet vil blive serveret på port 3000 på din localhost: `localhost:3000`.
Du kan køre denne dokumentation offline ved at bruge [Docsify](https://docsify.js.org/#/). Fork dette repo, [installer Docsify](https://docsify.js.org/#/quickstart) på din lokale maskine, og så i roden af denne repo, skriv `docsify serve`. Websitet vil blive serveret på port 3000 på din localhost: `localhost:3000`.
## PDF'er
@ -173,18 +173,18 @@ Find en pdf af læseplanen med links [her](https://microsoft.github.io/ML-For-Be
## 🎒 Andre kurser
Vores team producerer også andre kurser! Se:
Vores team producerer andre kurser! Se nærmere på:
<!-- CO-OP TRANSLATOR OTHER COURSES START -->
### LangChain
[](https://aka.ms/langchain4j-for-beginners)
[](https://aka.ms/langchainjs-for-beginners?WT.mc_id=m365-94501-dwahlin)
[](https://github.com/microsoft/langchain-for-beginners?WT.mc_id=m365-94501-dwahlin)
[](https://aka.ms/langchain4j-for-beginners)
[](https://aka.ms/langchainjs-for-beginners?WT.mc_id=m365-94501-dwahlin)
[](https://github.com/microsoft/langchain-for-beginners?WT.mc_id=m365-94501-dwahlin)
---
### Azure / Edge / MCP / Agenter
[](https://github.com/microsoft/AZD-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/edgeai-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/AZD-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/edgeai-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/mcp-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/ai-agents-for-beginners?WT.mc_id=academic-105485-koreyst)
@ -198,7 +198,7 @@ Vores team producerer også andre kurser! Se:
---
### Grundlæggende læring
### Kerneindlæring
[](https://aka.ms/ml-beginners?WT.mc_id=academic-105485-koreyst)
[](https://aka.ms/datascience-beginners?WT.mc_id=academic-105485-koreyst)
[](https://aka.ms/ai-beginners?WT.mc_id=academic-105485-koreyst)
@ -217,22 +217,33 @@ Vores team producerer også andre kurser! Se:
## Få hjælp
Hvis du sidder fast eller har spørgsmål om at bygge AI-apps. Deltag sammen med andre elever og erfarne udviklere i diskussioner om MCP. Det er et støttende fællesskab, hvor spørgsmål er velkomne, og viden deles frit.
Hvis du sidder fast eller har spørgsmål, mens du lærer maskinlæring eller bygger AI-applikationer, skal du ikke bekymre dig — hjælp er tilgængelig.
- Gennemgå notebooks efter hver lektion for bedre forståelse.
- Øv dig i at implementere algoritmer på egen hånd.
- Udforsk virkelige datasæt ved brug af lærte koncepter.
- Udforsk virkelige datasæt ved hjælp af de lærte koncepter.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Ansvarsfraskrivelse**:
Dette dokument er blevet oversat ved hjælp af AI-oversættelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selvom vi stræber efter nøjagtighed, bedes du være opmærksom på, at automatiske oversættelser kan indeholde fejl eller unøjagtigheder. Det oprindelige dokument på dets modersmål bør betragtes som den autoritative kilde. For kritisk information anbefales professionel menneskelig oversættelse. Vi er ikke ansvarlige for eventuelle misforståelser eller fejltolkninger, der opstår som følge af brugen af denne oversættelse.
**Ansvarsfraskrivelse**:
Dette dokument er blevet oversat ved hjælp af AI-oversættelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selvom vi stræber efter nøjagtighed, bedes du være opmærksom på, at automatiserede oversættelser kan indeholde fejl eller unøjagtigheder. Det oprindelige dokument på dets modersmål skal betragtes som den autoritative kilde. For kritiske oplysninger anbefales professionel menneskelig oversættelse. Vi påtager os intet ansvar for eventuelle misforståelser eller fejltolkninger, der opstår som følge af brugen af denne oversættelse.
> ### [Tämä oppitunti on saatavilla R:llä!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
> ### [Tämä oppitunti saatavilla R:llä!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
### Johdanto
Tähän mennessä olet tutustunut regressioon näyteaineiston avulla, joka on poimittu kurpitsan hinnoitteluaineistosta ja jota käytämme koko oppitunnin ajan. Olet myös visualisoinut aineistoa Matplotlibillä.
Tähän mennessä olet tutustunut regressioon esimerkkidatan avulla, joka on kerätty kurpitsahintojen aineistosta, jota käytämme koko tämän oppitunnin ajan. Olet myös visualisoinut sen käyttäen Matplotlibia.
Nyt olet valmis sukeltamaan syvemmälle ML:n regressioon. Visualisointi auttaa sinua ymmärtämään dataa, mutta todellinen koneoppimisen voima tulee _mallien opettamisesta_. Mallit opetetaan historiatiedolla, jotta ne automaattisesti tunnistavat datariippuvuuksia, ja ne mahdollistavat uusien, aiemmin näkemättömien tietojen tulosten ennustamisen.
Nyt olet valmis sukeltamaan syvemmälle koneoppimisen regressioon. Vaikka visualisointi auttaa sinua hahmottamaan dataa, koneoppimisen todellinen voima tulee _mallien harjoittamisesta_. Mallit koulutetaan historiallisella datalla kaappaamaan automaattisesti datan riippuvuuksia, ja niiden avulla voit ennustaa tuloksia uudelle datalle, jota malli ei ole aiemmin nähnyt.
Tässä oppitunnissa opit lisää kahdesta regressiotyypistä: _perus lineaarisesta regressiosta_ ja _polynomiregressiosta_, sekä joistakin näiden tekniikoiden taustalla olevasta matematiikasta. Nämä mallit mahdollistavat kurpitsahintojen ennustamisen eri syötetietojen perusteella.
Tässä oppitunnissa opit lisää kahdesta regressiotyypistä: _perus lineaarisesta regressiosta_ ja _polynomiregressiosta_, sekä joistakin näiden tekniikoiden taustalla olevista matematiikoista. Näillä malleilla voimme ennustaa kurpitsahintoja eri lähtötietojen perusteella.
[](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression")
> 🎥 Klikkaa yllä olevaa kuvaa nähdäksesi lyhyen videokatsauksen lineaarisesta regressiosta.
> 🎥 Klikkaa yllä olevaa kuvaa katsomaan lyhyt videoyhteenveto lineaarisesta regressiosta.
> Tämän opetussuunnitelman aikana oletamme hyvin vähäisiä matemaattisia ennakkotietoja ja pyrimme tekemään sisällöstä saavutettavaa eri alojen opiskelijoille, joten kiinnitä huomiota huomautuksiin, 🧮 kutsuihin, kaavioihin ja muihin oppimistyökaluihin, jotka tukevat ymmärrystä.
> Koko tämän opetussuunnitelman aikana oletamme vähäisen matematiikan osaamisen ja pyrimme tekemään sisällöstä saavutettavaa muilta aloilta tuleville opiskelijoille, joten pidä silmällä huomautuksia, 🧮 merkintöjä, kaavioita ja muita oppimistyökaluja, jotka auttavat ymmärtämisessä.
### Esivaatimus
### Esivaatimukset
Sinun tulisi nyt olla perehtynyt tutkimamme kurpitsadatan rakenteeseen. Sen löydät ennakkoladattuna ja esipuhdistettuna tämän oppitunnin _notebook.ipynb_-tiedostosta. Tiedostossa kurpitsan hinta esitetään busheliltä uudessa dataframessa. Varmista, että voit ajaa nämä notebookit Visual Studio Coden kernoissa.
Sinun tulisi nyt olla tuttu kurpitsadatan rakenteen kanssa, jota tarkastelemme. Sen löydät valmiiksi ladattuna ja siistittynä tämän oppitunnin _notebook.ipynb_-tiedostosta. Tiedostossa kurpitsan hinta näytetään per hehtolitran (bushel) uutena dataframenä. Varmista, että voit ajaa näitä muistikirjoja Visual Studio Code -ympäristössä.
### Valmistelu
Muistutuksena, lataat tätä dataa voidaksesi esittää sille kysymyksiä.
Muistutuksena, lataat tätä dataa, jotta voit esittää sille kysymyksiä.
- Milloin on paras aika ostaa kurpitsoja?
- Minkä hintaisen laatikon minikurpitsoja voin odottaa?
- Kannattaako ostaa puoli-bushelin koreissa vai 1 1/9 bushelin laatikoissa?
Tutkitaanpa dataa lisää.
- Milloin on paras aika ostaa kurpitsoja?
- Minkä hinnan voin odottaa pikkukurpitsalaatikosta?
- Kannattaako ostaa ne puolen hehtolitran koreissa vai 1 1/9 hehtolitran laatikossa?
Edellisessä oppitunnissa loit Pandas-dataframen ja täytit sen osalla alkuperäisestä aineistosta, standardoiden hinnat bushelin mukaan. Näin teit, mutta keräsit vain noin 400 datapistettä ja vain syys- ja loka-kuukausilta.
Jatketaan tämän datan tutkimista.
Katso tässä oppitunnissa mukana olevasta notebookista esiladattu data. Data on esiladattu ja alkuperäinen hajontakaavio on piirretty, joka näyttää kuukaustiedot. Voimme ehkä saada tarkemman kuvan datan luonteesta puhdistamalla sitä lisää.
Edellisessä oppitunnissa loit Pandas-dataframen ja täytit sen osalla alkuperäisestä aineistosta, vakioimalla hinnat hehtolitran mukaan. Tällä tavoin onnistuimme keräämään noin 400 datapistettä ja vain syksyn kuukausilta.
## Lineaarinen regressioviiva
Katso data, jonka olemme ladanneet valmiiksi tämän oppitunnin mukanaolevaan muistikirjaan. Data on esiladattu ja ensimmäinen hajontakaavio piirretty kuukausidatan näyttämiseksi. Ehkä voimme saada hieman tarkempaa tietoa datan luonteesta puhdistamalla sitä vielä lisää.
Kuten opit Oppitunnissa 1, lineaarisen regression tavoitteena on piirtää viiva, joka:
## Lineaarisen regression suora
- **Näyttää muuttujien suhteet**. Näyttää muuttujien välisen suhteen
- **Tekee ennusteita**. Tekee tarkkoja ennusteita siitä, mihin uusi datapiste asettuu suhteessa viivaan.
Kuten opit oppitunnissa 1, lineaarisen regression harjoituksen tavoite on pystyä piirtämään suora, joka:
On tyypillistä, että **vähintään neliöiden menetelmää** käytetään tämän tyyppisen viivan piirtämiseen. Termi "vähintään neliöiden menetelmä" viittaa mallin virheen kokonaismäärän minimointiin. Jokaisen datapisteen pystysuora etäisyys (jota kutsutaan residuaaliksi) mitataan todellisen pisteen ja regressioviivan välillä.
- **Näyttää muuttujien väliset suhteet:** Havainnollistaa muuttujien välisen yhteyden
- **Tekee ennusteita:** Tekee tarkkoja ennusteita siitä, mihin uusi datapiste sijoittuu verrattuna tähän viivaan.
On tavallista käyttää **vähimmän neliösumman regressiota** (Least-Squares Regression) tällaisten suorien piirtämiseen. Termi "vähimmän neliösumman" viittaa prosessiin, jossa minimoidaan mallimme kokonaisvirhe. Jokaiselle datapisteelle mittaamme pystysuoran etäisyyden (jota kutsutaan jäännökseksi) todellisen pisteen ja regressiosuoran välillä.
Neliöimme nämä etäisyydet kahdesta pääsyystä:
1. **Suuruus ilman suuntaa:** Haluamme käsitellä -5 virheen kuten +5 virhettä. Neliöiminen tekee kaikista arvoista positiivisia.
1. **Suuruus, ei suunta:** Haluamme kohdata virheen -5 samalla tavalla kuin virheen +5. Neliöiminen muuttaa kaikki arvot positiivisiksi.
2. **Poikkeamien rankaisu:** Neliöiminen antaa suuremman painon suurille virheille, pakottaen viivan pysymään lähempänä kaukana olevia pisteitä.
2. **Poikkeamien rankaisu:** Neliöinti antaa suuremman painon suuremmille virheille, pakottaen viivan pysymään lähempänä kauempana olevia pisteitä.
Lisäämme sitten kaikki nämä neliöidyt arvot yhteen. Tavoitteemme on löytää tarkka viiva, jossa tämä summa on pienin mahdollinen – siksi nimi "vähintään neliöiden menetelmä".
Lisäämme sitten kaikki nämä neliöt yhteen. Tavoitteemme on löytää juuri se viiva, jossa tämä loppusumma on mahdollisimman pieni – tästä nimi "vähimmän neliösumman" regressio.
> **🧮 Näytä matematiikka**
>
> Tämä viiva, jota kutsutaan _paras sovitusviivaksi_, voidaan esittää [yhtälöllä](https://en.wikipedia.org/wiki/Simple_linear_regression):
> Tätä viivaa, jota kutsutaan _sopivaksi suoraksi_, voidaan ilmaista [kaavalla](https://en.wikipedia.org/wiki/Simple_linear_regression):
>
> ```
> Y = a + bX
> ```
>
> `X` on 'selittävä muuttuja'. `Y` on 'riippuva muuttuja'. Viivan kulmakerroin on `b` ja `a` on y-akselin leikkauspiste, joka kuvaa `Y`:n arvoa kun `X = 0`.
> `X` on selittävä muuttuja. `Y` on selitettävä muuttuja. Viivan kulmakerroin on `b` ja `a` on y-leikkauspiste, joka tarkoittaa arvoa `Y`, kun `X = 0`.
> Lasketaan ensin kulmakerroin `b`. Infograafi tekijältä [Jen Looper](https://twitter.com/jenlooper)
> Laske ensin kulmakerroin `b`. Infografiikka tekijältä [Jen Looper](https://twitter.com/jenlooper)
>
> Toisin sanoen ja viitaten kurpitsadatan alkuperäiseen kysymykseen: "ennustetaan kurpitsan hinta per bushel kuukauden mukaan", `X` viittaa hintaan ja `Y` myyntikuukauteen.
> Toisin sanoen ja viitaten kurpitsadatan alkuperäiseen kysymykseen: "ennustetaan kurpitsan hinta per hehtolitran myyntikuukauden mukaan", `X` viittaa aikaan (kuukauteen) ja `Y` hintaan.
> Lasketaan Y:n arvo. Jos maksat noin 4 dollaria, täytyy olla huhtikuu! Infograafi tekijältä [Jen Looper](https://twitter.com/jenlooper)
> Laske Y:n arvo. Jos maksat noin 4 dollaria, sen täytyy olla huhtikuu! Infografiikka tekijältä [Jen Looper](https://twitter.com/jenlooper)
>
> Viivan laskennassa on näytettävä sen kaltevuus, joka riippuu myös leikkauskohdasta, eli siitä missä `Y` sijaitsee, kun `X = 0`.
> Laskelmassa viivan kulman täytyy myös ottaa huomioon leikkauspiste, eli missä `Y` sijaitsee, kun `X = 0`.
>
> Voit tarkastella näiden arvojen laskennan menetelmää verkkosivulta [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html). Käy myös [tällä vähintään neliöiden laskimella](https://www.mathsisfun.com/data/least-squares-calculator.html) nähdäksesi kuinka lukuarvot vaikuttavat viivaan.
> Voit tutustua laskentamenetelmään arvonlaskennasta [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html) -sivustolla. Käy myös [vähimmän neliösumman laskurilla](https://www.mathsisfun.com/data/least-squares-calculator.html) nähdäksesi, miten numeroarvot vaikuttavat viivaan.
## Korrelatiivisuus
## Korrelaatio
Yksi termi, joka on syytä ymmärtää, on **korrelaatiokerroin** tietyille X- ja Y-muuttujille. Hajontakuvion avulla voit nopeasti havaita tämän kertoimen. Kuvio, jossa datapisteet ovat siistissä viivassa, on korkea korrelaatio, mutta kun pisteet ovat hajallaan kaikkialla X:n ja Y:n välillä, korrelaatio on matala.
Yksi termi, jonka ymmärtäminen on tärkeää, on **korrelaatiokerroin** annetuille X- ja Y-muuttujille. Hajontakaaviolla voit nopeasti havainnollistaa tämän kertoimen. Jos pisteet ovat kauniissa rivissä, korrelaatio on korkea, mutta jos pisteet ovat hajallaan kaikkialla X:n ja Y:n välillä, korrelaatio on matala.
Hyvä lineaarinen regressiomalli on sellainen, jolla on korkea (lähellä 1:tä eikä 0:aa) korrelaatiokerroin, käytettäessä vähintään neliöiden menetelmää ja regressioviivaa.
Hyvä lineaarinen regressiomalli on sellainen, jonka korrelaatiokerroin on korkea (lähellä 1 eikä 0) vähimmän neliösumman regressiomallissa.
✅ Suorita tämän oppitunnin mukana oleva notebook ja tarkastele Kuukausi vs. Hinta hajontakaaviota. Vaikuttaako kurpitsamyynnin Kuukauden ja Hinnan yhdistelmä korkealta vai matalalta korrelaatiolta, silmämääräisen tulkintasi perusteella? Muuttuuko tulos, jos käytät kuukauden sijaan yksityiskohtaisempaa mittaria, esim. *vuorokauden numeroa* (eli kuinka mones päivä vuodesta)?
✅ Aja tämän oppitunnin mukana tuleva muistikirja ja tutki 'Kuukausi – Hinta' -hajontakaaviota. Vaikuttaako kurpitsan myyntimäärän kuukausien ja hintojen data korkean vai matalan korrelaation omaavalta, visuaalisen tulkintasi perusteella? Muuttuuko tämä, jos käytät hienojakoisempaa mittaria kuin `Kuukausi`, esim. *vuoden päivä* (eli päivien määrä vuodenvaihteesta lähtien)?
Alla koodissa oletamme, että olemme puhdistaneet datan ja saaneet dataframen nimeltä `new_pumpkins`, joka muistuttaa seuraavaa:
Alla olevassa koodissa oletamme, että data on puhdistettu ja saatu data frame nimeltä `new_pumpkins`, joka on samanlainen kuin seuraava:
ID | Month | DayOfYear | Variety | City | Package | Low Price | High Price | Price
> Koodin dataa puhdistavista toimenpiteistä löydät tiedostosta [`notebook.ipynb`](notebook.ipynb). Olemme suorittaneet samat puhdistusvaiheet kuin edellisessä oppitunnissa, ja laskeneet `DayOfYear`-sarakkeen seuraavalla lausekkeella:
> Koodin datan puhdistamiseen löydät [`notebook.ipynb`](notebook.ipynb)-tiedostosta. Olemme tehneet samat puhdistusvaiheet kuin edellisessä oppitunnissa ja laskeneet `DayOfYear`-sarakkeen seuraavan lausekkeen avulla:
Nyt kun ymmärrät lineaarisen regression matematiikan taustalla, luokaamme regressiomalli nähdäksesi, voimmeko ennustaa, mikä kurpitsapakkaus tarjoaa parhaat kurpitsahinnat. Joku, joka ostaa kurpitsoja juhlapuutarhaa varten, haluaa tämän tiedon optimoidakseen kurpitsapakkaustensa ostot.
Koska sinulla on nyt käsitys lineaarisen regression taustalla olevasta matematiikasta, luodaan regressiomalli nähdäksesi, voimmeko ennustaa, mikä kurpitsapakkaus tarjoaa parhaat kurpitsanhinnat. Joulun kurpitsatilaisuutta varten ostava saattaa haluta tämän tiedon optimoidakseen ostoksensa.
## Etsimässä korrelaatiota
## Korrelatorin etsiminen
[](https://youtu.be/uoRq-lW2eQo "ML for beginners - Looking for Correlation: The Key to Linear Regression")
> 🎥 Klikkaa yllä olevaa kuvaa nähdäksesi lyhyen videokatsauksen korrelaatiosta.
> 🎥 Klikkaa yllä olevaa kuvaa katsomaan lyhyt videoyhteenveto korrelaatiosta.
Edellisestä oppitunnista olet todennäköisesti nähnyt, että eri kuukausien keskimääräinen hinta näyttää tältä:
Viimeisestä oppitunnista olet varmaankin nähnyt, että eri kuukausien hintojen keskiarvot näyttävät tältä:
<imgalt="Keskiarvo hinta kuukauden mukaan" src="../../../../translated_images/fi/barchart.a833ea9194346d76.webp"width="50%"/>
<imgalt="Average price by month" src="../../../../translated_images/fi/barchart.a833ea9194346d76.webp"width="50%"/>
Tämä viittaa siihen, että jonkinlaista korrelaatiota pitäisi olla, ja voimme yrittää opettaa lineaarisen regressiomallin ennustamaan suhdetta `Month` ja `Price` välillä, tai `DayOfYear` ja `Price` välillä. Tässä on hajontakaavio jälkimmäisestä suhteesta:
Tämä viittaa siihen, että jonkinlainen korrelaatio on olemassa, ja voimme yrittää kouluttaa lineaarisen regressiomallin ennustamaan suhdetta `Kuukausi` ja `Hinta` tai `PäiväVuodessa` ja `Hinta` välillä. Tässä on hajontakaavio, joka näyttää jälkimmäisen suhteen:
<imgalt="Hajontakaavio hinta vs. vuorokauden numero" src="../../../../translated_images/fi/scatter-dayofyear.bc171c189c9fd553.webp"width="50%"/>
<imgalt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/fi/scatter-dayofyear.bc171c189c9fd553.webp"width="50%"/>
Katsotaan onko korrelaatiota käyttäen `corr`-funktiota:
Katsotaan, onko korrelaatiota `corr`-funktion avulla:
Korrelaation näyttää olevan melko pieni, -0.15 kuukauden mukaan ja -0.17 vuorokauden numeron mukaan, mutta voi olla toinen tärkeä suhde. Näyttää siltä, että hintoja on eri ryhmiä eri kurpitsalajikkeille. Vahvistaaksemme tätä hypoteesia piirretään kukin kurpitsakategoria eri värillä. Käyttämällä `ax` parametria `scatter`-funktiossa voimme piirtää kaikki pisteet samaan kuvaan:
Näyttää siltä, että korrelaatio on melko pieni, -0.15 kuukauden mukaan ja -0.17 päivän mukaan, mutta voi olla jokin toinen tärkeä suhde. Näyttää siltä, että hinnat muodostavat eri klustereita eri kurpitsalajien mukaan. Vahvistaaksemme tämän hypoteesin piirretään jokainen kurpitsakategoria omalla värillään. Antamalla `ax`-parametri `scatter`-piirtotoiminnolle voimme piirtää kaikki pisteet samaan kuvaajaan:
```python
ax=None
@ -140,42 +141,42 @@ for i,var in enumerate(new_pumpkins['Variety'].unique()):
<imgalt="Hajontakaavio hinta vs. vuorokauden numero värikoodattu" src="../../../../translated_images/fi/scatter-dayofyear-color.65790faefbb9d54f.webp"width="50%"/>
<imgalt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/fi/scatter-dayofyear-color.65790faefbb9d54f.webp"width="50%"/>
Tutkimuksemme viittaa siihen, että lajikkeella on suurempi vaikutus kokonaishintaan kuin varsinaisella myyntipäivällä. Näemme tämän pylväskaaviosta:
Tutkimuksemme viittaa siihen, että lajike vaikuttaa enemmän hintaan kuin myyntipäivämäärä. Näin näkyy myös palkkikaaviosta:
<imgalt="Hajontakaavio Hinta vs Vuorokauden Numero" src="../../../../translated_images/fi/pie-pumpkins-scatter.d14f9804a53f927e.webp"width="50%"/>
<imgalt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/fi/pie-pumpkins-scatter.d14f9804a53f927e.webp"width="50%"/>
Jos nyt lasketaan korrelaatio `Price` ja `DayOfYear` välillä `corr`-funktiolla, saamme noin `-0.27`, mikä tarkoittaa, että ennustemallin opettaminen on järkevää.
Jos nyt lasket korrelaation `Hinnan` ja `PäiväVuodessa`-arvon välillä `corr`-funktiolla, saat jotain -0.27:n tienoilla – mikä tarkoittaa, että ennustemallin kouluttaminen on järkevää.
> Ennen lineaarisen regressiomallin opettamista on tärkeää varmistaa, että datamme on puhdasta. Lineaarinen regressio ei toimi hyvin puuttuvien arvojen kanssa, joten on järkevää poistaa kaikki tyhjät solut:
> Ennen lineaarisen regressiomallin kouluttamista on tärkeää varmistaa, että data on puhdasta. Lineaarinen regressio ei toimi hyvin puuttuvien arvojen kanssa, joten on järkevää poistaa kaikki tyhjät solut:
```python
pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info()
```
Toinen lähestymistapa voisi olla täyttää tyhjät arvot vastaavien sarakkeiden keskiarvoilla.
Toinen lähestymistapa olisi täyttää tyhjät arvot vastaavan sarakkeen keskiarvolla.
## Yksinkertainen lineaarinen regressio
[](https://youtu.be/e4c_UP2fSjg "ML for beginners - Linear and Polynomial Regression using Scikit-learn")
> 🎥 Klikkaa yllä olevaa kuvaa nähdäksesi lyhyen videokatsauksen lineaarisesta ja polynomisesta regressiosta.
> 🎥 Klikkaa yllä olevaa kuvaa katsomaan lyhyt videoyhteenveto lineaarisesta ja polynomiregressiosta.
@ -183,69 +184,68 @@ from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
```
Aloitamme erottamalla syötearvot (ominaisuudet) ja odotetun tuloksen (label) eri numpy-taulukoihin:
Aloitamme erottelemalla syötearvot (ominaisuudet) ja odotetun tuloksen (label) omiin numpy-taulukoihinsa:
```python
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price']
```
> Huomaa, että jouduimme käyttämään `reshape`-toimintoa syötteessä, jotta LinearRegression kirjasto ymmärtää sen oikein. Lineaarinen regressio odottaa 2-ulotteista taulukkoa syötteenä, jossa jokainen rivi on yksi ominaisuusvektori. Koska meillä on vain yksi syöte, tarvitsemme N×1 muotoisen taulukon, jossa N on aineiston koko.
> Huomaa, että jouduimme tekemään `reshape`-muunnoksen syötteisiin, jotta Linear Regression -paketti ymmärtää ne oikein. Lineaarinen regressio odottaa 2-ulotteista taulukkoa syötteeksi, jossa jokainen taulukon rivi vastaa ominaisuusvektoria. Meillä on vain yksi syöte, joten tarvitaan N×1-muotoinen taulukko, missä N on datan koko.
Seuraavaksi jaamme aineiston harjoitus- ja testidatoihin, jotta voimme validoida mallimme opettamisen jälkeen:
Seuraavaksi jaamme datan koulutus- ja testidatasettiin, jotta voimme validoida mallimme koulutuksen jälkeen:
```python
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```
Viimein, mallin opettaminen tapahtuu kahdella rivillä koodia. Määrittelemme `LinearRegression`-olion ja sovitamme sen dataamme metodilla `fit`:
Lopuksi lineaarisen regressiomallin kouluttaminen tapahtuu kahdella koodirivillä. Määrittelemme `LinearRegression`-olion ja sovitamme sen dataan `fit`-metodilla:
```python
lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)
```
`LinearRegression`-objekti sovittamisen (`fit`) jälkeen sisältää kaikki regressiokertoimet, joihin pääsee käsiksi `.coef_`-ominaisuudella. Tapauksessamme on vain yksi kerroin, joka on noin `-0.017`. Tämä tarkoittaa, että hinnat näyttävät laskevan hieman ajan myötä, mutta ei liikaa, noin 2 senttiä päivässä. Voimme myös päästä käsiksi regressioviivan leikkauspisteeseen Y-akselilla käyttämällä `lin_reg.intercept_` -arvoa – se on tapauksessamme noin `21`, mikä osoittaa hinnan vuoden alussa.
LinearRegression-objekti fitauksen jälkeen sisältää kaikki regressiokertoimet, joihin pääsee käsiksi .coef_-ominaisuuden kautta. Meidän tapauksessamme on vain yksi kerroin, jonka tulisi olla noin -0,017. Tämä tarkoittaa, että hinnat näyttävät laskevan hieman ajan myötä, mutta ei paljoa, noin 2 senttiä päivässä. Pääsemme käsiksi myös regressiokäyrän leikkauspisteeseen Y-akselin kanssa käyttämällä lin_reg.intercept_ -ominaisuutta - se on meidän tapauksessamme noin 21, mikä ilmaisee hinnan vuoden alussa.
Nähdäksemme, kuinka tarkka mallimme on, voimme ennustaa hintoja testiaineistolla ja mitata, kuinka lähellä ennusteet ovat odotettuja arvoja. Tämä voidaan tehdä käyttäen keskineliövirheen (MSE) metriikkaa, joka on kaikkien odotettujen ja ennustettujen arvojen neliöllisten erotusten keskiarvo.
Nähdäksemme, kuinka tarkka mallimme on, voimme ennustaa testidatan hinnat ja mitata sitten, kuinka lähellä ennusteemme ovat odotettuja arvoja. Tämä voidaan tehdä käyttäen neliöllisen keskiarvon neliöjuurivirhettä (RMSE), joka on kaikkien odotetun ja ennustetun arvon neliöllisten erotusten keskiarvon neliöjuuri.
Virheemme näyttää olevan noin 2 pistettä, mikä on ~17%. Ei kovin hyvä. Toinen mallin laadun mittari on **selitysaste** (coefficient of determination), joka saadaan seuraavasti:
Virheemme näyttää olevan noin 2 pistettä, eli ~17%. Ei kovin hyvä. Toinen mallin laadun mittari on **määrityskerroin**, joka voidaan saada näin:
```python
score = lin_reg.score(X_train,y_train)
print('Model determination: ', score)
```
Jos arvo on 0, se tarkoittaa, että malli ei ota syötteitä huomioon ja toimii *huonoimpana lineaarisena ennustajana*, joka on yksinkertaisesti tuloksen keskiarvo. Arvo 1 tarkoittaa, että voimme täydellisesti ennustaa kaikki odotetut tulokset. Meidän tapauksessamme kerroin on noin 0.06, mikä on melko matala.
Jos arvo on 0, se tarkoittaa, että malli ei huomioi syötteitä ja toimii *huonoimpana lineaarisena ennustajana*, joka on yksinkertaisesti tuloksen keskiarvo. Arvo 1 tarkoittaa, että pystymme täydellisesti ennustamaan kaikki odotetut arvot. Meillä kerroin on noin 0,06, mikä on melko alhainen.
Voimme myös piirtää testidatan yhdessä regressioviivan kanssa nähdäksesi paremmin, miten regressio toimii tapauksessamme:
Voimme myös piirtää testidatan ja regressiokäyrän samaan kuvaajaan, jotta näemme paremmin, miten regressio toimii tapauksessamme:
Toinen lineaarisen regression muoto on polynomiregressio. Vaikka joskus muuttujien välillä on lineaarinen suhde – mitä suurempi kurpitsan tilavuus, sitä korkeampi hinta – joskus näitä suhteita ei voi kuvata tasaisena tasona tai suorana viivana.
Toinen lineaarisen regression tyyppi on polynominen regressio. Vaikka joskus muuttujien välillä on lineaarinen suhde - mitä suurempi kurpitsa tilavuudeltaan, sitä korkeampi hinta - joskus näitä suhteita ei voi esittää tasona tai suorana viivana.
✅ Tässä on [lisää esimerkkejä](https://online.stat.psu.edu/stat501/lesson/9/9.8) aineistosta, johon voisi soveltaa polynomiregressiota
✅ Tässä on [joitakin lisää esimerkkejä](https://online.stat.psu.edu/stat501/lesson/9/9.8) aineistosta, johon polynominen regressio sopii
Katso uudelleen suhdetta Päivämäärän ja Hinnan välillä. Näyttääkö tämä hajontakuvio siltä, että sitä tulisi välttämättä analysoida suoralla viivalla? Eikö hinnat voi heilahdella? Tässä tapauksessa voit kokeilla polynomiregressiota.
Katso uudelleen suhdetta Päivämäärän ja Hinnan välillä. Näyttääkö tämä hajontakuvio siltä, että se pitäisi välttämättä analysoida suoralla viivalla? Eikö hinnat voi vaihdella? Tässä tapauksessa voit kokeilla polynomista regressiota.
✅ Polynomit ovat matemaattisia lausekkeita, jotka voivat sisältää yhden tai useamman muuttujan ja kertoimia
✅ Polynomit ovat matemaattisia lausekkeita, jotka voivat sisältää yhden tai useamman muuttujan ja kertoimen
Polynomiregressio luo kaarevan käyrän sovittamaan paremmin epälineaarista dataa. Jos mukaan otetaan toisen asteen `DayOfYear`-muuttuja syöttötietoihin, pystymme sovittamaan dataamme paraabelin muotoisen käyrän, jolla on minimi tietyn pisteen kohdalla vuoden aikana.
Polynominen regressio luo käyrän, joka istuu paremmin epälineaariseen dataan. Meidän tapauksessamme, jos lisäämme syötteisiin itseisarvoltaan neliöidyn DayOfYear-muuttujan, pystymme sovittamaan dataa parabolisella käyrällä, jolla on minimi tietyssä vuoden kohdassa.
Scikit-learn sisältää hyödyllisen [pipeline-rajapinnan](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) yhdistämään erilaiset data-analyysin vaiheet. **Pipeline** on ketju **estimaattoreita**. Tapauksessamme luomme pipeline:n, joka ensin lisää polynomiset ominaisuudet malliin ja sitten kouluttaa regression:
Scikit-learn sisältää hyödyllisen [pipeline API:n](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) eri datankäsittelyvaiheiden yhdistämistä varten. **Pipeline** on ketju **estimaattoreita**. Meidän tapauksessamme luomme pipelineketjun, joka ensin lisää polynomiset piirteet malliin, ja sen jälkeen opettaa regression:
```python
from sklearn.preprocessing import PolynomialFeatures
Käyttäen PolynomialFeatures(2) tarkoittaa, että otamme mukaan kaikki toisen asteen polynomit syötteestä. Meidän tapauksessamme se tarkoittaa vain DayOfYear<sup>2</sup>, mutta jos on kaksi syötemuuttujaa X ja Y, tämä lisää X<sup>2</sup>, XY ja Y<sup>2</sup>. Voimme myös käyttää korkeampiasteisia polynomeja, jos haluamme.
`PolynomialFeatures(2)` tarkoittaa, että mukaan otetaan kaikki toisen asteen polynomit syötedatasta. Meidän tapauksessamme se tarkoittaa vain `DayOfYear`<sup>2</sup>, mutta jos meillä olisi kaksi syöte muuttujaa X ja Y, mukaan tulisi X<sup>2</sup>, XY ja Y<sup>2</sup>. Voimme myös käyttää korkeampiasteisia polynomeja, jos haluamme.
Pipelinetä voi käyttää samoin kuin alkuperäistä LinearRegression-objektia, eli voimme fitata pipelinen ja sitten predictata saadaksemme ennusteita. Tässä kuvaaja, jossa testidata ja likimääräinen käyrä:
Pipelinetä voi käyttää samalla tavalla kuin alkuperäistä `LinearRegression`-objektia, eli voimme `fit`-metodilla sovittaa ja `predict`-metodilla ennustaa tuloksia. Tässä on kuvaaja, joka näyttää testidatan ja approksimaatiokäyrän:
Polynomista regressiota käyttäen saamme hieman pienemmän MSE:n ja korkeamman määrityskertoimen, mutta ei merkittävästi. Tarvitsemme mukaan muita piirteitä!
Polynomiregressiolla saamme hieman pienemmän MSE:n ja korkeamman selitysasteen, mutta ei merkittävästi. Meidän täytyy ottaa mukaan muitakin piirteitä!
> Näet, että kurpitsan pienimmät hinnat ovat havaittavissa jossakin Halloweenin tienoilla. Miten selität tämän?
> Voit nähdä, että minimihinnat kurpitsoille ovat jossain halloweenin tienoilla. Miten tätä voisi selittää?
🎃 Onneksi olkoon, olet juuri luonut mallin, joka voi auttaa ennustamaan piirakkakurpitsojen hintaa. Voit todennäköisesti toistaa saman menetelmän kaikille kurpistyyppilajikkeille, mutta se olisi työlästä. Opitaan nyt, miten kurpislajike otetaan mallissa huomioon!
🎃 Onneksi olkoon, loit juuri mallin, joka auttaa ennustamaan kurpitsapiirakan hintoja. Voisit luultavasti toistaa saman prosessin kaikille kurpitsatyypeille, mutta se olisi työlästä. Opitaan nyt, miten ottaa kurpitsan lajike huomioon mallissa!
## Kategorialliset piirteet
## Kategoriset ominaisuudet
Ihanteellisessa maailmassa haluamme pystyä ennustamaan eri kurpislajikkeiden hinnat samalla mallilla. Kuitenkin Variety-sarake on hieman erilainen kuin esimerkiksi Month, koska se sisältää ei-numeerisia arvoja. Tällaisia sarakkeita kutsutaan **kategoriallisiksi**.
Ihannetilanteessa haluamme pystyä ennustamaan eri kurpitsalajikkeiden hintoja samalla mallilla. Kuitenkin `Variety`-sarake eroaa esimerkiksi `Month`-sarakkeesta, koska se sisältää ei-numeerisia arvoja. Tällaisia sarakkeita kutsutaan **kategorisiksi**.
[](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression")
[](https://youtu.be/DYGliioIAE0 "ML aloittelijoille - Kategoriset ominaisuudet ja lineaarinen regressio")
> 🎥 Klikkaa yllä olevaa kuvaa nähdäksesi lyhyen videon kategoriapiirteiden käytöstä.
> 🎥 Klikkaa yllä olevaa kuvaa nähdäksesi lyhyen videokatsauksen kategoristen ominaisuuksien käytöstä.
Tässä voit nähdä, miten keskihinta riippuu lajikkeesta:
Tässä näet, miten keskimääräinen hinta riippuu lajikkeesta:
<imgalt="Average price by variety"src="../../../../translated_images/fi/price-by-variety.744a2f9925d9bcb4.webp"width="50%"/>
Ottaksemme lajikkeen huomioon, meidän tulee ensin muuntaa se numeeriseksi eli **enkoodata**. On useita tapoja tehdä tämä:
Ottaaksemme lajikkeen huomioon, meidän täytyy ensin muuntaa se numeromuotoon eli **koodata** se. On olemassa muutamia tapoja tehdä tämä:
* Yksinkertainen **numeraalinen enkoodaus** rakentaa taulukon eri lajikkeista ja korvaa lajikenimen taulukon indeksillä. Tämä ei ole paras idea lineaarisessa regressiossa, koska lineaarinen regressio ottaa indeksin numeerisen arvon ja lisää sen tulokseen kertoimen kanssa kerrottuna. Meidän tapauksessamme suhde indeksiluvun ja hinnan välillä on selvästi epälineaarinen, vaikka indeksit järjestettäisiin tietyllä tavalla.
* **One-hot-enkoodaus** korvaa Variety-sarakkeen neljällä eri sarakkeella, yksi kullekin lajikkeelle. Jokainen sarake sisältää arvon 1 jos rivi kuuluu kyseiseen lajikkeeseen, ja muuten 0. Tämä tarkoittaa, että lineaarisessa regressiossa on neljä kerrointa, yksi kullekin kurpislajikkeelle, jotka vastaavat "aloitushintaa" (tai pikemminkin "lisähintaa") kyseiselle lajikkeelle.
* Yksinkertainen **numeroarvokoodaus** luo taulukon eri lajikkeista ja korvaa lajikenimen kyseisen taulukon indeksillä. Tämä ei ole paras idea lineaarisessa regressiossa, koska lineaariregressio ottaa indeksin numeerisen arvon eikä huomioi, että indeksin numeerinen arvo ei välttämättä ole lineaarisesti yhteydessä hintaan. Toisin sanoen, lineaarisessa mallissa kerroin kerrotaan indeksiluvulla, mikä ei vastaa todellista hintasuhdetta.
* **One-hot-koodaus** korvaa `Variety`-sarakkeen neljällä eri sarakkeella, yhden kullekin lajikkeelle. Kukin sarake sisältää `1`, jos rivi vastaa kyseistä lajiketta, ja `0` muuten. Tämä tarkoittaa, että lineaariregressiossa on neljä kerrointa, yksi jokaiselle kurpitsalajikkeelle, jotka kuvaavat kunkin lajikkeen "aloitushintaa" (tai pikemminkin "lisähintaa").
Alla oleva koodi näyttää, miten lajike voidaan one-hot-koodata:
Alla on koodi, jolla voimme one-hot enkoodata lajikkeen:
Jotta voimme kouluttaa lineaariregression käyttäen one-hot-koodattua lajiketta syötteenä, meidän pitää vain alustaa `X` ja `y` oikein:
Kouluttaaksemme lineaarisen regression käyttäen one-hot enkoodattua lajiketta syötteenä, meidän tarvitsee vain alustaa X ja y -data oikein:
```python
X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price']
```
Muu koodi on sama kuin aiemmin käyttämämme lineaarisen regression koulutuksessa. Kun kokeilet, huomaat, että keskineliövirhe on suunnilleen sama, mutta selitysaste nousee huomattavasti (~77%). Tarkempia ennusteita saamme ottamalla huomioon lisää kategorisia piirteitä sekä numeerisia ominaisuuksia, kuten `Month` tai `DayOfYear`. Yhden suuren ominaisuustaulukon saamiseksi voimme käyttää `join`:
Loput koodista on sama kuin mitä käytimme aiemmin LinearRegressionin opettamiseen. Jos kokeilet, näet, että keskimääräinen neliövirhe on suunnilleen sama, mutta saamme paljon korkeamman määrityskertoimen (~77%). Saadaksemme vieläkin tarkempia ennusteita voimme ottaa huomioon enemmän kategoriallisia piirteitä sekä numeerisia piirteitä, kuten Month tai DayOfYear. Saadaksemme yhden suuren piirteiden taulukon, voimme käyttää join-metodia:
```python
X = pd.get_dummies(new_pumpkins['Variety']) \
@ -318,12 +316,11 @@ X = pd.get_dummies(new_pumpkins['Variety']) \
.join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']
```
Tässä otamme lisäksi huomioon Cityn ja Package-tyypin, jolloin MSE on 2,84 (10%) ja määrityskerroin 0,94!
Tässä otamme myös huomioon `City`- ja `Package`-tyypin, mikä antaa meille MSE-arvoksi 2.84 (10%) ja selitysasteeksi 0.94!
## Yhdistetään kaikki
## Kaiken yhdistäminen
Parhaan mallin saamiseksi voimme käyttää yhdistettyä (one-hot-koodattua kategorista + numeerista) dataa ylläolevasta esimerkistä yhdessä polynomiregression kanssa. Tässä on koko koodi vaivattomuutta varten:
Tehdäksemme parhaan mallin voimme käyttää yhdistettyä (one-hot enkoodattu kategoriallinen + numeerinen) dataa yllä olevasta esimerkistä yhdessä polynomisen regression kanssa. Tässä on koko koodi käyttöösi:
```python
# aseta harjoitusdata
@ -333,10 +330,10 @@ X = pd.get_dummies(new_pumpkins['Variety']) \
.join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']
# tee opetus- ja testijako
# tee harjoitus-testaus-jako
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
Tämä antaa meille parhaan määrityskertoimen lähes 97 %, ja MSE=2,23 (~8 % ennustvirhe).
Tämä antaa meille parhaan selitysasteen lähes 97 % ja MSE:n 2.23 (~8 % ennustevirhe).
| Malli | MSE | Selitysaste |
|-------|-----|-------------|
| `DayOfYear` lineaarinen | 2.77 (17.2%) | 0.07 |
| `DayOfYear` polynomi | 2.73 (17.0%) | 0.08 |
| `Variety` lineaarinen | 5.24 (19.7%) | 0.77 |
| Kaikki ominaisuudet lineaarinen | 2.84 (10.5%) | 0.94 |
| Kaikki ominaisuudet polynomi | 2.23 (8.25%) | 0.97 |
| Malli | MSE | Määrityskerroin |
|-------|-----|---------------|
| `DayOfYear` Lineaarinen | 2.77 (17.2%) | 0.07 |
| `DayOfYear` Polynominen | 2.73 (17.0%) | 0.08 |
| `Variety` Lineaarinen | 5.24 (19.7%) | 0.77 |
| Kaikki piirteet Lineaarinen | 2.84 (10.5%) | 0.94 |
| Kaikki piirteet Polynominen | 2.23 (8.25%) | 0.97 |
🏆 Hienoa työtä! Loit neljä regressiomallia yhdessä oppitunnissa ja paransit mallin laatua 97 prosenttiin. Regressio-aiheen lopussa opit logistisesta regressiosta luokitteluja varten.
🏆 Hienoa työtä! Loit neljä regressiomallia yhdessä oppitunnissa ja paransit mallin laatua 97 %:iin. Regressio-osan lopussa opit logistisesta regressiosta luokitusten määrittämiseksi.
---
## 🚀Haaste
Testaa eri muuttujia tässä muistikirjassa nähdäksesi, miten korrelaatio vastaa mallin tarkkuutta.
Testaa tässä muistikirjassa useampaa eri muuttujaa nähdäksesi, miten korrelaatio vastaa mallin tarkkuutta.
## [Luentotentin jälkeinen tietovisa](https://ff-quizzes.netlify.app/en/ml/)
## Kertaus & Itsenäinen opiskelu
## Kertaus & Itsestä opiskelua
Tässä oppitunnissa opimme lineaarisesta regressiosta. On olemassa myös muita tärkeitä regressiotyyppejä. Lue lisää Stepwise-, Ridge-, Lasso- ja Elasticnet-menetelmistä. Hyvä kurssi opinnoille on [Stanfordin tilastollisen oppimisen kurssi](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning)
Tässä oppitunnissa opimme lineaarisesta regression mallinnuksesta. On olemassa myös muita tärkeitä regressiotyyppejä. Lue Stepwise-, Ridge-, Lasso- ja Elasticnet-teknikoista. Hyvä kurssi syventymiseen on [Stanfordin statistiikan oppimisjakso](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning)
## Tehtävä
@ -381,6 +377,6 @@ Tässä oppitunnissa opimme lineaarisesta regressiosta. On olemassa myös muita
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Vastuuvapauslauseke**:
Tämä asiakirja on käännetty käyttämällä tekoälypohjaista käännöspalvelua [Co-op Translator](https://github.com/Azure/co-op-translator). Pyrimme tarkkuuteen, mutta huomioithan, että automaattiset käännökset saattavat sisältää virheitä tai epätarkkuuksia. Alkuperäinen asiakirja sen alkuperäiskielellä on virallinen lähde. Tärkeissä asioissa suosittelemme ammattimaista ihmiskäännöstä. Emme ota vastuuta tämän käännöksen käytöstä aiheutuvista väärinymmärryksistä tai virheellisistä tulkinnoista.
**Vastuuvapauslauseke**:
Tämä asiakirja on käännetty käyttämällä tekoälypohjaista käännöspalvelua [Co-op Translator](https://github.com/Azure/co-op-translator). Vaikka pyrimme tarkkuuteen, ole ystävällinen ja huomioi, että automatisoiduissa käännöksissä saattaa esiintyä virheitä tai epätarkkuuksia. Alkuperäistä asiakirjaa sen omalla kielellä tulee pitää ensisijaisena lähteenä. Tärkeiden tietojen osalta suositellaan ammattimaista ihmiskäännöstä. Emme ole vastuussa mahdollisista väärinymmärryksistä tai virhetulkingoista, jotka johtuvat tämän käännöksen käytöstä.
Käytät tätä datasettiä eri luokittelijoiden kanssa _ennustaaksesi tietyn kansallisen ruokakulttuurin ainesosaryhmän perusteella_. Samalla opit lisää tavoista, joilla algoritmeja voidaan hyödyntää luokittelutehtävissä.
Käytät tätä aineistoa erilaisten luokittelijoiden kanssa _ennustaaksesi tietyn kansallisen ruokakulttuurin perustuen joukkoon ainesosia_. Samalla opit lisää erilaisista tavoista, joilla algoritmeja voidaan hyödyntää luokittelutehtävissä.
Jos olet suorittanut [Oppitunnin 1](../1-Introduction/README.md), varmista, että _cleaned_cuisines.csv_-tiedosto on olemassa juurihakemistossa `/data` näitä neljää oppituntia varten.
Oletetaan, että olet suorittanut [Oppitunti 1](../1-Introduction/README.md), varmista että _cleaned_cuisines.csv_-tiedosto on olemassa `/data`-kansion juuressa näitä neljää oppituntia varten.
## Harjoitus - ennusta kansallinen ruokakulttuuri
1. Työskentele tämän oppitunnin _notebook.ipynb_-kansiossa ja tuo tiedosto sekä Pandas-kirjasto:
1. Työskentele tässä oppitunnin _notebook.ipynb_-kansiossa ja tuo tiedosto yhdessä Pandas-kirjaston kanssa:
```python
import pandas as pd
@ -30,7 +30,7 @@ Jos olet suorittanut [Oppitunnin 1](../1-Introduction/README.md), varmista, ett
@ -79,81 +79,81 @@ Nyt olet valmis kouluttamaan mallisi!
## Luokittelijan valinta
Kun datasi on puhdas ja valmis koulutukseen, sinun täytyy päättää, mitä algoritmia käytät tehtävään.
Nyt kun data on puhdas ja valmis koulutukseen, sinun täytyy päättää, mitä algoritmia käyttää.
Scikit-learn ryhmittelee luokittelun ohjatun oppimisen alle, ja tässä kategoriassa on monia tapoja luokitella. [Vaihtoehtojen määrä](https://scikit-learn.org/stable/supervised_learning.html) voi aluksi tuntua hämmentävältä. Seuraavat menetelmät sisältävät luokittelutekniikoita:
Scikit-learn ryhmittelee luokittelun ohjattuun oppimiseen, ja tässä kategoriassa on monia tapoja luokitella. [Monipuolisuus](https://scikit-learn.org/stable/supervised_learning.html) voi ensi näkemältä olla hämmentävää. Seuraavat menetelmät sisältävät kaikki luokittelutekniikoita:
- Lineaariset mallit
- Tukivektorikoneet
- Stokastinen gradienttilaskenta
- Lähimmät naapurit
- Gaussin prosessit
- Gaussiset prosessit
- Päätöspuut
- Yhdistelmämallit (äänestysluokittelija)
- Moniluokka- ja monitulostusalgoritmit (moniluokka- ja monilabel-luokittelu, moniluokka-monitulostusluokittelu)
- Kokonaismenetelmät (äänestävä luokittelija)
- Moniluokka- ja usean ulostulon algoritmit (moniluokkainen ja monimerkintäinen luokittelu, moniluokkainen usean ulostulon luokittelu)
> Voit myös käyttää [neuroverkkoja datan luokitteluun](https://scikit-learn.org/stable/modules/neural_networks_supervised.html#classification), mutta se ei kuulu tämän oppitunnin aihepiiriin.
> Voit myös käyttää [neuroverkkoja datan luokitteluun](https://scikit-learn.org/stable/modules/neural_networks_supervised.html#classification), mutta se on tämän oppitunnin ulkopuolella.
### Minkä luokittelijan valita?
### Mikä luokittelija valitaan?
Minkä luokittelijan siis valitset? Usein useiden kokeileminen ja hyvän tuloksen etsiminen on tapa testata. Scikit-learn tarjoaa [vertailun rinnakkain](https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html) luodulla datasetillä, jossa verrataan KNeighbors, SVC kahdella tavalla, GaussianProcessClassifier, DecisionTreeClassifier, RandomForestClassifier, MLPClassifier, AdaBoostClassifier, GaussianNB ja QuadraticDiscriminationAnalysis, ja tulokset visualisoidaan:
Joten, minkä luokittelijan valitset? Usein on järkevää kokeilla useampaa ja etsiä hyvää tulosta. Scikit-learn tarjoaa [rinnakkaisvertailun](https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html) luodulla datalla vertaillen KNeighborsia, kahta SVC-versiota, GaussianProcessClassifieria, DecisionTreeClassifieria, RandomForestClassifieria, MLPClassifieria, AdaBoostClassifieria, GaussianNB:tä ja QuadraticDiscrinationAnalysistä tuloksineen visuaalisesti:
> AutoML ratkaisee tämän ongelman kätevästi suorittamalla nämä vertailut pilvessä, jolloin voit valita parhaan algoritmin datallesi. Kokeile [täällä](https://docs.microsoft.com/learn/modules/automate-model-selection-with-azure-automl/?WT.mc_id=academic-77952-leestott)
> AutoML ratkaisee tämän ongelman siististi ajamalla nämä vertailut pilvessä, jolloin voit valita parhaan algoritmin datallesi. Kokeile sitä [tässä](https://docs.microsoft.com/learn/modules/automate-model-selection-with-azure-automl/?WT.mc_id=academic-77952-leestott)
### Parempi lähestymistapa
Parempi tapa kuin arvaaminen on seurata ladattavaa [ML Cheat Sheet](https://docs.microsoft.com/azure/machine-learning/algorithm-cheat-sheet?WT.mc_id=academic-77952-leestott). Tässä huomataan, että moniluokkaongelmaamme varten meillä on joitakin vaihtoehtoja:
Parempi tapa kuin arvailla villeinä on seurata tämän ladattavan [ML Cheat sheetin](https://docs.microsoft.com/azure/machine-learning/algorithm-cheat-sheet?WT.mc_id=academic-77952-leestott) vinkkejä. Sieltä löydämme, että moniluokkaiseen ongelmaamme on muutama vaihtoehto:
> Osa Microsoftin algoritmien huijauslistasta, joka käsittelee moniluokkaluokitteluvaihtoehtoja
> Ote Microsoftin algoritmivinkkilistasta, joka kuvaa moniluokkalun luokitteluvaihtoehtoja
✅ Lataa tämä huijauslista, tulosta se ja ripusta seinällesi!
✅ Lataa tämä vinkkilista, tulosta se ja laita seinällesi roikkumaan!
### Perustelu
### Päättely
Katsotaan, voimmeko perustella eri lähestymistapoja annettujen rajoitusten perusteella:
Katsotaan, voimmeko perustella eri lähestymistavat annetuin rajoituksin:
- **Neuroverkot ovat liian raskaita**. Puhdas mutta minimaalinen datasetti ja se, että koulutus tapahtuu paikallisesti notebookien kautta, tekevät neuroverkoista liian raskaita tähän tehtävään.
- **Ei kaksiluokkaista luokittelijaa**. Emme käytä kaksiluokkaista luokittelijaa, joten se sulkee pois one-vs-all-menetelmän.
- **Päätöspuu tai logistinen regressio voisi toimia**. Päätöspuu voisi toimia, tai logistinen regressio moniluokkaiselle datalle.
- **Moniluokkaiset Boosted Decision Trees ratkaisevat eri ongelman**. Moniluokkainen Boosted Decision Tree sopii parhaiten ei-parametrisiin tehtäviin, kuten tehtäviin, jotka on suunniteltu luomaan sijoituksia, joten se ei ole hyödyllinen meille.
- **Neuroverkot ovat liian raskaita**. Ottaen huomioon puhtaan, mutta pienen datasetimme ja että koulutus tapahtuu paikallisesti muistikirjojen kautta, neuroverkot ovat liian raskaita tähän tehtävään.
- **Ei kaksiluokkaista luokittelijaa**. Emme käytä kaksiluokkaista luokittelijaa, joten one-vs-all suljetaan pois.
- **Päätöspuu tai logistinen regressio voisi toimia**. Päätöspuu voisi toimia, samoin logistinen regressio moniluokkaiseen dataan.
- **Moniluokkainen Boosted Decision Trees ratkaisee eri ongelman**. Moniluokkainen vahvistettu päätöspuu soveltuu paremmin parametrisiin tehtäviin, kuten rankingien rakentamiseen, joten se ei ole meille käyttökelpoinen.
### Scikit-learnin käyttö
Käytämme Scikit-learnia datan analysointiin. On kuitenkin monia tapoja käyttää logistista regressiota Scikit-learnissa. Katso [parametrit, jotka voit asettaa](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
Käytämme Scikit-learnia datan analysointiin. Kuitenkin logistiikkaregressiota on monia erilaisia tapoja käyttää Scikit-learnissa. Tutustu [parametreihin](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
Käytännössä on kaksi tärkeää parametria - `multi_class` ja `solver` - jotka meidän täytyy määrittää, kun pyydämme Scikit-learnia suorittamaan logistisen regression. `multi_class`-arvo soveltaa tiettyä käyttäytymistä. Solverin arvo määrittää, mitä algoritmia käytetään. Kaikkia solvereita ei voi yhdistää kaikkiin `multi_class`-arvoihin.
Käytännössä tärkeimmät parametrit ovat `multi_class` ja `solver` - joita tarvitsee määrittää pyytäessämme Scikit-learnia suorittamaan logistisen regression. `multi_class` määrittää tietyn käyttäytymisen. `solver` on käytettävä algoritmi. Kaikki solverit eivät sovi yhteen kaikkien `multi_class` -arvojen kanssa.
Dokumentaation mukaan moniluokkaisessa tapauksessa koulutusalgoritmi:
Dokumenttien mukaan moniluokkaisessa tapauksessa koulutusalgoritmi:
- **Käyttää one-vs-rest (OvR) -menetelmää**, jos `multi_class`-vaihtoehto on asetettu`ovr`
- **Käyttää ristientropiahäviötä**, jos `multi_class`-vaihtoehto on asetettu `multinomial`. (Tällä hetkellä `multinomial`-vaihtoehto on tuettu vain ‘lbfgs’, ‘sag’, ‘saga’ ja ‘newton-cg’ solvereilla.)
- **Käyttää one-vs-rest (OvR) -metodia**, jos `multi_class` on asetettu arvoksi`ovr`
- **Käyttää ristientropiahäviötä**, jos `multi_class` on asetettu arvoksi `multinomial`. (Tällä hetkellä `multinomial` on tuettu vain `lbfgs`, `sag`, `saga` ja `newton-cg` -solverien kanssa.)
> 🎓 'Menetelmä' voi olla joko 'ovr' (one-vs-rest) tai 'multinomial'. Koska logistinen regressio on suunniteltu tukemaan binääriluokittelua, nämä menetelmät auttavat sitä käsittelemään paremmin moniluokkaluokittelutehtäviä. [lähde](https://machinelearningmastery.com/one-vs-rest-and-one-vs-one-for-multi-class-classification/)
> 🎓 'Skenaario' voi olla 'ovr' (one-vs-rest) tai 'multinomial'. Koska logistinen regressio on suunniteltu binääriluokitteluun, nämä skenaariot mahdollistavat paremman tuen moniluokkaluille luokittelutehtäville. [lähde](https://machinelearningmastery.com/one-vs-rest-and-one-vs-one-for-multi-class-classification/)
> 🎓 'Solver' määritellään "algoritmiksi, jota käytetään optimointiongelmassa". [lähde](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
> 🎓 'Solveri' on määritelty algoritmiksi, jota käytetään optimointiongelmassa. [lähde](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
Scikit-learn tarjoaa tämän taulukon selittämään, miten solverit käsittelevät eri haasteita, joita eri datarakenteet esittävät:
Scikit-learn tarjoaa tämän taulukon selittämään, miten solverit käsittelevät erilaisia datarakenteiden haasteita:
Koska käytät moniluokkaista tapausta, sinun täytyy valita, mitä _menetelmää_ käytät ja mitä _solveria_ asetat. Käytä LogisticRegressionia moniluokka-asetuksella ja **liblinear**-solveria koulutukseen.
Koska käytät moniluokkaista tapausta, sinun täytyy valita, mitä _skenaariota_ ja _solveria_ käytetään. Käytä LogisticRegressionia moniluokkaisella asetuksella ja **liblinear**-solveria kouluttaaksesi.
1. Luo logistinen regressio, jossa multi_class on asetettu `ovr` ja solver asetettu `liblinear`:
1. Luo logistinen regressio, jossa `multi_class` on asetettu `ovr`:ksi ja `solver``liblinear`iksi:
```python
lr = LogisticRegression(multi_class='ovr',solver='liblinear')
@ -163,18 +163,20 @@ Koska käytät moniluokkaista tapausta, sinun täytyy valita, mitä _menetelmä
print ("Accuracy is {}".format(accuracy))
```
✅ Kokeile eri solveria, kuten `lbfgs`, joka on usein asetettu oletusarvoksi
Tässä oppitunnissa käytit siivottua dataasi rakentaaksesi koneoppimismallin, joka voi ennustaa kansallisen keittiön ainesosien perusteella. Käytä aikaa tutkiaksesi Scikit-learnin tarjoamia monia vaihtoehtoja datan luokitteluun. Syvenny tarkemmin 'solver'-käsitteeseen ymmärtääksesi, mitä kulissien takana tapahtuu.
In this lesson, you used your cleaned data to build a machine learning model that can predict a national cuisine based on a series of ingredients. Take some time to read through the many options Scikit-learn provides to classify data. Dig deeper into the concept of 'solver' to understand what goes on behind the scenes.
## [Luennon jälkeinen kysely](https://ff-quizzes.netlify.app/en/ml/)
Tutustu hieman tarkemmin logistisen regression matematiikkaan [tässä oppitunnissa](https://people.eecs.berkeley.edu/~russell/classes/cs194/f11/lectures/CS194%20Fall%202011%20Lecture%2006.pdf)
## Tehtävä
Dig a little more into the math behind logistic regression in [this lesson](https://people.eecs.berkeley.edu/~russell/classes/cs194/f11/lectures/CS194%20Fall%202011%20Lecture%2006.pdf)
## Assignment
[Tutki solvereita](assignment.md)
[Study the solvers](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Vastuuvapauslauseke**:
Tämä asiakirja on käännetty käyttämällä tekoälypohjaista käännöspalvelua [Co-op Translator](https://github.com/Azure/co-op-translator). Vaikka pyrimme tarkkuuteen, huomioithan, että automaattiset käännökset voivat sisältää virheitä tai epätarkkuuksia. Alkuperäinen asiakirja sen alkuperäisellä kielellä tulisi pitää ensisijaisena lähteenä. Kriittisen tiedon osalta suositellaan ammattimaista ihmiskäännöstä. Emme ole vastuussa väärinkäsityksistä tai virhetulkinnoista, jotka johtuvat tämän käännöksen käytöstä.
Tämä asiakirja on käännetty käyttämällä tekoälypohjaista käännöspalvelua [Co-op Translator](https://github.com/Azure/co-op-translator). Vaikka pyrimme tarkkuuteen, ole hyvä ja huomioi, että automatisoiduissa käännöksissä saattaa esiintyä virheitä tai epätarkkuuksia. Alkuperäinen asiakirja sen alkuperäiskielellä tulee pitää auktoriteettisena lähteenä. Tärkeiden tietojen kohdalla suositellaan ammattimaista ihmiskäännöstä. Emme ole vastuussa tämän käännöksen käytöstä johtuvista väärinkäsityksistä tai virheellisistä tulkinnoista.
> Tässä repositoriossa on yli 50 kielen käännöksiä, mikä lisää huomattavasti ladattavan tiedoston kokoa. Kloonaa ilman käännöksiä käyttämällä osittaista checkoutia:
> Tämä arkisto sisältää yli 50 käännöstä, mikä lisää huomattavasti latauskokoa. Jos haluat kloonata ilman käännöksiä, käytä sparse checkoutia:
>
> **Bash / macOS / Linux:**
> ```bash
@ -33,205 +33,217 @@
> git sparse-checkout set --no-cone "/*" "!translations" "!translated_images"
> ```
>
> Saat kaiken tarvittavan kurssin suorittamiseen paljon nopeammalla latauksella.
> Näin saat kaiken tarvittavan kurssin suorittamiseen paljon nopeammalla latauksella.
Meillä on käynnissä Discordin Learn with AI -sarja, opi lisää ja liity mukaan osoitteessa [Learn with AI Series](https://aka.ms/learnwithai/discord) ajalla 18. - 30. syyskuuta 2025. Saat vinkkejä ja niksejä GitHub Copilotin käyttöön Data Scientistin työssä.
Meillä on käynnissä Discordin opi tekoälyn kanssa -sarja, lisätietoja ja liittyminen osoitteessa [Learn with AI Series](https://aka.ms/learnwithai/discord) ajalla 18.–30. syyskuuta 2025. Saat vinkkejä ja niksejä GitHub Copilotin käyttämiseen Data Scientissä.
> 🌍 Matkusta ympäri maailmaa tutkiessamme koneoppimista maailman kulttuurien avulla 🌍
> 🌍 Matkustetaan maailman ympäri tutkien koneoppimista maailman kulttuurien kautta 🌍
Microsoftin Cloud Advocates tarjoaa 12-viikkoisen, 26-oppitunnin opetussuunnitelman, joka käsittelee **koneoppimista**. Tässä opetussuunnitelmassa opit niin kutsutusta **klassikosta koneoppimisesta**, käyttäen pääasiassa Scikit-learnia kirjastona ja välttäen syväoppimista, jota käsitellään [AI for Beginners -opetussuunnitelmassamme](https://aka.ms/ai4beginners). Yhdistä nämä oppitunnit myös ['Data Science for Beginners' -opetussuunnitelman](https://aka.ms/ds4beginners) kanssa!
Microsoftin Cloud Advocates tarjoaa 12 viikon ja 26 oppitunnin opetussuunnitelman, joka keskittyy **koneoppimiseen**. Tässä kurssissa opit niistä koneoppimisen muodoista, joita joskus kutsutaan **klassiseksi koneoppimiseksi**, pääasiassa hyödyntäen Scikit-learniä kirjastona ja välttäen syväoppimista, joka sisältyy meidän [AI for Beginners -opetussuunnitelmaamme](https://aka.ms/ai4beginners). Yhdistä nämä oppitunnit myös meidän ['Data Science for Beginners' -opetussuunnitelmaan](https://aka.ms/ds4beginners)!
Matkustamme ympäri maailmaa soveltaessamme näitä klassisia menetelmiä eri alueiden tietoihin. Jokainen oppitunti sisältää ennen- ja jälkeetenttejä, kirjalliset ohjeet oppitunnin suorittamiseen, ratkaisut, harjoitukset ja muuta. Projektipohjainen pedagogiikkamme sallii oppimisen rakentamisen ohessa, mikä on todistettu tapa saada uudet taidot pysymään.
Matkusta kanssamme maailman ympäri, kun sovellamme näitä klassisia menetelmiä monien maailman alueiden tietoihin. Jokainen oppitunti sisältää ennen ja jälkeen oppitunnin kyselyt, kirjalliset ohjeet tehtävän suorittamiseksi, ratkaisun, tehtävän ja lisää. Projektipohjainen pedagogiikkamme antaa sinun oppia samalla kun rakennat, mikä on todistettu tapa saada uudet taidot palautumaan mieleen.
**✍️ Suuret kiitokset kirjoittajille** Jen Looper, Stephen Howell, Francesca Lazzeri, Tomomi Imura, Cassie Breviu, Dmitry Soshnikov, Chris Noring, Anirban Mukherjee, Ornella Altunyan, Ruth Yakubu ja Amy Boyd
**✍️ Lämmin kiitos kirjoittajillemme** Jen Looper, Stephen Howell, Francesca Lazzeri, Tomomi Imura, Cassie Breviu, Dmitry Soshnikov, Chris Noring, Anirban Mukherjee, Ornella Altunyan, Ruth Yakubu ja Amy Boyd
**🎨 Kiitokset myös kuvittajillemme** Tomomi Imura, Dasani Madipalli ja Jen Looper
**🙏 Erityiskiitokset 🙏 Microsoft Student Ambassador -kirjoittajillemme, tarkistajillemme ja sisällöntuottajille, erityisesti Rishit Dagli, Muhammad Sakib Khan Inan, Rohan Raj, Alexandru Petrescu, Abhishek Jaiswal, Nawrin Tabassum, Ioan Samuila ja Snigdha Agarwal**
**🙏 Erityiskiitokset 🙏 Microsoft Student Ambassador -kirjoittajille, arvioijille ja sisältöjen toimittajille**, erityisesti Rishit Dagli, Muhammad Sakib Khan Inan, Rohan Raj, Alexandru Petrescu, Abhishek Jaiswal, Nawrin Tabassum, Ioan Samuila ja Snigdha Agarwal
**🤩 Erityiskiitos Microsoft Student Ambassadors Eric Wanjau, Jasleen Sondhi ja Vidushi Gupta R-oppitunneistamme!**
**🤩 Lisäkiitos Microsoft Student Ambassadors Eric Wanjau, Jasleen Sondhi ja Vidushi Gupta -tiimille R-oppitunneistamme!**
# Aloittaminen
Noudata näitä ohjeita:
1. **Forkkaa repositorio**: Klikkaa "Fork" -painiketta tämän sivun oikeassa yläkulmassa.
> [Löydät kaikki kurssin lisäresurssit Microsoft Learn -kokoelmassamme](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
> [löydät kaikki lisäresurssit tälle kurssille Microsoft Learn -kokoelmastamme](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
**[Opiskelijat](https://aka.ms/student-page)**, käyttäkää tätä opetussuunnitelmaa forkaamalla koko repo omaan GitHub-tiliinne ja suorittakaa harjoitukset itse tai ryhmässä:
**[Opiskelijat](https://aka.ms/student-page)**, käyttääksenne tätä opetussuunnitelmaa, forkkaa koko arkisto omaan GitHub-tiliisi ja suorita harjoitukset yksin tai ryhmässä:
- Aloita ennakkokyselyllä.
- Lue oppitunti ja suorita tehtävät, pysähdy ja pohdi jokaisen tietotarkistuksen kohdalla.
- Yritä luoda projektit ymmärtämällä oppitunnit sen sijaan, että suorittaisit ratkaisukoodin; kuitenkin koodi on saatavilla jokaisen projektilähtöisen oppitunnin `/solution` -kansiossa.
- Tee jälkitentti.
- Aloita esiluentokyselyllä.
- Lue luento ja suorita tehtävät, pysähdyttele ja pohdi jokaista tiedon tarkistusta.
- Yritä luoda projektit ymmärtämällä oppitunnit sen sijaan, että vain suoritat ratkaisukoodin; kuitenkin koodit löytyvät /solution -kansioista jokaisessa projektiin keskittyneessä oppitunnissa.
- Tee jälkiluennon kysely.
- Suorita haaste.
- Tee tehtävä.
- Oppituntiryhmän suorittamisen jälkeen käy [Keskustelutaululla](https://github.com/microsoft/ML-For-Beginners/discussions) ja "opiskele ääneen" täyttämällä sopiva PAT-arviointilomake. 'PAT' on Progress Assessment Tool, arviointityökalu, jonka täytät oppimisesi edistämiseksi. Voit myös reagoida muiden PAT-lomakkeisiin, jotta voimme oppia yhdessä.
- Oppikokonaisuuden suoritettuasi käy [Keskustelufoorumilla](https://github.com/microsoft/ML-For-Beginners/discussions) ja "opiskele ääneen" täyttämällä sopiva PAT-arviointilomake. PAT on etenemisen arviointityökalu, jonka avulla voit edistää oppimistasi. Voit myös reagoida muiden PAT-arviointeihin, jotta opimme yhdessä.
> Lisätutkimukseen suosittelemme seuraavia [Microsoft Learn](https://docs.microsoft.com/en-us/users/jenlooper-2911/collections/k7o7tg1gp306q4?WT.mc_id=academic-77952-leestott) moduuleja ja oppimispolkuja.
> Jatko-opiskelua varten suosittelemme seuraavia [Microsoft Learn](https://docs.microsoft.com/en-us/users/jenlooper-2911/collections/k7o7tg1gp306q4?WT.mc_id=academic-77952-leestott) moduuleja ja oppimispolkuja.
**Opettajat**, olemme [sisällyttäneet joitain ehdotuksia](for-teachers.md) opetussuunnitelman käyttöön.
**Opettajat**, olemme lisänneet [joitain ehdotuksia](for-teachers.md) tämän opetussuunnitelman käyttämiseen.
---
## Videoesittelyt
## Video-oppaat
Jotkut oppitunneista ovat saatavilla lyhytmuotoisina videoina. Löydät ne kaikki oppituntien yhteydessä tai [ML for Beginners -soittolistalta Microsoft Developer YouTube-kanavalta](https://aka.ms/ml-beginners-videos) klikkaamalla alla olevaa kuvaa.
Jotkut oppitunnit ovat saatavilla lyhyinä videoina. Löydät ne kaikki suoraan oppitunneilta tai [ML for Beginners -soittolistalta Microsoft Developerin YouTube-kanavalta](https://aka.ms/ml-beginners-videos) kuvaa klikkaamalla.
[](https://aka.ms/ml-beginners-videos)
> 🎥 Klikkaa yllä olevaa kuvaa nähdäksesi videon projektista ja sen tekijöistä!
> 🎥 Klikkaa yllä olevaa kuvaa videota varten, jossa kerrotaan projektista ja tekijöistä!
---
## Pedagogiikka
Olemme valinneet kaksi pedagogista periaatetta tätä opetussuunnitelmaa rakentaessamme: varmistaa, että se on käytännönläheinen **projektipohjainen**, ja että se sisältää **useita tietokilpailuja**. Lisäksi opetussuunnitelmalla on yhtenäinen **teema**, joka antaa sille eheyttä.
Olemme valinneet kaksi pedagogista periaatetta tämän opetussuunnitelman rakentamisessa: varmistaa, että se on käytännönläheinen **projekti-pohjainen** ja että se sisältää **useita tietovisailuja**. Lisäksi opetussuunnitelmalla on yhteinen **teema** antaakseen yhtenäisyyttä.
Sisällön linkittäminen projekteihin tekee prosessista opiskelijalle mielenkiintoisemman ja käsitteiden omaksuminen vahvistuu. Lisäksi matalan panoksen tietokilpailu ennen oppituntia asettaa opiskelijan opiskelutavotteet, ja jälkitentti varmistaa käsitteiden pysyvyyden. Tämä opetussuunnitelma on suunniteltu joustavaksi ja hauskaksi, ja se voidaan suorittaa kokonaan tai osittain. Projektit alkavat yksinkertaisista ja monimutkaistuvat 12 viikon syklin loppuun mennessä. Oppitunnit sisältävät myös jälkisanat koneoppimisen todellisista sovelluksista, joita voi käyttää lisäpisteisiin tai keskustelun pohjana.
Sisällön linkittäminen projekteihin tekee prosessista opiskelijoille kiinnostavamman ja parantaa käsitteiden muistamista. Lisäksi matalariskeinen tietovisa ennen tuntia asettaa opiskelijan tavoitteet uusien asioiden oppimiselle, ja toinen tietovisa luennon jälkeen vahvistaa muistia. Tämä opetussuunnitelma on suunniteltu joustavaksi ja hauskaksi, ja sen voi suorittaa kokonaan tai osittain. Projektit alkavat pieninä ja monimutkaistuvat vaiheittain 12 viikon jaksolla. Tämä opetussuunnitelma sisältää myös loppuosan ML:n todellisista sovelluksista, jonka voi käyttää lisäpisteiden ansaitsemiseen tai keskustelun pohjaksi.
> Löydät [käytösnormimme](CODE_OF_CONDUCT.md), [osallistumisohjeet](CONTRIBUTING.md), [käännökset](..) ja [vianetsinnän](TROUBLESHOOTING.md) ohjeet. Otamme mielellämme vastaan rakentavaa palautetta!
> **Huomio kielistä**: Nämä oppitunnit on ensisijaisesti kirjoitettu Pythonilla, mutta monet ovat saatavilla myös R-kielellä. R-oppitunnin suorittamiseksi siirry `/solution`-kansioon ja etsi R-opetuksia. Niillä on .rmd-pääte, joka edustaa **R Markdown** -tiedostoa, jota voidaan yksinkertaisesti määritellä R:n tai muiden kielten `koodilohkojen` upotukseksi ja `YAML-otsikoksi` (joka ohjaa esimerkiksi PDF-muodon tuottamista) `Markdown-asiakirjassa`. Tällaisenaan se toimii esimerkillisenä kirjoituskehyksenä datatieteessä, sillä se mahdollistaa koodin, sen tulosten ja ajatusten yhdistämisen kirjoittamalla ne ylös Markdownilla. Lisäksi R Markdown -asiakirjat voidaan viedä tulostusmuotoihin kuten PDF, HTML tai Word.
> **Huomio visailuista**: Kaikki visailut löytyvät [Quiz App -kansiosta](../../quiz-app), yhteensä 52 visailua, joissa on kolme kysymystä kukin. Ne on linkitetty oppituntien sisältä, mutta quiz-sovellusta voidaan ajaa paikallisesti; seuraa ohjeita `quiz-app`-kansiossa paikallisen isännöinnin tai Azuren käyttöönoton osalta.
| Oppitunnin numero | Aihe | Oppituntiryhmä | Opetustavoitteet | Linkitetty oppitunti | Tekijä |
| 02 | Koneoppimisen historia | [Johdatus](1-Introduction/README.md) | Opit alan historian | [Oppitunti](1-Introduction/2-history-of-ML/README.md) | Jen ja Amy |
| 03 | Oikeudenmukaisuus ja koneoppiminen | [Johdatus](1-Introduction/README.md) | Mitkä ovat tärkeät filosofiset kysymykset oikeudenmukaisuudesta, jotka tulisi huomioida koneoppimismalleja rakennettaessa? | [Oppitunti](1-Introduction/3-fairness/README.md) | Tomomi |
| 04 | Tekniikat koneoppimisessa | [Johdatus](1-Introduction/README.md) | Mitä tekniikoita koneoppimisasiantuntijat käyttävät mallien rakentamiseen? | [Oppitunti](1-Introduction/4-techniques-of-ML/README.md) | Chris ja Jen |
| 05 | Johdatus regressioon | [Regressio](2-Regression/README.md) | Aloita Pythonilla ja Scikit-learnillä regressiomallien parissa | [Python](2-Regression/1-Tools/README.md) • [R](../../2-Regression/1-Tools/solution/R/lesson_1.html) | Jen • Eric Wanjau |
| 06 | Pohjois-Amerikan kurpitsahinnat 🎃 | [Regressio](2-Regression/README.md) | Visualisoi ja siivoa dataa koneoppimista varten | [Python](2-Regression/2-Data/README.md) • [R](../../2-Regression/2-Data/solution/R/lesson_2.html) | Jen • Eric Wanjau |
| 07 | Pohjois-Amerikan kurpitsahinnat 🎃 | [Regressio](2-Regression/README.md) | Rakenna lineaariset ja polynomiset regressiomallit | [Python](2-Regression/3-Linear/README.md) • [R](../../2-Regression/3-Linear/solution/R/lesson_3.html) | Jen ja Dmitry • Eric Wanjau |
| 08 | Pohjois-Amerikan kurpitsahinnat 🎃 | [Regressio](2-Regression/README.md) | Rakenna logistinen regressiomalli | [Python](2-Regression/4-Logistic/README.md) • [R](../../2-Regression/4-Logistic/solution/R/lesson_4.html) | Jen • Eric Wanjau |
| 09 | Verkkosovellus 🔌 | [Web App](3-Web-App/README.md) | Rakenna verkkosovellus käyttämällä kouluttamaasi mallia | [Python](3-Web-App/1-Web-App/README.md) | Jen |
| 10 | Johdatus luokitteluun | [Luokittelu](4-Classification/README.md) | Siivoa, valmistele ja visualisoi datasi; johdatus luokitteluun | [Python](4-Classification/1-Introduction/README.md) • [R](../../4-Classification/1-Introduction/solution/R/lesson_10.html) | Jen ja Cassie • Eric Wanjau |
| 11 | Herkulliset Aasian ja Intian keittiöt 🍜 | [Luokittelu](4-Classification/README.md) | Johdatus luokittelijoihin | [Python](4-Classification/2-Classifiers-1/README.md) • [R](../../4-Classification/2-Classifiers-1/solution/R/lesson_11.html) | Jen ja Cassie • Eric Wanjau |
| 12 | Herkulliset Aasian ja Intian keittiöt 🍜 | [Luokittelu](4-Classification/README.md) | Lisää luokittelijoita | [Python](4-Classification/3-Classifiers-2/README.md) • [R](../../4-Classification/3-Classifiers-2/solution/R/lesson_12.html) | Jen ja Cassie • Eric Wanjau |
| 13 | Herkulliset Aasian ja Intian keittiöt 🍜 | [Luokittelu](4-Classification/README.md) | Rakenna suositteluverkkosovellus mallisi avulla | [Python](4-Classification/4-Applied/README.md) | Jen |
| 14 | Johdatus klusterointiin | [Klusterointi](5-Clustering/README.md) | Siivoa, valmistele ja visualisoi datasi; johdatus klusterointiin | [Python](5-Clustering/1-Visualize/README.md) • [R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | Jen • Eric Wanjau |
| 15 | Tutustu Nigerialaisen musiikin makuun 🎧 | [Klusterointi](5-Clustering/README.md) | Tutustu K-means-klusterointimenetelmään | [Python](5-Clustering/2-K-Means/README.md) • [R](../../5-Clustering/2-K-Means/solution/R/lesson_15.html) | Jen • Eric Wanjau |
| 16 | Johdatus luonnolliseen kielen käsittelyyn ☕️ | [Luonnollisen kielen käsittely](6-NLP/README.md) | Opettele NLP:n perusteet rakentamalla yksinkertainen botti | [Python](6-NLP/1-Introduction-to-NLP/README.md) | Stephen |
| 17 | Yleiset NLP-tehtävät ☕️ | [Luonnollisen kielen käsittely](6-NLP/README.md) | Syvennä NLP-tietämystäsi ymmärtämällä yleisiä tehtäviä, joita tarvitaan kielirakenteiden käsittelyssä | [Python](6-NLP/2-Tasks/README.md) | Stephen |
| 18 | Käännös ja tunneanalyysi ♥️ | [Luonnollisen kielen käsittely](6-NLP/README.md) | Käännös ja tunneanalyysi Jane Austenin teksteillä | [Python](6-NLP/3-Translation-Sentiment/README.md) | Stephen |
| 19 | Euroopan romanttiset hotellit ♥️ | [Luonnollisen kielen käsittely](6-NLP/README.md) | Tunneanalyysi hotelliarvioiden perusteella 1 | [Python](6-NLP/4-Hotel-Reviews-1/README.md)| Stephen |
| 20 | Euroopan romanttiset hotellit ♥️ | [Luonnollisen kielen käsittely](6-NLP/README.md) | Tunneanalyysi hotelliarvioiden perusteella 2 | [Python](6-NLP/5-Hotel-Reviews-2/README.md)| Stephen |
> [löydä kaikki lisäresurssit tälle kurssille Microsoft Learn -kokoelmastamme](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
> **Huomio kielistä**: Nämä oppitunnit on pääasiassa kirjoitettu Pythonilla, mutta monet ovat saatavilla myös R:llä. R-oppitunnin suorittamiseksi siirry `/solution`-kansioon ja etsi sieltä R-oppitunteja. Niissä on .rmd-laajennus, joka tarkoittaa **R Markdown**-tiedostoa, joka voidaan yksinkertaisesti määritellä `koodipalojen` (R:n tai muiden kielten) ja `YAML-otsikon` (joka ohjaa tulosteiden kuten PDF:n muotoilua) upotukseksi `Markdown-dokumentissa`. Siten se toimii erinomaisena kirjoitusympäristönä data-analytiikassa, sillä se sallii koodin, sen tulosten sekä ajatusten yhdistämisen ja niiden kirjaamisen Markdown-muodossa. Lisäksi R Markdown -dokumentit voidaan renderöidä esimerkiksi PDF-, HTML- tai Word-muotoihin.
> **Huomio kokeista**: Kaikki kokeet ovat [Quiz App -kansiossa](../../quiz-app), yhteensä 52 koetta, joissa on kukin kolme kysymystä. Ne ovat linkitetty oppitunneille, mutta quiz-sovellusta voi ajaa myös paikallisesti; seuraa `quiz-app`-kansion ohjeita paikallista isännöintiä tai Azureen julkaisemista varten.
| Oppitunnin numero | Aihe | Oppituntiryhmä | Oppimistavoitteet | Linkitetty oppitunti | Tekijä |
| 02 | Koneoppimisen historia | [Johdanto](1-Introduction/README.md) | Opi tämän alan tausta | [Oppitunti](1-Introduction/2-history-of-ML/README.md) | Jen ja Amy |
| 03 | Oikeudenmukaisuus ja koneoppiminen | [Johdanto](1-Introduction/README.md) | Mitkä ovat tärkeät filosofiset oikeudenmukaisuuteen liittyvät kysymykset, joita opiskelijoiden tulisi harkita ML-malleja rakentaessaan ja soveltaessaan? | [Oppitunti](1-Introduction/3-fairness/README.md) | Tomomi |
| 04 | Koneoppimisen menetelmät | [Johdanto](1-Introduction/README.md) | Mitä menetelmiä ML-tutkijat käyttävät mallien rakentamiseen? | [Oppitunti](1-Introduction/4-techniques-of-ML/README.md) | Chris ja Jen |
| 05 | Johdatus regressioon | [Regressio](2-Regression/README.md) | Aloita Python- ja Scikit-learn-kirjastoilla regressiomallien tekeminen | [Python](2-Regression/1-Tools/README.md) • [R](../../2-Regression/1-Tools/solution/R/lesson_1.html) | Jen • Eric Wanjau |
| 06 | Pohjois-Amerikan kurpitsahinnat 🎃 | [Regressio](2-Regression/README.md) | Visualisoi ja siivoa dataa ML:n valmisteluksi | [Python](2-Regression/2-Data/README.md) • [R](../../2-Regression/2-Data/solution/R/lesson_2.html) | Jen • Eric Wanjau |
| 07 | Pohjois-Amerikan kurpitsahinnat 🎃 | [Regressio](2-Regression/README.md) | Rakenna lineaarisia ja polynomisia regressiomalleja | [Python](2-Regression/3-Linear/README.md) • [R](../../2-Regression/3-Linear/solution/R/lesson_3.html) | Jen ja Dmitry • Eric Wanjau |
| 08 | Pohjois-Amerikan kurpitsahinnat 🎃 | [Regressio](2-Regression/README.md) | Rakenna logistinen regressiomalli| [Python](2-Regression/4-Logistic/README.md) • [R](../../2-Regression/4-Logistic/solution/R/lesson_4.html) | Jen • Eric Wanjau |
| 16 | Johdatus luonnollisen kielen käsittelyyn ☕️ | [Luonnollisen kielen käsittely](6-NLP/README.md) | Opi NLP:n perusteet rakentamalla yksinkertainen botti | [Python](6-NLP/1-Introduction-to-NLP/README.md) | Stephen |
| 17 | Tavalliset NLP-tehtävät ☕️ | [Luonnollisen kielen käsittely](6-NLP/README.md) | Syvennä NLP-tietämystäsi ymmärtämällä tavallisia tehtäviä, joita rakenteiden käsittelyssä tarvitaan | [Python](6-NLP/2-Tasks/README.md) | Stephen |
| 18 | Käännös ja tunnetilan analyysi ♥️ | [Luonnollisen kielen käsittely](6-NLP/README.md) | Käännös ja tunnetilan analysointi Jane Austenin avulla | [Python](6-NLP/3-Translation-Sentiment/README.md) | Stephen |
| 19 | Euroopan romanttiset hotellit ♥️ | [Luonnollisen kielen käsittely](6-NLP/README.md) | Tunnetilan analysointi hotelliarvosteluilla 1 | [Python](6-NLP/4-Hotel-Reviews-1/README.md) | Stephen |
| 20 | Euroopan romanttiset hotellit ♥️ | [Luonnollisen kielen käsittely](6-NLP/README.md) | Tunnetilan analysointi hotelliarvosteluilla 2 | [Python](6-NLP/5-Hotel-Reviews-2/README.md) | Stephen |
| Jälkipuhe | Mallin vianetsintä koneoppimisessa RAI:n avulla | [ML luonnossa](9-Real-World/README.md) | Mallin vianetsintä koneoppimisessa Responsible AI -kojelaudan avulla | [Oppitunti](9-Real-World/2-Debugging-ML-Models/README.md) | Ruth Yakubu |
> [löydä kaikki kurssin lisäresurssit Microsoft Learn -kokoelmastamme](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
## Offline-käyttö
Voit käyttää tätä dokumentaatiota offline-tilassa käyttämällä [Docsifya](https://docsify.js.org/#/). Haarauta tämä repositorio, [asenna Docsify](https://docsify.js.org/#/quickstart) paikallisesti koneellesi, ja sitten tämän repositorion juurikansiossa kirjoita `docsify serve`. Verkkosivusto palvellaan portissa 3000 paikallisessa palvelimessasi: `localhost:3000`.
Voit käyttää tätä dokumentaatiota offline-tilassa käyttäen [Docsify](https://docsify.js.org/#/). Forkkaa tämä repo, [asenna Docsify](https://docsify.js.org/#/quickstart) paikalliselle koneellesi, ja aja sitten tämän repon juurikansiossa komento `docsify serve`. Sivusto palvelee portissa 3000 paikallisessa ympäristössäsi: `localhost:3000`.
[](https://aka.ms/langchain4j-for-beginners)
[](https://aka.ms/langchainjs-for-beginners?WT.mc_id=m365-94501-dwahlin)
[](https://github.com/microsoft/langchain-for-beginners?WT.mc_id=m365-94501-dwahlin)
[](https://github.com/microsoft/edgeai-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/AZD-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/edgeai-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/mcp-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/ai-agents-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/generative-ai-for-beginners?WT.mc_id=academic-105485-koreyst)
[-9333EA?style=for-the-badge&labelColor=E5E7EB&color=9333EA)](https://github.com/microsoft/Generative-AI-for-beginners-dotnet?WT.mc_id=academic-105485-koreyst)
[-C084FC?style=for-the-badge&labelColor=E5E7EB&color=C084FC)](https://github.com/microsoft/generative-ai-for-beginners-java?WT.mc_id=academic-105485-koreyst)
[-E879F9?style=for-the-badge&labelColor=E5E7EB&color=E879F9)](https://github.com/microsoft/generative-ai-with-javascript?WT.mc_id=academic-105485-koreyst)
[](https://aka.ms/ml-beginners?WT.mc_id=academic-105485-koreyst)
[](https://aka.ms/datascience-beginners?WT.mc_id=academic-105485-koreyst)
[](https://aka.ms/ai-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/Security-101?WT.mc_id=academic-96948-sayoung)
[](https://aka.ms/webdev-beginners?WT.mc_id=academic-105485-koreyst)
[](https://aka.ms/iot-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/xr-development-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://aka.ms/GitHubCopilotAI?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/mastering-github-copilot-for-dotnet-csharp-developers?WT.mc_id=academic-105485-koreyst)
Jos juutut tai sinulla on kysyttävää tekoälysovellusten rakentamisesta, liity muiden oppijoiden ja kokeneiden kehittäjien keskusteluihin MCP:stä. Se on kannustava yhteisö, jossa kysymykset ovat tervetulleita ja tietoa jaetaan vapaasti.
Jos jäät jumiin tai sinulla on kysymyksiä koneoppimisesta oppimisen tai tekoälysovellusten rakentamisen aikana, älä huoli — apua on saatavilla.
- Käy läpi muistikirjat jokaisen oppitunnin jälkeen paremman ymmärtämisen vuoksi.
- Tarkastele muistiinpanoja jokaisen oppitunnin jälkeen paremman ymmärryksen saamiseksi.
- Harjoittele algoritmien toteuttamista itse.
- Tutustu oikean maailman aineistoihin opittujen käsitteiden avulla.
- Tutki oikean maailman datakokonaisuuksia opittujen käsitteiden avulla.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Vastuuvapauslauseke**:
Tämä asiakirja on käännetty käyttämällä tekoälypohjaista käännöspalvelua [Co-op Translator](https://github.com/Azure/co-op-translator). Vaikka pyrimme tarkkuuteen, tulee huomioida, että automaattiset käännökset voivat sisältää virheitä tai epätarkkuuksia. Alkuperäistä asiakirjaa sen alkuperäisellä kielellä tulee pitää virallisena lähteenä. Tärkeiden tietojen osalta suositellaan ammattimaista ihmiskäännöstä. Emme ole vastuussa tämän käännöksen käytöstä aiheutuvista väärinkäsityksistä tai tulkinnoista.
**Vastuuvapauslauseke**:
Tämä asiakirja on käännetty käyttämällä tekoälypohjaista käännöspalvelua [Co-op Translator](https://github.com/Azure/co-op-translator). Vaikka pyrimme tarkkuuteen, huomioithan, että automaattikäännöksissä saattaa esiintyä virheitä tai epätarkkuuksia. Alkuperäinen asiakirja sen alkuperäiskielellä on virallinen lähde. Tärkeiden tietojen osalta suositellaan ammattimaista ihmiskäännöstä. Emme ole vastuussa tästä käännöksestä johtuvista väärinymmärryksistä tai tulkinnoista.
> ### [Denne leksjonen er tilgjengelig i R!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
### Introduksjon
> ### [Denne leksjonen er tilgjengelig på R!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
### Introduksjon
Så langt har du utforsket hva regresjon er med prøveutvalg samlet fra gresskarprisdatasettet som vi skal bruke gjennom denne leksjonen. Du har også visualisert det med Matplotlib.
Så langt har du utforsket hva regresjon er med eksempeldatahentet fra gresskarprisingsdatasettet som vi skal bruke gjennom denne leksjonen. Du har også visualisert det ved hjelp av Matplotlib.
Nå er du klar til å dykke dypere inn i regresjon for ML. Mens visualisering lar deg forstå data, kommer den virkelige kraften i Maskinlæring fra _trening av modeller_. Modeller trenes på historiske data for automatisk å fange opp dataavhengigheter, og de tillater deg å forutsi utfall for nye data, som modellen ikke har sett før.
Nå er du klar til å gå dypere inn i regresjon for ML. Mens visualisering hjelper deg med å forstå data, kommer den virkelige styrken i maskinlæring fra _trening av modeller_. Modeller trenes på historiske data for automatisk å fange dataavhengigheter, og de lar deg forutsi utfall for nye data som modellen ikke har sett før.
I denne leksjonen vil du lære mer om to typer regresjon: _grunnleggende lineær regresjon_ og _polynomisk regresjon_, sammen med noe av matematikken som ligger til grunn for disse teknikkene. Disse modellene vil tillate oss å forutsi gresskarpriser basert på forskjellige inngangsdata.
I denne leksjonen vil du lære mer om to typer regresjon: _grunnleggende lineær regresjon_ og _polynomisk regresjon_, sammen med noe av matematikken som ligger til grunn for disse teknikkene. Disse modellene vil tillate oss å forutsi gresskarpriser avhengig av ulike inngangsdata.
[](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression")
> 🎥 Klikk på bildet ovenfor for en kort videooversikt over lineær regresjon.
> 🎥 Klikk på bildet over for en kort videooversikt over lineær regresjon.
> Gjennom dette pensumet forutsetter vi minimal kunnskap i matematikk, og søker å gjøre det tilgjengelig for studenter fra andre fagfelt, så hold øye med notater, 🧮 markeringer, diagrammer og andre læringsverktøy for å hjelpe forståelsen.
> Gjennom denne lærestien antar vi minimal matematikkunnskap, og søker å gjøre den tilgjengelig for studenter fra andre fagfelt, så se etter notater, 🧮 markeringer, diagrammer og andre læringsverktøy for å lette forståelsen.
### Forutsetninger
### Forutsetning
Du bør nå være kjent med strukturen på gresskardataene som vi undersøker. Du kan finne det forhåndslastet og forhåndsrenset i denne leksjonens _notebook.ipynb_-fil. I filen vises gresskarpris per bushel i en ny dataramme. Sørg for at du kan kjøre disse notatbøkene i kjerne i Visual Studio Code.
Du bør nå være kjent med strukturen til gresskardataene vi undersøker. Du finner dem ferdig lastet og forhåndsrenset i denne leksjonens _notebook.ipynb_-fil. I filen vises gresskarprisen per bushel i en ny datastruktur. Sørg for at du kan kjøre disse notatbøkene i miljøer i Visual Studio Code.
### Forberedelse
Som en påminnelse laster du inn disse dataene for å stille spørsmål til dem.
Som en påminnelse lastes disse dataene inn for at du skal kunne stille spørsmål til dem.
- Når er det beste tidspunktet å kjøpe gresskar?
- Hvilken pris kan jeg forvente på en kasse med miniatyrgresskar?
- Bør jeg kjøpe dem i halvbukettkurver eller i 1 1/9 bushel-boksen?
La oss fortsette å grave i disse dataene.
- Hvilken pris kan jeg forvente for en kasse med miniatyrgresskar?
- Bør jeg kjøpe dem i halvbusselkurver, eller i 1 1/9 bushel-esker?
La oss grave videre i disse dataene.
I forrige leksjon opprettet du en Pandas-dataramme og fylte den med deler av det originale datasettet, og standardiserte prisene per bushel. Ved å gjøre det, klarte du imidlertid bare å samle inn omtrent 400 datapunkter og kun for høstmånedene.
I forrige leksjon opprettet du en Pandas-dataramme og fylte den med deler av det originale datasettet, og standardiserte prisene per bushel. Ved å gjøre det fikk du imidlertid bare omtrent 400 datapunkter og kun for høstmånedene.
Ta en titt på dataene vi forhåndslastet i denne leksjonens medfølgende notatbok. Dataene er forhåndslastet, og en innledende spredningsdiagram er tegnet for å vise månedsdata. Kanskje vi kan få litt mer detalj om datanaturen ved å rense den mer.
Ta en titt på dataene vi har lastet inn i denne leksjonens medfølgende notatbok. Dataene er forhåndslastet, og det lages et første spredningsdiagram for å vise månedens data. Kanskje vi kan få litt mer detalj rundt datanaturen ved å rense det mer.
## En lineær regresjonslinje
Som du lærte i leksjon 1, er målet med en lineær regresjonsøvelse å kunne plotte en linje for å:
- **Vis variable relasjoner**. Vis forholdet mellom variabler
- **Gjøre prediksjoner**. Gjør nøyaktige prediksjoner om hvor et nytt datapunkt vil falle i forhold til den linjen.
- **Vise variabelrelasjoner**. Vise forholdet mellom variabler
- **Lage spådommer**. Lage nøyaktige spådommer om hvor et nytt datapunkt vil falle i forhold til den linjen.
Det er vanlig med **minste kvadraters regresjon** å tegne denne typen linje. Begrepet "minste kvadraters" refererer til prosessen med å minimere den totale feilen i modellen vår. For hvert datapunkt måler vi den vertikale avstanden (kalt et residual) mellom det faktiske punktet og regresjonslinjen vår.
Det er typisk med **Minimum kvadraters regresjon** å tegne denne typen linje. Begrepet "Minimum kvadraters" refererer til prosessen med å minimere den totale feilen i modellen vår. For hvert datapunkt måler vi den vertikale avstanden (kalt residual) mellom det faktiske punktet og vår regresjonslinje.
Vi kvadrerer disse avstandene av to hovedgrunner:
Vi kvadrerer disse avstandene av to hovedgrunner:
1. **Størrelse over retning:** Vi ønsker å behandle en feil på -5 det samme som en feil på +5. Kvadrering gjør alle verdier positive.
1. **Størrelse over retning:** Vi ønsker å behandle en feil på -5 likt som en feil på +5. Kvadrering gjør alle verdier positive.
2. **Straff for uteliggere:** Kvadrering gir mer vekt til større feil, og tvinger linjen til å holde seg nærmere punkter som ligger langt unna.
2. **Straffe uteliggere:** Kvadrering gir større vekt til større feil, og tvinger linjen til å holde seg nærmere punkter som er langt unna.
Deretter legger vi sammen alle disse kvadrerte verdiene. Målet vårt er å finne den spesifikke linjen hvor denne endelige summen er på sitt laveste (den minste mulige verdien) — derav navnet "minste kvadraters".
Vi legger deretter sammen alle disse kvadrerte verdiene. Målet vårt er å finne den spesifikke linjen der denne endelige summen er minst (den minste mulige verdien)—derav navnet "Minimum kvadraters".
> **🧮 Vis meg matematikken**
> **🧮 Vis meg matematikken**
>
> Denne linjen, kalt _best fit-linjen_ kan uttrykkes ved [en ligning](https://en.wikipedia.org/wiki/Simple_linear_regression):
> Denne linjen, kalt _beste tilpassede linje_, kan uttrykkes ved [en ligning](https://en.wikipedia.org/wiki/Simple_linear_regression):
>
> ```
> Y = a + bX
> ```
>
> `X` er den 'forklarende variabelen'. `Y` er den 'avhengige variabelen'. Stigningstallet til linjen er `b` og `a` er y-avskjæringen, som refererer til verdien av `Y` når `X = 0`.
> `X` er 'den forklarende variabelen'. `Y` er 'den avhengige variabelen'. Helningen til linjen er `b` og `a` er y-aksens skjæringspunkt, som refererer til verdien av `Y` når `X = 0`.
> Først beregnes stigningen `b`. Infografikk av [Jen Looper](https://twitter.com/jenlooper)
> Først beregner vi helningen `b`. Infografikk av [Jen Looper](https://twitter.com/jenlooper)
>
> Med andre ord, og med henvisning til vårt gresskardatas opprinnelige spørsmål: "forutsi prisen på et gresskar per bushel etter måned", vil `X` referere til prisen og `Y` til salgsmåneden.
> Med andre ord, og med referanse til vår originale gresskardataspørsmål: "forutsi prisen på et gresskar per bushel etter måned", ville`X` referere til prisen og `Y` til salgsmåneden.
> Beregn verdien av Y. Hvis du betaler rundt 4 dollar, må det være april! Infografikk av [Jen Looper](https://twitter.com/jenlooper)
> Beregn verdien av Y. Hvis du betaler rundt $4, må det være april! Infografikk av [Jen Looper](https://twitter.com/jenlooper)
>
> Matematikk som beregner linjen må demonstrere linjens stigning, som også avhenger av avskjæringen, eller hvor `Y` er plassert når `X = 0`.
> Matematikken som beregner linjen må vise helningen til linjen, som også avhenger av skjæringspunktet, altså hvor `Y` befinner seg når `X = 0`.
>
> Du kan observere metoden for beregning av disse verdiene på [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html) nettstedet. Besøk også [denne minste kvadraters kalkulator](https://www.mathsisfun.com/data/least-squares-calculator.html) for å se hvordan tallverdiene påvirker linjen.
> Du kan se metoden for beregning av disse verdiene på [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html) sin nettside. Besøk også [denne Minimum kvadraters kalkulatoren](https://www.mathsisfun.com/data/least-squares-calculator.html) for å se hvordan tallverdiene påvirker linjen.
## Korrelasjon
Et annet begrep å forstå er **korrelasjonskoeffisienten** mellom gitte X og Y variabler. Ved å bruke et spredningsdiagram kan du raskt visualisere denne koeffisienten. Et plott med datapunkter fordelt i en pen linje har høy korrelasjon, men et plott med datapunkter spredt overalt mellom X og Y har lav korrelasjon.
Et siste begrep å forstå er **Korrelasjonskoeffisienten** mellom gitte X- og Y-variabler. Ved bruk av et spredningsdiagram kan du raskt visualisere denne koeffisienten. Et plot med datapunkter spredt langs en fin linje har høy korrelasjon, mens et plot med datapunkter spredt overalt mellom X og Y har lav korrelasjon.
En god lineær regresjonsmodell vil være en som har høy (nærmere 1 enn 0) korrelasjonskoeffisient ved bruk av minste kvadraters regresjonsmetode med en regresjonslinje.
En god lineær regresjonsmodell vil være en som har høy (nærmere 1 enn 0) korrelasjonskoeffisient ved bruk av Minimum kvadraters regresjonsmetode med en regresjonslinje.
✅ Kjør notatboken som følger med denne leksjonen og se på spredningsplottet for Måned mot Pris. Ser dataene som kobler Måned til Pris for gresskarsalg ut til å ha høy eller lav korrelasjon, i henhold til din visuelle tolkning av spredningsplottet? Endres det hvis du bruker et mer detaljert mål i stedet for `Month`, f.eks. *dag i året* (dvs. antall dager siden begynnelsen av året)?
✅ Kjør notatboken som følger denne leksjonen og se på spredningsdiagrammet mellom måned og pris. Ser dataene som assosierer måned til pris for gresskarsalg ut til å ha høy eller lav korrelasjon, i henhold til din visuelle tolkning av spredningsplottet? Endrer det seg om du bruker en mer finmasket måling i stedet for `Month`, f.eks. *dag på året* (altså antall dager siden starten på året)?
I koden nedenfor antar vi at vi har renset dataene, og oppnådd en dataramme kalt `new_pumpkins`, lik følgende:
I koden nedenfor antar vi at vi har renset dataene, og fått en dataramme kalt `new_pumpkins`, som ligner på følgende:
ID | Month | DayOfYear | Variety | City | Package | Low Price | High Price | Price
> Koden for å rense dataene er tilgjengelig i [`notebook.ipynb`](notebook.ipynb). Vi har utført de samme renseprosedyrene som i forrige leksjon, og har beregnet kolonnen `DayOfYear` ved hjelp av følgende uttrykk:
> Koden for å rense dataene er tilgjengelig i [`notebook.ipynb`](notebook.ipynb). Vi har utført de samme rensetrinnene som i forrige leksjon, og har beregnet `DayOfYear`-kolonnen med følgende uttrykk:
Nå som du har forståelse for matematikken bak lineær regresjon, la oss lage en regresjonsmodell for å se om vi kan forutsi hvilken pakke med gresskar som vil ha de beste gresskarprisene. Noen som kjøper gresskar til en høstgresskarhage kan ønske denne informasjonen for å kunne optimalisere sine kjøp av gresskarpakker til hagen.
## Ser etter korrelasjon
Nå som du har forstått matematikken bak lineær regresjon, la oss lage en regresjonsmodell for å se om vi kan forutsi hvilken pakke gresskar som vil ha de beste prisene. Noen som kjøper gresskar til en høytidssesong kanskje vil ha denne informasjonen for å kunne optimalisere sine gresskarpakkeinnkjøp til sesongen.
## På jakt etter korrelasjon
[](https://youtu.be/uoRq-lW2eQo "ML for beginners - Looking for Correlation: The Key to Linear Regression")
> 🎥 Klikk på bildet ovenfor for en kort videooversikt over korrelasjon.
> 🎥 Klikk på bildet over for en kort videooversikt over korrelasjon.
Fra forrige leksjon har du sannsynligvis sett at gjennomsnittsprisen for ulike måneder ser slik ut:
<imgalt="Gjennomsnittspris per måned"src="../../../../translated_images/no/barchart.a833ea9194346d76.webp"width="50%"/>
Dette antyder at det bør være en viss korrelasjon, og vi kan prøve å trene en lineær regresjonsmodell for å predikere forholdet mellom `Month` og `Price`, eller mellom `DayOfYear` og `Price`. Her er spredningsplottet som viser det sistnevnte forholdet:
Dette antyder at det bør finnes en viss korrelasjon, og vi kan prøve å trene en lineær regresjonsmodell for å forutsi forholdet mellom `Month` og `Price`, eller mellom `DayOfYear` og `Price`. Her er spredningsdiagrammet som viser sistnevnte forhold:
<imgalt="Spredningsplott av Pris vs. Dag i året" src="../../../../translated_images/no/scatter-dayofyear.bc171c189c9fd553.webp"width="50%"/>
<imgalt="Spredningsdiagram av pris vs. dag på året" src="../../../../translated_images/no/scatter-dayofyear.bc171c189c9fd553.webp"width="50%"/>
La oss se om det er en korrelasjon ved å bruke `corr`-funksjonen:
La oss se om det er korrelasjon ved å bruke `corr`-funksjonen:
Det ser ut som korrelasjonen er ganske liten, -0.15 basert på `Month` og -0.17 basert på `DayOfYear`, men det kan være et annet viktig forhold. Det ser ut til å være forskjellige klynger av priser som tilsvarer forskjellige gresskarsorter. For å bekrefte denne hypotesen, la oss tegne hver gresskarkategori med en annen farge. Ved å sende inn en `ax`-parameter til `scatter`-plottfunksjonen kan vi tegne alle punktene på samme graf:
Det ser ut som korrelasjonen er ganske liten, -0.15 for `Month` og -0.17 for `DayOfMonth`, men det kan finnes en annen viktig sammenheng. Det ser ut til å være forskjellige klynger av priser som tilsvarer ulike gresskartyper. For å bekrefte denne hypotesen, la oss plotte hver gresskarkategori med forskjellig farge. Ved å sende med `ax`-parameteren til `scatter` plottefunksjonen kan vi plotte alle punktene i samme graf:
```python
ax=None
@ -140,42 +142,43 @@ for i,var in enumerate(new_pumpkins['Variety'].unique()):
<imgalt="Spredningsplott av Pris vs. Dag i året" src="../../../../translated_images/no/scatter-dayofyear-color.65790faefbb9d54f.webp"width="50%"/>
<imgalt="Spredningsdiagram av pris vs. dag på året med farge" src="../../../../translated_images/no/scatter-dayofyear-color.65790faefbb9d54f.webp"width="50%"/>
Vår undersøkelse antyder at sort har større effekt på den totale prisen enn den faktiske salgsdatoen. Vi kan se dette med et stolpediagram:
Vår undersøkelse antyder at variasjon har større effekt på den totale prisen enn selve salgsdatoen. Vi kan se dette med et stolpediagram:
<imgalt="Spredningsplott av Pris vs. Dag i året" src="../../../../translated_images/no/pie-pumpkins-scatter.d14f9804a53f927e.webp"width="50%"/>
<imgalt="Spredningsdiagram av pris vs. dag på året for pie pumpkins" src="../../../../translated_images/no/pie-pumpkins-scatter.d14f9804a53f927e.webp"width="50%"/>
Hvis vi nå beregner korrelasjonen mellom `Price` og `DayOfYear` ved bruk av `corr`-funksjonen, får vi noe som `-0.27`– noe som betyr at det gir mening å trene en prediksjonsmodell.
Hvis vi nå beregner korrelasjonen mellom `Price` og `DayOfYear` ved bruk av `corr`-funksjonen, får vi omtrent`-0.27`– noe som betyr at det gir mening å trene en prediksjonsmodell.
> Før vi trener en lineær regresjonsmodell, er det viktig å sørge for at dataene våre er rene. Lineær regresjon fungerer ikke godt med manglende verdier, så det gir mening å kvitte seg med alle tomme celler:
> Før du trener en lineær regresjonsmodell, er det viktig å sørge for at dataene våre er rene. Lineær regresjon fungerer ikke godt med manglende verdier, så det er lurt å kvitte seg med tomme celler:
```python
pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info()
```
En annen tilnærming kan være å fylle de tomme verdiene med gjennomsnittsverdier fra den tilsvarende kolonnen.
En annen tilnærming kan være å fylle disse tomme verdiene med gjennomsnittsverdier fra den tilsvarende kolonnen.
## Enkel lineær regresjon
[](https://youtu.be/e4c_UP2fSjg "ML for beginners - Linear and Polynomial Regression using Scikit-learn")
> 🎥 Klikk på bildet ovenfor for en kort videooversikt over lineær og polynomisk regresjon.
> 🎥 Klikk på bildet over for en kort videooversikt over lineær og polynomisk regresjon.
For å trene vår lineære regresjonsmodell, vil vi bruke **Scikit-learn**-biblioteket.
For å trene vår lineære regresjonsmodell, bruker vi **Scikit-learn**biblioteket.
```python
from sklearn.linear_model import LinearRegression
@ -183,48 +186,51 @@ from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
```
Vi starter med å separere inngangsverdier (egenskaper) og forventet utgang (etikett) i separate numpy-arrays:
Vi begynner med å separere inngangsverdiene (funksjoner) og forventet utgang (etikett) i separate numpy-arrays:
```python
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price']
```
> Merk at vi måtte utføre `reshape` på inngangsdataene for at Linear Regression-pakken skulle forstå det korrekt. Lineær regresjon forventer et 2D-array som input, der hver rad av arrayet tilsvarer en vektor med inngangsegenskaper. I vårt tilfelle, siden vi bare har én input, trenger vi et array med formen N×1, der N er datastørrelsen.
Deretter må vi splitte dataene i trenings- og testdatasett, slik at vi kan validere modellen vår etter trening:
> Merk at vi måtte utføre `reshape` på inngangsdataene for at Linear Regression-pakken skulle forstå dem riktig. Lineær regresjon forventer et 2D-array som input, hvor hver rad i arrayet tilsvarer en vektor av inngangsfunksjoner. I vårt tilfelle, siden vi bare har én inngang, trenger vi et array med form N×1, hvor N er dataset-størrelsen.
Deretter må vi dele dataene i trenings- og testdatasett, slik at vi kan validere modellen vår etter trening:
```python
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```
Til slutt tar trening av den faktiske lineære regresjonsmodellen bare to kodelinjer. Vi definerer `LinearRegression`-objektet, og tilpasser det til dataene våre med `fit`-metoden:
Til slutt tar det bare to linjer med kode å trene den faktiske lineære regresjonsmodellen. Vi definerer `LinearRegression`-objektet, og passer det til dataene våre ved hjelp av `fit`-metoden:
```python
lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)
```
Objektet `LinearRegression` etter at det er blitt `fit`-tet inneholder alle koeffisientene til regresjonen, som kan aksesseres ved hjelp av `.coef_`-egenskapen. I vårt tilfelle er det bare én koeffisient, som bør være rundt `-0.017`. Det betyr at prisene ser ut til å synke litt med tiden, men ikke så mye, omtrent 2 cent per dag. Vi kan også aksessere skjæringspunktet til regresjonen med Y-aksen ved å bruke `lin_reg.intercept_` - det vil være rundt `21` i vårt tilfelle, noe som indikerer prisen ved begynnelsen av året.
`LinearRegression`-objektet etter at vi har "fit"-tet det inneholder alle koeffisientene til regresjonen, som kan aksesseres ved hjelp av `.coef_`-egenskapen. I vårt tilfelle er det bare én koeffisient, som skal være rundt `-0.017`. Det betyr at prisene ser ut til å synke litt med tiden, men ikke for mye, omtrent 2 cent per dag. Vi kan også aksessere skjæringspunktet for regresjonen med Y-aksen ved å bruke `lin_reg.intercept_` - det vil være rundt `21` i vårt tilfelle, noe som indikerer prisen i begynnelsen av året.
For å se hvor nøyaktig modellen vår er, kan vi predikere priser på et testdatasett, og deretter måle hvor nær våre prediksjoner er til de forventede verdiene. Dette kan gjøres ved hjelp av gjennomsnittlig kvadratfeil (MSE) metrikken, som er gjennomsnittet av alle kvadrerte forskjeller mellom forventet og predikert verdi.
For å se hvor nøyaktig modellen vår er, kan vi forutsi priser på en testdatasett, og deretter måle hvor nær våre prediksjoner er de forventede verdiene. Dette kan gjøres ved hjelp av rotmiddelkvadratfeil (RMSE) metrikk, som er roten av gjennomsnittet av alle kvadrerte forskjeller mellom forventet og forutsagt verdi.
Feilen vår ser ut til å være rundt 2 poeng, som er ~17%. Ikke så bra. En annen indikator på modellkvalitet er **determinasjonskoeffisienten**, som kan oppnås på denne måten:
Feilen vår ser ut til å være rundt 2 poeng, som er ~17%. Ikke så bra. En annen indikator på modellkvalitet er **bestemmelseskoeffisienten**, som kan oppnås slik:
```python
score = lin_reg.score(X_train,y_train)
print('Model determination: ', score)
```
Hvis verdien er 0, betyr det at modellen ikke tar hensyn til innndataene, og fungerer som den *verste lineære prediktoren*, som rett og slett er et gjennomsnitt av resultatet. Verdien 1 betyr at vi kan perfekt predikere alle forventede utganger. I vårt tilfelle er koeffisienten rundt 0.06, som er ganske lav.
Hvis verdien er 0, betyr det at modellen ikke tar hensyn til inngangsdata, og oppfører seg som den *verste lineære prediktoren*, som rett og slett er et gjennomsnitt av resultatet. Verdien 1 betyr at vi kan perfekt forutsi alle forventede utganger. I vårt tilfelle er koeffisienten rundt 0.06, som er ganske lavt.
Vi kan også plotte testdata sammen med regresjonslinjen for bedre å se hvordan regresjon fungerer i vårt tilfelle:
Vi kan også plotte testdata sammen med regresjonslinjen for bedre å se hvordan regresjonen fungerer i vårt tilfelle:
```python
plt.scatter(X_test,y_test)
@ -235,17 +241,17 @@ plt.plot(X_test,pred)
## Polynomregresjon
En annen type lineær regresjon er polynomregresjon. Selv om det noen ganger er et lineært forhold mellom variabler – jo større gresskaret er i volum, desto høyere er prisen – kan disse forholdene noen ganger ikke plottes som et plan eller en rett linje.
En annen type lineær regresjon er polynomregresjon. Selv om det noen ganger er et lineært forhold mellom variabler - jo større gresskaret er i volum, desto høyere pris - kan disse forholdene noen ganger ikke plottes som et plan eller en rett linje.
✅ Her er [noen flere eksempler](https://online.stat.psu.edu/stat501/lesson/9/9.8) på data som kan bruke polynomregresjon
✅ Her er [noen flere eksempler](https://online.stat.psu.edu/stat501/lesson/9/9.8) på data som kan bruke polynomregresjon.
Ta en ny titt på forholdet mellom dato og pris. Virker ikke dette scatterplottet som om det nødvendigvis bør analyseres med en rett linje? Kan ikke prisene svinge? I så fall kan du prøve polynomregresjon.
Ta en ny titt på forholdet mellom dato og pris. Virker dette spredningsplottet som det nødvendigvis bør analyseres med en rett linje? Kan ikke prisene fluktuere? I så fall kan du prøve polynomregresjon.
✅ Polynomier er matematiske uttrykk som kan bestå av en eller flere variabler og koeffisienter
✅ Polynomuttrykk er matematiske uttrykk som kan bestå av én eller flere variabler og koeffisienter.
Polynomregresjon lager en buet linje for bedre å tilpasse ikke-lineære data. I vårt tilfelle, hvis vi inkluderer en kvadratisk `DayOfYear`-variabel i inndataene, bør vi kunne tilpasse våre data med en parabolsk kurve, som vil ha et minimum på et visst punkt i løpet av året.
Polynomregresjon lager en buet linje for bedre å tilpasse ikke-lineære data. I vårt tilfelle, hvis vi inkluderer en kvadratert `DayOfYear`-variabel i inputdataene, bør vi kunne tilpasse dataene våre med en parabolsk kurve som har et minimum på et bestemt punkt i løpet av året.
Scikit-learn inkluderer en nyttig [pipeline API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) for å kombinere forskjellige trinn i databehandling. En **pipeline** er en kjede av **estimatorer**. I vårt tilfelle vil vi lage en pipeline som først legger til polynomfunksjoner til modellen vår, og deretter trener regresjonen:
Scikit-learn inkluderer en nyttig [pipeline API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) for å kombinere forskjellige steg i databehandlingen. En **pipeline** er en kjede av **estimatorer**. I vårt tilfelle lager vi en pipeline som først legger til polynomfunksjoner i modellen, og deretter trener regresjonen:
```python
from sklearn.preprocessing import PolynomialFeatures
Å bruke `PolynomialFeatures(2)` betyr at vi inkluderer alle andregradspolynomer fra inndataene. I vårt tilfelle betyr det bare `DayOfYear`<sup>2</sup>, men gitt to inngangsvariabler X og Y, vil dette legge til X<sup>2</sup>, XY og Y<sup>2</sup>. Vi kan også bruke polynomer med høyere grad hvis vi ønsker det.
Å bruke `PolynomialFeatures(2)` betyr at vi vil inkludere alle polynomer av andre grad fra inputdataene. I vårt tilfelle betyr det bare `DayOfYear`<sup>2</sup>, men gitt to inputvariabler X og Y, vil dette legge til X<sup>2</sup>, XY og Y<sup>2</sup>. Vi kan også bruke polynomer av høyere grad om vi ønsker.
Pipelines kan brukes på samme måte som det originale `LinearRegression`-objektet, dvs. vi kan `fit`-te pipelinen, og deretter bruke `predict` for å få prediksjonsresultater. Her er grafen som viser testdataene og tilnærmingskurven:
Pipelines kan brukes på samme måte som det originale `LinearRegression`-objektet, altså kan vi `fit` pipe-linen, og deretter bruke `predict` for å få prediksjonsresultatene. Her er grafen som viser testdataene og tilnærmingskurven:
Ved å bruke polynomregresjon kan vi få litt lavere MSE og høyere determinering, men ikke signifikant. Vi må ta hensyn til andre funksjoner!
Ved å bruke polynomregresjon kan vi få litt lavere MSE og høyere bestemmelseskoeffisient, men ikke signifikant. Vi må ta hensyn til andre funksjoner!
> Du kan se at de laveste gresskarprisene observeres et sted rundt Halloween. Hvordan kan du forklare dette?
> Du kan se at de minimale gresskarprisene observeres en plass rundt Halloween. Hvordan kan du forklare dette?
🎃 Gratulerer, du har nettopp laget en modell som kan hjelpe til med å forutsi prisen på paigresskar. Du kan sannsynligvis gjenta samme prosedyre for alle gresskartyper, men det ville være tidkrevende. La oss nå lære hvordan vi tar hensyn til gresskarvariant i modellen vår!
🎃 Gratulerer, du har nettopp laget en modell som kan hjelpe med å forutsi prisen på paigresskar. Du kan sannsynligvis gjenta den samme prosedyren for alle gresskartypene, men det ville være tidkrevende. La oss nå lære hvordan vi tar hensyn til gresskarvarianter i modellen vår!
## Kategoriske variabler
## Kategoriske funksjoner
I en ideell verden ønsker vi å kunne forutsi priser for forskjellige gresskarvarianter ved å bruke den samme modellen. Men kolonnen `Variety` er litt annerledes enn kolonner som `Month`, fordi den inneholder ikke-numeriske verdier. Slike kolonner kalles **kategoriske**.
I den ideelle verden ønsker vi å kunne forutsi priser for forskjellige gresskarvarianter ved hjelp av samme modell. Men `Variety`-kolonnen er noe annerledes enn kolonner som `Month`, fordi den inneholder ikke-numeriske verdier. Slike kolonner kalles **kategoriske**.
[](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression")
> 🎥 Klikk på bildet over for en kort videooversikt over bruk av kategoriske variabler.
> 🎥 Klikk bildet over for en kort videooversikt over bruk av kategoriske funksjoner.
Her kan du se hvordan gjennomsnittsprisen avhenger av variasjon:
Her kan du se hvordan gjennomsnittsprisen avhenger av variant:
<imgalt="Average price by variety"src="../../../../translated_images/no/price-by-variety.744a2f9925d9bcb4.webp"width="50%"/>
For å ta varianter i betraktning, må vi først konvertere det til numerisk form, eller **kode** det. Det finnes flere måter vi kan gjøre det på:
For å ta hensyn til variant må vi først konvertere den til numerisk form, eller **kode** den. Det finnes flere måter vi kan gjøre dette på:
* Enkel **numerisk koding** bygger en tabell med forskjellige varianter, og erstatter så variantnavnet med en indeks i tabellen. Dette er ikke den beste idéen for lineær regresjon, fordi lineær regresjon tar den faktiske numeriske verdien av indeksen, og legger det til resultatet multiplisert med en koeffisient. I vårt tilfelle er forholdet mellom indeksnummer og pris klart ikke-lineært, selv om vi sørger for at indeksene er ordnet på en bestemt måte.
* **One-hot-koding**erstatter kolonnen `Variety` med 4 forskjellige kolonner, én for hver variant. Hver kolonne inneholder `1` hvis raden tilsvarer den aktuelle varianten, og `0` ellers. Det betyr at det vil være fire koeffisienter i den lineære regresjonen, én for hver gresskarvariant, ansvarlig for "startpris" (eller heller "tillegg" pris) for den aktuelle varianten.
* Enkel **nummerisk koding** vil bygge en tabell over ulike varianter, og deretter erstatte variantnavnet med en indeks i denne tabellen. Dette er ikke det beste for lineær regresjon, fordi lineær regresjon tar den faktiske numeriske verdien av indeksen og legger den til resultatet, multiplisert med en koeffisient. I vårt tilfelle er forholdet mellom indeksnummer og pris tydelig ikke-lineært, selv om vi sørger for at indeksene er ordnet på en bestemt måte.
* **One-hot-koding**vil erstatte `Variety`-kolonnen med 4 ulike kolonner, én for hver variant. Hver kolonne vil inneholde `1` hvis den tilsvarende raden er av en gitt variant, og `0` ellers. Dette betyr at det vil være fire koeffisienter i lineær regresjon, én for hver gresskarvariant, som er ansvarlige for "startpris" (eller heller "tilleggpris") for akkurat den varianten.
Koden nedenfor viser hvordan vi kan en-til-en kode en variant:
Koden nedenfor viser hvordan vi kan one-hot kode en variant:
For å trene lineær regresjon med one-hot kodet variant som input, må vi bare initialisere `X` og `y` data korrekt:
For å trene lineær regresjon med one-hot-kodet variant som input, trenger vi bare å initialisere `X` og `y` data riktig:
```python
X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price']
```
Resten av koden er den samme som vi brukte ovenfor for å trene lineær regresjon. Hvis du prøver det, vil du se at gjennomsnittlig kvadratfeil er omtrent den samme, men vi får mye høyere determinering (~77%). For å få enda mer nøyaktige prediksjoner kan vi ta med flere kategoriske variabler, samt numeriske funksjoner, som `Month` eller `DayOfYear`. For å få et stort array med funksjoner kan vi bruke `join`:
Resten av koden er den samme som vi brukte overfor for å trene Linear Regression. Hvis du prøver det, vil du se at middel kvadratfeil er omtrent den samme, men vi får mye høyere bestemmelseskoeffisient (~77%). For å få enda mer nøyaktige prediksjoner kan vi ta med flere kategoriske funksjoner, samt numeriske funksjoner som `Month` eller `DayOfYear`. For å få en stor tabell med alle funksjoner kan vi bruke `join`:
```python
X = pd.get_dummies(new_pumpkins['Variety']) \
@ -319,31 +325,31 @@ X = pd.get_dummies(new_pumpkins['Variety']) \
y = new_pumpkins['Price']
```
Her tar vi også hensyn til `City` og `Package`-type, noe som gir oss MSE 2.84 (10%), og determinering 0.94!
Her tar vi også hensyn til `City` og `Package` type, som gir oss MSE 2.84 (10%), og bestemmelse 0.94!
## Sette det hele sammen
## Å sette det hele sammen
For å lage den beste modellen kan vi bruke kombinert (one-hot kodet kategorisk + numeriske) data fra eksempelet ovenfor sammen med polynomregresjon. Her er den komplette koden for din bekvemmelighet:
For å lage den beste modellen kan vi bruke kombinert (one-hot kodet kategorisk + numerisk) data fra eksempelet ovenfor sammen med polynomregresjon. Her er den komplette koden for din bekvemmelighet:
```python
# sett opp treningsdata
# Sett opp treningsdata
X = pd.get_dummies(new_pumpkins['Variety']) \
.join(new_pumpkins['Month']) \
.join(pd.get_dummies(new_pumpkins['City'])) \
.join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']
# lag trenings-test deling
# Lag trenings- og testdeling
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
Dette bør gi oss den beste determinering-koeffisienten på nesten 97%, og MSE=2.23 (~8% prediksjonsfeil).
Dette skal gi oss den beste bestemmelseskoeffisienten på nesten 97%, og MSE=2.23 (~8% prediksjonsfeil).
| Modell | MSE | Determinering |
|--------|-----|---------------|
| Modell | MSE | Bestemmelse |
|-------|-----|---------------|
| `DayOfYear` Lineær | 2.77 (17.2%) | 0.07 |
| `DayOfYear` Polynom | 2.73 (17.0%) | 0.08 |
| `Variety` Lineær | 5.24 (19.7%) | 0.77 |
| Alle funksjoner Lineær | 2.84 (10.5%) | 0.94 |
| Alle funksjoner Polynom | 2.23 (8.25%) | 0.97 |
🏆 Bra jobbet! Du laget fire regresjonsmodeller i én leksjon, og forbedret modellkvaliteten til 97%. I den siste delen om regresjon vil du lære om logistisk regresjon for å bestemme kategorier.
🏆 Bra jobbet! Du har laget fire regresjonsmodeller i én lekse, og forbedret modellkvaliteten til 97%. I den siste delen om regresjon vil du lære om logistisk regresjon for kategoribestemmelse.
---
## 🚀Utfordring
Test flere forskjellige variable i denne notebooken for å se hvordan korrelasjon samsvarer med modellnøyaktighet.
Test flere forskjellige variabler i denne notatboken for å se hvordan korrelasjon stemmer med modellnøyaktighet.
## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
## Gjennomgang og selvstudie
## Gjennomgang & Selvstudium
I denne leksjonen lærte vi om lineær regresjon. Det finnes andre viktige typer regresjon. Les om Stepwise, Ridge, Lasso og Elasticnet teknikker. Et godt kurs å studere for å lære mer er [Stanford Statistical Learning-kurset](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning)
@ -381,6 +387,6 @@ I denne leksjonen lærte vi om lineær regresjon. Det finnes andre viktige typer
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Ansvarsfraskrivelse**:
Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vennligst vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det opprinnelige dokumentet på originalspråket 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 fra bruken av denne oversettelsen.
**Ansvarsfraskrivelse**:
Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vennligst vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på originalsproget 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.
I denne leksjonen skal du bruke datasettet du lagret fra forrige leksjon, som inneholder balanserte og rene data om matretter.
I denne leksjonen skal du bruke datasettet du lagret fra forrige leksjon fullt av balansert, rent data om kjøkken.
Du vil bruke dette datasettet med ulike klassifiseringsmetoder for å _forutsi en nasjonal matrett basert på en gruppe ingredienser_. Mens du gjør dette, vil du lære mer om hvordan algoritmer kan brukes til klassifiseringsoppgaver.
Du skal bruke dette datasettet med en rekke klassifikatorer for å _forutsi en gitt nasjonal kjøkken basert på en gruppe ingredienser_. Mens du gjør dette, vil du lære mer om noen av måtene algoritmer kan utnyttes til klassifiseringsoppgaver.
## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
Forutsatt at du fullførte [Leksjon 1](../1-Introduction/README.md), sørg for at en _cleaned_cuisines.csv_-fil finnes i rotmappen `/data` for disse fire leksjonene.
Forutsatt at du fullførte [Leksjon 1](../1-Introduction/README.md), sørg for at en fil kalt _cleaned_cuisines.csv_ finnes i rotmappen `/data` for disse fire leksjonene.
## Øvelse - forutsi en nasjonal matrett
## Øvelse - forutsi et nasjonalt kjøkken
1. Arbeid i denne leksjonens _notebook.ipynb_-mappe, og importer filen sammen med Pandas-biblioteket:
1. Arbeid i denne leksjonens _notebook.ipynb_-mappe, importer den filen sammen med Pandas-biblioteket:
```python
import pandas as pd
@ -19,7 +19,7 @@ Forutsatt at du fullførte [Leksjon 1](../1-Introduction/README.md), sørg for a
@ -77,73 +77,73 @@ Forutsatt at du fullførte [Leksjon 1](../1-Introduction/README.md), sørg for a
Nå er du klar til å trene modellen din!
## Velge klassifiseringsmetode
## Velge klassifikatoren din
Nå som dataene dine er rene og klare for trening, må du bestemme hvilken algoritme du skal bruke til oppgaven.
Nå som dataene dine er rene og klare for trening, må du bestemme hvilket algoritme du vil bruke.
Scikit-learn grupperer klassifisering under Supervised Learning, og i den kategorien finner du mange måter å klassifisere på. [Utvalget](https://scikit-learn.org/stable/supervised_learning.html) kan virke overveldende ved første øyekast. Følgende metoder inkluderer klassifiseringsteknikker:
Scikit-learn grupperer klassifisering under Overvåket Læring, og i den kategorien finner du mange måter å klassifisere på. [Variasjonen](https://scikit-learn.org/stable/supervised_learning.html) kan virke overveldende ved første øyekast. Følgende metoder inkluderer alle klassifiseringsteknikker:
- Lineære modeller
- Support Vector Machines
- Støttevektormaskiner
- Stokastisk gradientnedstigning
- Nærmeste naboer
- Gaussiske prosesser
- Beslutningstrær
- Ensemble-metoder (voting Classifier)
- Multiklasse- og multioutput-algoritmer (multiklasse- og multilabel-klassifisering, multiklasse-multioutput-klassifisering)
- Ensemble-metoder (votering Klassifikator)
- Multiklasse og multioutput-algoritmer (multiklasse og multilabel klassifisering, multiklasse-multioutput klassifisering)
> Du kan også bruke [nevrale nettverk til å klassifisere data](https://scikit-learn.org/stable/modules/neural_networks_supervised.html#classification), men det er utenfor omfanget av denne leksjonen.
> Du kan også bruke [nevrale nettverk for å klassifisere data](https://scikit-learn.org/stable/modules/neural_networks_supervised.html#classification), men det er utenfor omfanget av denne leksjonen.
### Hvilken klassifiseringsmetode skal du velge?
### Hvilken klassifikator skal du velge?
Så, hvilken klassifiseringsmetode bør du velge? Ofte kan det være nyttig å teste flere metoder og se etter gode resultater. Scikit-learn tilbyr en [side-ved-side-sammenligning](https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html) på et opprettet datasett, som sammenligner KNeighbors, SVC på to måter, GaussianProcessClassifier, DecisionTreeClassifier, RandomForestClassifier, MLPClassifier, AdaBoostClassifier, GaussianNB og QuadraticDiscriminationAnalysis, og viser resultatene visuelt:
Så, hvilken klassifikator bør du velge? Ofte er det en god metode å prøve flere for å finne et godt resultat. Scikit-learn tilbyr en [side-ved-side sammenligning](https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html) på et opprettet datasett, som sammenligner KNeighbors, SVC på to måter, GaussianProcessClassifier, DecisionTreeClassifier, RandomForestClassifier, MLPClassifier, AdaBoostClassifier, GaussianNB og QuadraticDiscrinationAnalysis, og viser resultatene visualisert:
> Diagrammer generert fra Scikit-learns dokumentasjon
> Plottene er generert i Scikit-learns dokumentasjon
> AutoML løser dette problemet elegant ved å kjøre disse sammenligningene i skyen, slik at du kan velge den beste algoritmen for dataene dine. Prøv det [her](https://docs.microsoft.com/learn/modules/automate-model-selection-with-azure-automl/?WT.mc_id=academic-77952-leestott)
> AutoML løser dette problemet elegant ved å kjøre disse sammenligningene i skyen, slik at du kan velge den beste algoritmen for dine data. Prøv det [her](https://docs.microsoft.com/learn/modules/automate-model-selection-with-azure-automl/?WT.mc_id=academic-77952-leestott)
### En bedre tilnærming
En bedre tilnærming enn å gjette vilkårlig er å følge ideene i dette nedlastbare [ML Cheat Sheet](https://docs.microsoft.com/azure/machine-learning/algorithm-cheat-sheet?WT.mc_id=academic-77952-leestott). Her oppdager vi at vi har noen valg for vårt multiklasse-problem:
En bedre måte enn å gjette vilt på, er å følge ideene i dette nedlastbare [ML jukseark](https://docs.microsoft.com/azure/machine-learning/algorithm-cheat-sheet?WT.mc_id=academic-77952-leestott). Her oppdager vi at for vårt multiklasseproblem, har vi noen valg:
> En del av Microsofts Algorithm Cheat Sheet, som beskriver alternativer for multiklasse-klassifisering
> En seksjon fra Microsofts Algorithm Cheat Sheet, som detaljerer alternativer for multiklasseklassifisering
✅ Last ned denne jukselappen, skriv den ut, og heng den på veggen!
✅ Last ned dette juksearket, skriv det ut og heng det opp på veggen din!
### Resonnement
La oss se om vi kan resonnere oss frem til ulike tilnærminger gitt de begrensningene vi har:
La oss se om vi kan resonnere oss gjennom forskjellige tilnærminger gitt de begrensningene vi har:
- **Nevrale nettverk er for tunge**. Gitt vårt rene, men minimale datasett, og det faktum at vi kjører trening lokalt via notebooks, er nevrale nettverk for tunge for denne oppgaven.
- **Ingen to-klasse klassifiserer**. Vi bruker ikke en to-klasse klassifiserer, så det utelukker one-vs-all.
- **Nevrale nettverk er for tunge**. Gitt vårt rene, men minimale datasett, og at vi kjører treningen lokalt via notebooks, er nevrale nettverk for tunge for denne oppgaven.
- **Ingen to-klasses klassifikator**. Vi bruker ikke en to-klassers klassifikator, så det utelukker one-vs-all.
- **Beslutningstre eller logistisk regresjon kan fungere**. Et beslutningstre kan fungere, eller logistisk regresjon for multiklasse-data.
- **Multiklasse Boosted Decision Trees løser et annet problem**. Multiklasse Boosted Decision Trees er mest egnet for ikke-parametriske oppgaver, f.eks. oppgaver designet for å bygge rangeringer, så det er ikke nyttig for oss.
- **Multiklasse Boosted Decision Trees løser et annet problem**. Multiklasse boosted beslutningstre er mest egnet for ikke-parametriske oppgaver, f.eks. oppgaver designet for å bygge rangeringer, så det er ikke nyttig for oss.
### Bruke Scikit-learn
### Bruke Scikit-learn
Vi skal bruke Scikit-learn til å analysere dataene våre. Det finnes imidlertid mange måter å bruke logistisk regresjon i Scikit-learn. Ta en titt på [parametrene du kan sende](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
Vi skal bruke Scikit-learn for å analysere dataene våre. Det finnes imidlertid mange måter å bruke logistisk regresjon i Scikit-learn. Ta en titt på [parametrene som kan settes](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
I hovedsak er det to viktige parametere - `multi_class` og `solver` - som vi må spesifisere når vi ber Scikit-learn om å utføre en logistisk regresjon. `multi_class`-verdien gir en viss oppførsel. Verdien av solver angir hvilken algoritme som skal brukes. Ikke alle solvers kan kombineres med alle `multi_class`-verdier.
I hovedsak er det to viktige parametere - `multi_class` og `solver` - som vi må spesifisere når vi spør Scikit-learn om å utføre logistisk regresjon. `multi_class`-verdien bestemmer en spesiell oppførsel. Verdien for solver er hvilken algoritme som skal brukes. Ikke alle solvere kan kombineres med alle `multi_class`-verdier.
Ifølge dokumentasjonen, i multiklasse-tilfellet, treningsalgoritmen:
Ifølge dokumentasjonen, i multiklasse-tilfelle, bruker treningsalgoritmen:
- **Bruker one-vs-rest (OvR)-skjemaet**, hvis `multi_class`-alternativet er satt til `ovr`
- **Bruker kryssentropitap**, hvis `multi_class`-alternativet er satt til `multinomial`. (For øyeblikket støttes `multinomial`-alternativet kun av solverne ‘lbfgs’, ‘sag’, ‘saga’ og ‘newton-cg’.)
- **En en-mot-de-andre (OvR) ordning**, hvis `multi_class`-alternativet settes til `ovr`
- **Krysstaps-tapet (cross-entropy loss)**, hvis `multi_class`-alternativet settes til `multinomial`. (Foreløpig støttes `multinomial`-alternativet kun av ‘lbfgs’, ‘sag’, ‘saga’ og ‘newton-cg’ solverne.)"
> 🎓 'Skjemaet' her kan enten være 'ovr' (one-vs-rest) eller 'multinomial'. Siden logistisk regresjon egentlig er designet for å støtte binær klassifisering, lar disse skjemaene den håndtere multiklasse-klassifiseringsoppgaver bedre. [kilde](https://machinelearningmastery.com/one-vs-rest-and-one-vs-one-for-multi-class-classification/)
> 🎓 'Ordningen' her kan enten være 'ovr' (one-vs-rest) eller 'multinomial'. Fordi logistisk regresjon egentlig er designet for binærklassifisering, tillater disse ordningene den å håndtere multiklasseklassifikasjonsoppgaver bedre. [kilde](https://machinelearningmastery.com/one-vs-rest-and-one-vs-one-for-multi-class-classification/)
> 🎓 'Solver' er definert som "algoritmen som skal brukes i optimaliseringsproblemet". [kilde](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
> 🎓 'Solveren' defineres som "algoritmen som skal brukes i optimaliseringsproblemet". [kilde](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
Scikit-learn tilbyr denne tabellen for å forklare hvordan solvers håndterer ulike utfordringer presentert av forskjellige typer datastrukturer:
Scikit-learn tilbyr denne tabellen for å forklare hvordan solvere håndterer ulike utfordringer som forskjellige typer datastrukturer presenterer:
Siden du bruker multiklasse-tilfellet, må du velge hvilket _skjema_ du skal bruke og hvilken _solver_ du skal sette. Bruk LogisticRegression med en multiklasse-innstilling og **liblinear** solver for å trene.
Siden du bruker multiklasse-tilfelle, må du velge hvilket _oppsett_ som skal brukes og hvilken _solver_ som skal settes. Bruk LogisticRegression med en multiklasse-innstilling og **liblinear** solver til trening.
1. Opprett en logistisk regresjon med multi_class satt til `ovr` og solver satt til `liblinear`:
1. Opprett en logistisk regresjon med multi_class satt til `ovr` og solveren satt til `liblinear`:
```python
lr = LogisticRegression(multi_class='ovr',solver='liblinear')
@ -163,18 +163,20 @@ Siden du bruker multiklasse-tilfellet, må du velge hvilket _skjema_ du skal bru
print ("Accuracy is {}".format(accuracy))
```
✅ Prøv en annen solver som `lbfgs`, som ofte er satt som standard
> Merk, bruk Pandas [`ravel`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.ravel.html)-funksjonen for å flate ut dataene dine når det er nødvendig.
Nøyaktigheten er god på over **80%**!
✅ Prøv en annen solver som `lbfgs`, som ofte settes som standard
1. Du kan se denne modellen i aksjon ved å teste én rad med data (#50):
> Merk, bruk Pandas [`ravel`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.ravel.html) funksjon for å flate ut dataene dine når det trengs.
Nøyaktigheten er god, over **80%**!
1. Du kan se denne modellen i aksjon ved å teste en rad med data (#50):
I denne leksjonen brukte du de rensede dataene dine til å bygge en maskinlæringsmodell som kan forutsi en nasjonal matrett basert på en rekke ingredienser. Ta deg tid til å lese gjennom de mange alternativene Scikit-learn tilbyr for å klassifisere data. Gå dypere inn i konseptet 'solver' for å forstå hva som skjer i bakgrunnen.
I denne leksjonen brukte du dine rensede data for å bygge en maskinlæringsmodell som kan forutsi en nasjonal matrett basert på en rekke ingredienser. Ta deg tid til å lese gjennom de mange alternativene Scikit-learn tilbyr for å klassifisere data. Grav dypere inn i konseptet 'solver' for å forstå hva som skjer bak kulissene.
## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
## Gjennomgang & Selvstudium
## Gjennomgang og Selvstudium
Grav litt dypere i matematikken bak logistisk regresjon i [denne leksjonen](https://people.eecs.berkeley.edu/~russell/classes/cs194/f11/lectures/CS194%20Fall%202011%20Lecture%2006.pdf)
## Oppgave
Grav litt mer i matematikken bak logistisk regresjon i [denne leksjonen](https://people.eecs.berkeley.edu/~russell/classes/cs194/f11/lectures/CS194%20Fall%202011%20Lecture%2006.pdf)
## Oppgave
[Studer solverne](assignment.md)
[Studer løserne](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.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Ansvarsfraskrivelse**:
Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på dets 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 feilaktige tolkninger som oppstår ved bruk av denne oversettelsen.
Vi har en Discord-lær med AI-serie pågående, lær mer og bli med oss på [Learn with AI Series](https://aka.ms/learnwithai/discord) fra 18. - 30. september 2025. Du vil få tips og triks for å bruke GitHub Copilot for Data Science.
Vi har en pågående Discord-serie om å lære med AI, lær mer og bli med oss på [Learn with AI Series](https://aka.ms/learnwithai/discord) fra 18. til 30. september 2025. Du vil få tips og triks om bruk av GitHub Copilot for Data Science.
# Maskinlæring for nybegynnere - En læreplan
> 🌍 Reis rundt i verden mens vi utforsker Maskinlæring gjennom verdens kulturer 🌍
> 🌍 Reis rundt i verden mens vi utforsker maskinlæring gjennom verdens kulturer 🌍
Cloud Advocates hos Microsoft er glade for å tilby en 12-ukers, 26-leksjons læreplan som handler om **Maskinlæring**. I denne læreplanen vil du lære det som noen ganger kalles **klassisk maskinlæring**, med hovedvekt på Scikit-learn som et bibliotek og unngår dyp læring, som dekkes i vår [AI for Beginners-læreplan](https://aka.ms/ai4beginners). Kombiner disse leksjonene med vår ['Data Science for Beginners'-læreplan](https://aka.ms/ds4beginners), også!
Cloud Advocates hos Microsoft er glade for å kunne tilby en 12-ukers læreplan med 26 leksjoner som handler om **maskinlæring**. I denne læreplanen vil du lære om det som noen ganger kalles **klassisk maskinlæring**, med hovedvekt på Scikit-learn som bibliotek og uten bruk av dyp læring, som dekkes i vår [AI for Beginners' læreplan](https://aka.ms/ai4beginners). Kombiner gjerne disse leksjonene med vår ['Data Science for Beginners'læreplan](https://aka.ms/ds4beginners)!
Reis med oss rundt i verden mens vi bruker disse klassiske teknikkene på data fra mange verdensdeler. 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 metode for at nye ferdigheter skal 'feste seg'.
Reis med oss rundt i verden mens vi anvender disse klassiske teknikkene på data fra mange deler 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 undervisningsmetode lar deg lære mens du bygger, en dokumentert metode for at nye ferdigheter skal "feste seg".
**✍️ Hjertelig 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
**🙏 Spesiell takk 🙏 til våre Microsoft Student Ambassador-forfattere, anmeldere og innholdsbidragsytere**, særlig 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!**
**🤩 Ekstra takk til Microsoft Student Ambassadors Eric Wanjau, Jasleen Sondhi, og Vidushi Gupta for våre R-leksjoner!**
# Komme i gang
Følg disse trinnene:
1. **Gaffel depotet**: Klikk på "Fork" knappen øverst til høyre på denne siden.
> [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)
> 🔧 **Trenger du hjelp?** Sjekk vår [Veiledning for feilsøking](TROUBLESHOOTING.md) for løsninger på vanlige problemer med installasjon, oppsett og kjøring av leksjoner.
> 🔧 **Trenger du hjelp?** Se vår [Feilsøkingsguide](TROUBLESHOOTING.md) for løsninger på vanlige problemer med installasjon, oppsett og kjøring av leksjoner.
**[Studenter](https://aka.ms/student-page)**, for å bruke denne læreplanen, lag en gaffel av hele repositoriet til din egen GitHub-konto og fullfør øvelsene alene eller i gruppe:
**[Studenter](https://aka.ms/student-page)**, for å bruke denne læreplanen, fork hele repoet til din egen GitHub-konto og fullfør øvelsene på egen hånd eller i gruppe:
- Start med en quiz før forelesningen.
- Les forelesningen og fullfør aktivitetene, stopp opp og reflekter ved hver kunnskapskontroll.
- Prøv å lage prosjektene ved å forstå leksjonene fremfor å bare kjøre løsningskoden; denne koden er imidlertid tilgjengelig i `/solution`-mappene i hver prosjektorienterte leksjon.
- Ta quizen etter forelesningen.
- Prøv å lage prosjektene ved å forstå leksjonene heller enn å bare kjøre løsningskoden; koden er likevel tilgjengelig i `/solution`-mappene i hver prosjektorienterte leksjon.
- Ta quiz etter forelesningen.
- Fullfør utfordringen.
- Fullfør oppgaven.
- Etter å ha fullført en leksjonsgruppe, besøk [Diskusjonstavlen](https://github.com/microsoft/ML-For-Beginners/discussions) og "lær høyt" ved å fylle ut den passende PAT-rubrikken. En 'PAT' er et fremdriftsvurderingsverktøy som er et vurderingsskjema du fyller ut for å fremme læringen din. Du kan også reagere på andres PAT-er slik at vi kan lære sammen.
- 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 relevant PAT-rubric. En 'PAT' er et vurderingsverktøy som du fyller ut for å fremme læringen din. Du kan også reagere på andres PAT-er så 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æringsløpene.
> 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æringsveiene.
**Lærere**, vi har [inkludert noen forslag](for-teachers.md) om hvordan man bruker denne læreplanen.
**Lærere**, vi har [inkludert noen forslag](for-teachers.md) om hvordan denne læreplanen kan brukes.
---
## Videogjennomganger
## Video-gjennomganger
Noen av leksjonene er tilgjengelige som korte videoer. Du kan finne alle disse integrert i leksjonene, eller på [ML for Beginners playlisten på Microsoft Developer YouTube-kanal](https://aka.ms/ml-beginners-videos) ved å klikke på bildet nedenfor.
Noen av leksjonene er tilgjengelige som korte videoer. Du finner alle disse integrert 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)
@ -107,68 +107,68 @@ Noen av leksjonene er tilgjengelige som korte videoer. Du kan finne alle disse i
## Pedagogikk
Vi har valgt to pedagogiske prinsipper under byggingen av denne læreplanen: å sikre at det er praktisk **prosjektbasert** og at det inneholder **hyppige quizer**. I tillegg har denne læreplanen et felles **tema** for å gi den sammenheng.
Vi har valgt to pedagogiske prinsipper under utformingen av denne læreplanen: å sikre at den er praktisk **prosjektbasert** og at den inkluderer **hyppige quizer**. I tillegg har denne læreplanen et felles **tema** som gir sammenheng.
Ved å sikre at innholdet samsvarer med prosjekter, blir prosessen mer engasjerende for studentene og forståelsen av konsepter 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. Denne læreplanen er designet for å være fleksibel og morsom og kan gjennomføres i sin helhet eller delvis. Prosjektene starter smått og blir gradvis mer komplekse mot slutten av den 12-ukers syklusen. Denne læreplanen inkluderer også et etterord om reelle anvendelser av ML, som kan brukes som ekstra poeng eller som grunnlag for diskusjon.
Ved å sikre at innholdet samsvarer med prosjekter, gjøres læringsprosessen mer engasjerende for studentene og forståelsen av konsepter vil øke. I tillegg setter en quiz med lav innsats før en klasse studentens fokus på å lære et tema, mens en annen quiz etter klassen sikrer ytterligere forståelse. Denne læreplanen er designet for å være fleksibel og morsom og kan tas i sin helhet eller delvis. Prosjektene starter smått og blir gradvis mer komplekse gjennom den 12-ukers syklusen. Denne læreplanen inkluderer også et etterord om virkelige anvendelser av ML, som kan brukes som ekstra kreditt eller som grunnlag for diskusjon.
> Finn våre [Regler for oppførsel](CODE_OF_CONDUCT.md), [Bidragsretningslinjer](CONTRIBUTING.md), [Oversettelser](..), og [Feilsøking](TROUBLESHOOTING.md). Vi ønsker din konstruktive tilbakemelding velkommen!
> Finn våre [Regler for oppførsel](CODE_OF_CONDUCT.md), [Bidrag](CONTRIBUTING.md), [Oversettelser](..) og [Feilsøking](TROUBLESHOOTING.md)-retningslinjer. Vi tar imot konstruktive tilbakemeldinger!
## Hver leksjon inkluderer
- valgfri sketchnote
- valgfri supplementvideo
- videogjennomgang (kun noen leksjoner)
- [quiz før forelesning](https://ff-quizzes.netlify.app/en/ml/)
- valgfri skisse
- valgfri supplerende video
- video-gjennomgang (kun enkelte leksjoner)
- [quiz før forelesningen](https://ff-quizzes.netlify.app/en/ml/)
- skriftlig leksjon
- for prosjektbaserte leksjoner, trinnvise guider for hvordan bygge prosjektet
- kunnskapskontroller
- en utfordring
- tilleggslitteratur
- supplerende lesning
- oppgave
- [quiz etter forelesning](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 `kodebiter` (av R eller andre språk) og en `YAML-header` (som styrer hvordan utdata som PDF skal formateres) i et `Markdown-dokument`. Som sådan fungerer det som en eksemplarisk forfatterramme for datavitenskap siden det lar deg kombinere koden din, dens utdata, og tankene dine ved å tillate deg å skrive dem ned i Markdown. Dessuten kan R Markdown-dokumenter gjengis til utdataformater som PDF, HTML eller Word.
> **En merknad om quizzer**: Alle quizzer er samlet i [Quiz App-mappen](../../quiz-app), for totalt 52 quizzer med tre spørsmål hver. De er lenket inn i leksjonene, men quiz-appen kan kjøres lokalt; følg instruksjonen i `quiz-app`-mappen for lokal hosting eller distribuering til Azure.
| 01 | Introduksjon til maskinlæring | [Introduksjon](1-Introduction/README.md) | Lær grunnleggende konsepter bak maskinlæring | [Leksjon](1-Introduction/1-intro-to-ML/README.md) | Muhammad |
| 02 | Maskinlæringens historie | [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 viktige filosofiske spørsmål rundt rettferdighet som studenter bør vurdere når de bygger og bruker ML-modeller? | [Leksjon](1-Introduction/3-fairness/README.md) | Tomomi |
| 04 | Teknikkene 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 | [Python](2-Regression/1-Tools/README.md) • [R](../../2-Regression/1-Tools/solution/R/lesson_1.html) | Jen • Eric Wanjau |
| 06 | Nordamerikanske gresskarlyspriser 🎃 | [Regresjon](2-Regression/README.md) | Visualiser og rengjør data i forberedelse til ML | [Python](2-Regression/2-Data/README.md) • [R](../../2-Regression/2-Data/solution/R/lesson_2.html) | Jen • Eric Wanjau |
| 07 | Nordamerikanske gresskarlyspriser 🎃 | [Regresjon](2-Regression/README.md) | Bygg lineære og polynomielle regresjonsmodeller | [Python](2-Regression/3-Linear/README.md) • [R](../../2-Regression/3-Linear/solution/R/lesson_3.html) | Jen og Dmitry • Eric Wanjau |
| 08 | Nordamerikanske gresskarlyspriser 🎃 | [Regresjon](2-Regression/README.md) | Bygg en logistisk regresjonsmodell | [Python](2-Regression/4-Logistic/README.md) • [R](../../2-Regression/4-Logistic/solution/R/lesson_4.html) | Jen • Eric Wanjau |
| 09 | En Web-App 🔌 | [Web App](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 dine data; introduksjon til klassifisering | [Python](4-Classification/1-Introduction/README.md) • [R](../../4-Classification/1-Introduction/solution/R/lesson_10.html) | Jen og Cassie • Eric Wanjau |
| 11 | Deilige asiatiske og indiske kjøkken 🍜 | [Klassifisering](4-Classification/README.md) | Introduksjon til klassifisører | [Python](4-Classification/2-Classifiers-1/README.md) • [R](../../4-Classification/2-Classifiers-1/solution/R/lesson_11.html) | Jen og Cassie • Eric Wanjau |
| 12 | Deilige asiatiske og indiske kjøkken 🍜 | [Klassifisering](4-Classification/README.md) | Flere klassifisører | [Python](4-Classification/3-Classifiers-2/README.md) • [R](../../4-Classification/3-Classifiers-2/solution/R/lesson_12.html) | Jen og Cassie • Eric Wanjau |
| 13 | Deilige asiatiske og indiske kjøkken 🍜 | [Klassifisering](4-Classification/README.md) | Bygg en anbefalingswebapp ved bruk av din modell | [Python](4-Classification/4-Applied/README.md) | Jen |
| 14 | Introduksjon til klyngedannelse | [Klyngedannelse](5-Clustering/README.md) | Rengjør, forbered og visualiser dine data; Introduksjon til klyngedannelse | [Python](5-Clustering/1-Visualize/README.md) • [R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | Jen • Eric Wanjau |
| 15 | Utforsking av nigerianske musikksmaker 🎧 | [Klyngedannelse](5-Clustering/README.md) | Utforsk K-Means klyngemetode | [Python](5-Clustering/2-K-Means/README.md) • [R](../../5-Clustering/2-K-Means/solution/R/lesson_15.html) | Jen • Eric Wanjau |
| 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 dine NLP-kunnskaper ved å forstå vanlige oppgaver som kreves når du arbeider med 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 tidsseriefremskriving | [Tidsserie](7-TimeSeries/README.md) | Introduksjon til tidsseriefremskriving | [Python](7-TimeSeries/1-Introduction/README.md) | Francesca |
| 22 | ⚡️ Verdens strømforbruk ⚡️ - tidsseriefremskriving med ARIMA | [Tidsserie](7-TimeSeries/README.md) | Tidsseriefremskriving med ARIMA | [Python](7-TimeSeries/2-ARIMA/README.md) | Francesca |
| 23 | ⚡️ Verdens strømforbruk ⚡️ - tidsseriefremskriving med SVR | [Tidsserie](7-TimeSeries/README.md) | Tidsseriefremskriving 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-læring | [Python](8-Reinforcement/1-QLearning/README.md) | Dmitry |
| 25 | Hjelp Peter med å unngå ulven! 🐺 | [Forsterkende læring](8-Reinforcement/README.md) | Forsterkende læring Gym | [Python](8-Reinforcement/2-Gym/README.md) | Dmitry |
| Postscript | Virkelige ML-scenarier og anvendelser | [ML i det fri](9-Real-World/README.md) | Interessante og avslørende virkelige anvendelser av klassisk ML | [Leksjon](9-Real-World/1-Applications/README.md) | Team |
| Postscript | Feilsøking av modeller i ML ved bruk av RAI-dashboard | [ML i det fri](9-Real-World/README.md) | Feilsøking av maskinlæringsmodeller ved bruk av Responsible AI-dashbordkomponenter | [Leksjon](9-Real-World/2-Debugging-ML-Models/README.md) | Ruth Yakubu |
> [finn alle ekstra ressurser for dette kurset i vår Microsoft Learn-samling](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
## Frakoblet tilgang
Du kan kjøre denne dokumentasjonen frakoblet 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 til dette repoet, skriv `docsify serve`. Nettstedet vil bli servert på port 3000 på din lokalhost: `localhost:3000`.
## PDF-er
Finn en pdf av læreplanen med lenker [her](https://microsoft.github.io/ML-For-Beginners/pdf/readme.pdf).
- [quiz etter forelesningen](https://ff-quizzes.netlify.app/en/ml/)
> **En merknad om språk**: Disse leksjonene er primært 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, for eksempel PDF) i et `Markdown-dokument`. Som sådan fungerer det som en eksemplarisk forfatterramme for datavitenskap, siden det lar deg kombinere koden din, dens utdata og dine tanker ved å skrive dem ned i Markdown. I tillegg kan R Markdown-dokumenter gjengis til utdataformater som PDF, HTML eller Word.
> **En merknad om quizzer**: Alle quizzer er samlet i [Quiz App-mappen](../../quiz-app), totalt 52 quizzer 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 lokal hosting eller distribusjon til Azure.
| 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 som ligger 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 problemstillingene rundt rettferdighet som studenter bør vurdere når de bygger og anvender ML-modeller? | [Leksjon](1-Introduction/3-fairness/README.md) | Tomomi |
| 04 | Teknikkene 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 | [Python](2-Regression/1-Tools/README.md) • [R](../../2-Regression/1-Tools/solution/R/lesson_1.html) | Jen • Eric Wanjau |
| 06 | Nord-amerikanske gresskarpriser 🎃 | [Regresjon](2-Regression/README.md) | Visualiser og rens data som forberedelse til ML | [Python](2-Regression/2-Data/README.md) • [R](../../2-Regression/2-Data/solution/R/lesson_2.html) | Jen • Eric Wanjau |
| 07 | Nord-amerikanske gresskarpriser 🎃 | [Regresjon](2-Regression/README.md) | Bygg lineære og polynomiale regresjonsmodeller | [Python](2-Regression/3-Linear/README.md) • [R](../../2-Regression/3-Linear/solution/R/lesson_3.html) | Jen og Dmitry • Eric Wanjau |
| 08 | Nord-amerikanske gresskarpriser 🎃 | [Regresjon](2-Regression/README.md) | Bygg en logistisk regresjonsmodell | [Python](2-Regression/4-Logistic/README.md) • [R](../../2-Regression/4-Logistic/solution/R/lesson_4.html) | Jen • Eric Wanjau |
| 09 | En netthandelsapp 🔌 | [Web App](3-Web-App/README.md) | Bygg en nettapp for å bruke den trente modellen din | [Python](3-Web-App/1-Web-App/README.md) | Jen |
| 10 | Introduksjon til klassifisering | [Klassifisering](4-Classification/README.md) | Rens, forbered og visualiser data; introduksjon til klassifisering | [Python](4-Classification/1-Introduction/README.md) • [R](../../4-Classification/1-Introduction/solution/R/lesson_10.html) | Jen og Cassie • Eric Wanjau |
| 11 | Deilige asiatiske og indiske retter 🍜 | [Klassifisering](4-Classification/README.md) | Introduksjon til klassifikatorer | [Python](4-Classification/2-Classifiers-1/README.md) • [R](../../4-Classification/2-Classifiers-1/solution/R/lesson_11.html) | Jen og Cassie • Eric Wanjau |
| 12 | Deilige asiatiske og indiske retter 🍜 | [Klassifisering](4-Classification/README.md) | Flere klassifikatorer | [Python](4-Classification/3-Classifiers-2/README.md) • [R](../../4-Classification/3-Classifiers-2/solution/R/lesson_12.html) | Jen og Cassie • Eric Wanjau |
| 13 | Deilige asiatiske og indiske retter 🍜 | [Klassifisering](4-Classification/README.md) | Bygg en anbefalingsnettapp med modellen din | [Python](4-Classification/4-Applied/README.md) | Jen |
| 14 | Introduksjon til klynging | [Klynging](5-Clustering/README.md) | Rens, forbered og visualiser data; introduksjon til klynging | [Python](5-Clustering/1-Visualize/README.md) • [R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | Jen • Eric Wanjau |
| 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 din NLP-kunnskap ved å forstå vanlige oppgaver som kreves ved håndtering av 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 hotellvurderinger 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 hotellvurderinger 2 | [Python](6-NLP/5-Hotel-Reviews-2/README.md) | Stephen |
| 21 | Introduksjon til tidsserieprognoser | [Tidsserie](7-TimeSeries/README.md) | Introduksjon til tidsserieprognoser | [Python](7-TimeSeries/1-Introduction/README.md) | Francesca |
| 22 | ⚡️ Verdens strømmforbruk ⚡️ - tidsserieprognose med ARIMA | [Tidsserie](7-TimeSeries/README.md) | Tidsserieprognose med ARIMA | [Python](7-TimeSeries/2-ARIMA/README.md) | Francesca |
| 23 | ⚡️ Verdens strømmforbruk ⚡️ - tidsserieprognose med SVR | [Tidsserie](7-TimeSeries/README.md) | Tidsserieprognose med Support Vector Regressor | [Python](7-TimeSeries/3-SVR/README.md) | Anirban |
| 24 | Introduksjon til forsterkningslæring | [Forsterkningslæring](8-Reinforcement/README.md) | Introduksjon til forsterkningslæring med Q-Læring | [Python](8-Reinforcement/1-QLearning/README.md) | Dmitry |
| 25 | Hjelp Peter å unngå ulven! 🐺 | [Forsterkningslæring](8-Reinforcement/README.md) | Forsterkningslæring Gym | [Python](8-Reinforcement/2-Gym/README.md) | Dmitry |
| Postscript | Virkelige ML-scenarier og applikasjoner | [ML i det fri](9-Real-World/README.md) | Interessante og avslørende virkelige anvendelser av klassisk ML | [Leksjon](9-Real-World/1-Applications/README.md) | Team |
| Postscript | Modellfeilsøking i ML med RAI dashboard | [ML i det fri](9-Real-World/README.md) | Modellfeilsøking i maskinlæring med Responsible AI-dashboard-komponenter | [Leksjon](9-Real-World/2-Debugging-ML-Models/README.md) | Ruth Yakubu |
> [finn alle tilleggskilder 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 så i rotmappen av dette repoet, skriv `docsify serve`. Nettstedet vil bli servert på port 3000 på din localhost: `localhost:3000`.
## PDF-filer
Finn en pdf av pensumet med lenker [her](https://microsoft.github.io/ML-For-Beginners/pdf/readme.pdf).
## 🎒 Andre kurs
@ -177,14 +177,14 @@ Vårt team produserer andre kurs! Sjekk ut:
<!-- CO-OP TRANSLATOR OTHER COURSES START -->
### LangChain
[](https://aka.ms/langchain4j-for-beginners)
[](https://aka.ms/langchainjs-for-beginners?WT.mc_id=m365-94501-dwahlin)
[](https://github.com/microsoft/langchain-for-beginners?WT.mc_id=m365-94501-dwahlin)
[](https://aka.ms/langchain4j-for-beginners)
[](https://aka.ms/langchainjs-for-beginners?WT.mc_id=m365-94501-dwahlin)
[](https://github.com/microsoft/langchain-for-beginners?WT.mc_id=m365-94501-dwahlin)
---
### Azure / Edge / MCP / Agenter
[](https://github.com/microsoft/AZD-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/edgeai-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/AZD-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/edgeai-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/mcp-for-beginners?WT.mc_id=academic-105485-koreyst)
[](https://github.com/microsoft/ai-agents-for-beginners?WT.mc_id=academic-105485-koreyst)
@ -198,7 +198,7 @@ Vårt team produserer andre kurs! Sjekk ut:
---
### Grunnleggende læring
### Kjernelæring
[](https://aka.ms/ml-beginners?WT.mc_id=academic-105485-koreyst)
[](https://aka.ms/datascience-beginners?WT.mc_id=academic-105485-koreyst)
[](https://aka.ms/ai-beginners?WT.mc_id=academic-105485-koreyst)
@ -217,22 +217,33 @@ Vårt team produserer andre kurs! Sjekk ut:
## Få hjelp
Hvis du står fast eller har spørsmål om å bygge AI-apper. Bli med andre lærende og erfarne utviklere i diskusjoner om MCP. Det er et støttende fellesskap hvor spørsmål er velkomne og kunnskap deles fritt.
Hvis du står fast eller har spørsmål mens du lærer maskinlæring eller bygger AI-applikasjoner, ikke bekymre deg — hjelp er tilgjengelig.
- Gå gjennom notatbøker etter hver leksjon for bedre forståelse.
- Øv på å implementere algoritmer på egenhånd.
- Øv på å implementere algoritmer på egenhånd.
- Utforsk datasett fra virkeligheten ved å bruke lærte konsepter.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Ansvarsfraskrivelse**:
Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vennligst vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på dets 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.
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, vennligst vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det opprinnelige dokumentet på originalspråket skal betraktes som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.
localizeflow[bot]
2 weeks ago