🌐 Update translations via Co-op Translator

translations/no/1-Introduction/1-intro-to-ML/README.md

@@ -0,0 +1,159 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "69389392fa6346e0dfa30f664b7b6fec",
+  "translation_date": "2025-09-05T21:43:11+00:00",
+  "source_file": "1-Introduction/1-intro-to-ML/README.md",
+  "language_code": "no"
+}
+-->
+# Introduksjon til maskinlæring
+
+## [Quiz før forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+---
+
+[![ML for nybegynnere - Introduksjon til maskinlæring for nybegynnere](https://img.youtube.com/vi/6mSx_KJxcHI/0.jpg)](https://youtu.be/6mSx_KJxcHI "ML for nybegynnere - Introduksjon til maskinlæring for nybegynnere")
+
+> 🎥 Klikk på bildet over for en kort video som går gjennom denne leksjonen.
+
+Velkommen til dette kurset om klassisk maskinlæring for nybegynnere! Enten du er helt ny på dette temaet, eller en erfaren ML-praktiker som ønsker å friske opp kunnskapen, er vi glade for å ha deg med! Vi ønsker å skape et vennlig startpunkt for din ML-studie og vil gjerne evaluere, svare på og inkludere din [tilbakemelding](https://github.com/microsoft/ML-For-Beginners/discussions).
+
+[![Introduksjon til ML](https://img.youtube.com/vi/h0e2HAPTGF4/0.jpg)](https://youtu.be/h0e2HAPTGF4 "Introduksjon til ML")
+
+> 🎥 Klikk på bildet over for en video: MITs John Guttag introduserer maskinlæring
+
+---
+## Komme i gang med maskinlæring
+
+Før du starter med dette pensumet, må du ha datamaskinen din satt opp og klar til å kjøre notatbøker lokalt.
+
+- **Konfigurer maskinen din med disse videoene**. Bruk følgende lenker for å lære [hvordan du installerer Python](https://youtu.be/CXZYvNRIAKM) på systemet ditt og [setter opp en teksteditor](https://youtu.be/EU8eayHWoZg) for utvikling.
+- **Lær Python**. Det anbefales også å ha en grunnleggende forståelse av [Python](https://docs.microsoft.com/learn/paths/python-language/?WT.mc_id=academic-77952-leestott), et programmeringsspråk som er nyttig for dataforskere og som vi bruker i dette kurset.
+- **Lær Node.js og JavaScript**. Vi bruker også JavaScript noen ganger i dette kurset når vi bygger webapplikasjoner, så du må ha [node](https://nodejs.org) og [npm](https://www.npmjs.com/) installert, samt [Visual Studio Code](https://code.visualstudio.com/) tilgjengelig for både Python- og JavaScript-utvikling.
+- **Opprett en GitHub-konto**. Siden du fant oss her på [GitHub](https://github.com), har du kanskje allerede en konto, men hvis ikke, opprett en og deretter fork dette pensumet for å bruke det selv. (Gi oss gjerne en stjerne også 😊)
+- **Utforsk Scikit-learn**. Gjør deg kjent med [Scikit-learn](https://scikit-learn.org/stable/user_guide.html), et sett med ML-biblioteker som vi refererer til i disse leksjonene.
+
+---
+## Hva er maskinlæring?
+
+Begrepet 'maskinlæring' er et av de mest populære og ofte brukte begrepene i dag. Det er en betydelig sannsynlighet for at du har hørt dette begrepet minst én gang hvis du har en viss kjennskap til teknologi, uansett hvilket felt du jobber i. Mekanismene bak maskinlæring er imidlertid en gåte for de fleste. For en nybegynner innen maskinlæring kan emnet noen ganger føles overveldende. Derfor er det viktig å forstå hva maskinlæring faktisk er, og lære om det steg for steg, gjennom praktiske eksempler.
+
+---
+## Hypekurven
+
+![ml hype curve](../../../../1-Introduction/1-intro-to-ML/images/hype.png)
+
+> Google Trends viser den nylige 'hypekurven' for begrepet 'maskinlæring'
+
+---
+## Et mystisk univers
+
+Vi lever i et univers fullt av fascinerende mysterier. Store vitenskapsmenn som Stephen Hawking, Albert Einstein og mange flere har viet sine liv til å søke etter meningsfull informasjon som avdekker mysteriene i verden rundt oss. Dette er den menneskelige tilstanden for læring: et menneskebarn lærer nye ting og avdekker strukturen i sin verden år for år mens de vokser opp.
+
+---
+## Barnets hjerne
+
+Et barns hjerne og sanser oppfatter fakta fra omgivelsene og lærer gradvis de skjulte mønstrene i livet som hjelper barnet med å lage logiske regler for å identifisere lærte mønstre. Læringsprosessen til den menneskelige hjernen gjør mennesker til de mest sofistikerte levende skapningene i denne verden. Å lære kontinuerlig ved å oppdage skjulte mønstre og deretter innovere på disse mønstrene gjør oss i stand til å forbedre oss selv gjennom hele livet. Denne læringsevnen og utviklingskapasiteten er knyttet til et konsept kalt [hjernens plastisitet](https://www.simplypsychology.org/brain-plasticity.html). Overfladisk kan vi trekke noen motiverende likheter mellom læringsprosessen til den menneskelige hjernen og konseptene for maskinlæring.
+
+---
+## Den menneskelige hjernen
+
+Den [menneskelige hjernen](https://www.livescience.com/29365-human-brain.html) oppfatter ting fra den virkelige verden, behandler den oppfattede informasjonen, tar rasjonelle beslutninger og utfører visse handlinger basert på omstendigheter. Dette kaller vi å oppføre seg intelligent. Når vi programmerer en etterligning av den intelligente atferdsprosessen til en maskin, kalles det kunstig intelligens (AI).
+
+---
+## Noen begreper
+
+Selv om begrepene kan forveksles, er maskinlæring (ML) en viktig underkategori av kunstig intelligens. **ML handler om å bruke spesialiserte algoritmer for å avdekke meningsfull informasjon og finne skjulte mønstre fra oppfattet data for å støtte den rasjonelle beslutningsprosessen**.
+
+---
+## AI, ML, Deep Learning
+
+![AI, ML, deep learning, data science](../../../../1-Introduction/1-intro-to-ML/images/ai-ml-ds.png)
+
+> Et diagram som viser forholdet mellom AI, ML, deep learning og data science. Infografikk av [Jen Looper](https://twitter.com/jenlooper) inspirert av [denne grafikken](https://softwareengineering.stackexchange.com/questions/366996/distinction-between-ai-ml-neural-networks-deep-learning-and-data-mining)
+
+---
+## Konsepter vi skal dekke
+
+I dette pensumet skal vi dekke kun kjernebegrepene innen maskinlæring som en nybegynner må kjenne til. Vi dekker det vi kaller 'klassisk maskinlæring' hovedsakelig ved bruk av Scikit-learn, et utmerket bibliotek mange studenter bruker for å lære det grunnleggende. For å forstå bredere konsepter innen kunstig intelligens eller deep learning, er en sterk grunnleggende kunnskap om maskinlæring uunnværlig, og det ønsker vi å tilby her.
+
+---
+## I dette kurset vil du lære:
+
+- kjernebegreper innen maskinlæring
+- historien til ML
+- ML og rettferdighet
+- regresjonsteknikker innen ML
+- klassifiseringsteknikker innen ML
+- klyngingsteknikker innen ML
+- naturlig språkbehandlingsteknikker innen ML
+- tidsserieprognoseteknikker innen ML
+- forsterkende læring
+- virkelige applikasjoner for ML
+
+---
+## Hva vi ikke vil dekke
+
+- deep learning
+- nevrale nettverk
+- AI
+
+For å gi en bedre læringsopplevelse, vil vi unngå kompleksiteten til nevrale nettverk, 'deep learning' - modellbygging med mange lag ved bruk av nevrale nettverk - og AI, som vi vil diskutere i et annet pensum. Vi vil også tilby et kommende pensum om data science for å fokusere på den delen av dette større feltet.
+
+---
+## Hvorfor studere maskinlæring?
+
+Maskinlæring, fra et systemperspektiv, defineres som opprettelsen av automatiserte systemer som kan lære skjulte mønstre fra data for å hjelpe til med å ta intelligente beslutninger.
+
+Denne motivasjonen er løst inspirert av hvordan den menneskelige hjernen lærer visse ting basert på data den oppfatter fra omverdenen.
+
+✅ Tenk et øyeblikk på hvorfor en bedrift ville ønske å bruke maskinlæringsstrategier i stedet for å lage en hardkodet regelbasert motor.
+
+---
+## Applikasjoner av maskinlæring
+
+Applikasjoner av maskinlæring er nå nesten overalt, og er like utbredt som dataene som flyter rundt i våre samfunn, generert av våre smarttelefoner, tilkoblede enheter og andre systemer. Med tanke på det enorme potensialet til moderne maskinlæringsalgoritmer, har forskere utforsket deres evne til å løse multidimensjonale og tverrfaglige virkelige problemer med svært positive resultater.
+
+---
+## Eksempler på anvendt ML
+
+**Du kan bruke maskinlæring på mange måter**:
+
+- For å forutsi sannsynligheten for sykdom basert på en pasients medisinske historie eller rapporter.
+- For å utnytte værdata til å forutsi værhendelser.
+- For å forstå sentimentet i en tekst.
+- For å oppdage falske nyheter for å stoppe spredningen av propaganda.
+
+Finans, økonomi, geovitenskap, romutforskning, biomedisinsk ingeniørkunst, kognitiv vitenskap og til og med humanistiske fag har tilpasset maskinlæring for å løse de krevende, databehandlingsintensive problemene i deres felt.
+
+---
+## Konklusjon
+
+Maskinlæring automatiserer prosessen med mønsteroppdagelse ved å finne meningsfulle innsikter fra virkelige eller genererte data. Det har vist seg å være svært verdifullt i forretnings-, helse- og finansapplikasjoner, blant andre.
+
+I nær fremtid vil det å forstå det grunnleggende om maskinlæring bli et must for folk fra alle felt på grunn av dens utbredte adopsjon.
+
+---
+# 🚀 Utfordring
+
+Skisser, på papir eller ved bruk av en online app som [Excalidraw](https://excalidraw.com/), din forståelse av forskjellene mellom AI, ML, deep learning og data science. Legg til noen ideer om problemer som hver av disse teknikkene er gode til å løse.
+
+# [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+---
+# Gjennomgang & Selvstudie
+
+For å lære mer om hvordan du kan jobbe med ML-algoritmer i skyen, følg denne [Læringsstien](https://docs.microsoft.com/learn/paths/create-no-code-predictive-models-azure-machine-learning/?WT.mc_id=academic-77952-leestott).
+
+Ta en [Læringssti](https://docs.microsoft.com/learn/modules/introduction-to-machine-learning/?WT.mc_id=academic-77952-leestott) om det grunnleggende innen ML.
+
+---
+# Oppgave
+
+[Kom i gang](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/1-Introduction/1-intro-to-ML/assignment.md

@@ -0,0 +1,23 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "4c4698044bb8af52cfb6388a4ee0e53b",
+  "translation_date": "2025-09-05T21:43:45+00:00",
+  "source_file": "1-Introduction/1-intro-to-ML/assignment.md",
+  "language_code": "no"
+}
+-->
+# Kom i gang
+
+## Instruksjoner
+
+I denne oppgaven uten karakter skal du friske opp Python-kunnskapene dine og sette opp miljøet ditt slik at du kan kjøre notebooks.
+
+Ta denne [Python-læringsstien](https://docs.microsoft.com/learn/paths/python-language/?WT.mc_id=academic-77952-leestott), og sett opp systemene dine ved å gå gjennom disse introduksjonsvideoene:
+
+https://www.youtube.com/playlist?list=PLlrxD0HtieHhS8VzuMCfQD4uJ9yne1mE6
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/1-Introduction/2-history-of-ML/README.md

@@ -0,0 +1,164 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "6a05fec147e734c3e6bfa54505648e2b",
+  "translation_date": "2025-09-05T21:45:17+00:00",
+  "source_file": "1-Introduction/2-history-of-ML/README.md",
+  "language_code": "no"
+}
+-->
+# Historien om maskinlæring
+
+![Oppsummering av historien om maskinlæring i en sketchnote](../../../../sketchnotes/ml-history.png)
+> Sketchnote av [Tomomi Imura](https://www.twitter.com/girlie_mac)
+
+## [Quiz før forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+---
+
+[![ML for nybegynnere - Historien om maskinlæring](https://img.youtube.com/vi/N6wxM4wZ7V0/0.jpg)](https://youtu.be/N6wxM4wZ7V0 "ML for nybegynnere - Historien om maskinlæring")
+
+> 🎥 Klikk på bildet over for en kort video som går gjennom denne leksjonen.
+
+I denne leksjonen skal vi gå gjennom de viktigste milepælene i historien om maskinlæring og kunstig intelligens.
+
+Historien om kunstig intelligens (AI) som et fagfelt er nært knyttet til historien om maskinlæring, ettersom algoritmene og de teknologiske fremskrittene som ligger til grunn for ML har bidratt til utviklingen av AI. Det er nyttig å huske at selv om disse feltene som separate forskningsområder begynte å ta form på 1950-tallet, så fantes det viktige [algoritmiske, statistiske, matematiske, teknologiske og tekniske oppdagelser](https://wikipedia.org/wiki/Timeline_of_machine_learning) som både gikk forut for og overlappet denne perioden. Faktisk har mennesker tenkt på disse spørsmålene i [hundrevis av år](https://wikipedia.org/wiki/History_of_artificial_intelligence): denne artikkelen diskuterer de historiske intellektuelle grunnlagene for ideen om en 'tenkende maskin.'
+
+---
+## Viktige oppdagelser
+
+- 1763, 1812 [Bayes' teorem](https://wikipedia.org/wiki/Bayes%27_theorem) og dets forgjengere. Dette teoremet og dets anvendelser ligger til grunn for inferens og beskriver sannsynligheten for at en hendelse inntreffer basert på tidligere kunnskap.
+- 1805 [Minste kvadraters metode](https://wikipedia.org/wiki/Least_squares) av den franske matematikeren Adrien-Marie Legendre. Denne teorien, som du vil lære om i vår enhet om regresjon, hjelper med datafitting.
+- 1913 [Markov-kjeder](https://wikipedia.org/wiki/Markov_chain), oppkalt etter den russiske matematikeren Andrey Markov, brukes til å beskrive en sekvens av mulige hendelser basert på en tidligere tilstand.
+- 1957 [Perceptron](https://wikipedia.org/wiki/Perceptron) er en type lineær klassifikator oppfunnet av den amerikanske psykologen Frank Rosenblatt som ligger til grunn for fremskritt innen dyp læring.
+
+---
+
+- 1967 [Nærmeste nabo](https://wikipedia.org/wiki/Nearest_neighbor) er en algoritme opprinnelig designet for å kartlegge ruter. I en ML-kontekst brukes den til å oppdage mønstre.
+- 1970 [Backpropagation](https://wikipedia.org/wiki/Backpropagation) brukes til å trene [feedforward-nevrale nettverk](https://wikipedia.org/wiki/Feedforward_neural_network).
+- 1982 [Rekurrente nevrale nettverk](https://wikipedia.org/wiki/Recurrent_neural_network) er kunstige nevrale nettverk avledet fra feedforward-nevrale nettverk som skaper temporale grafer.
+
+✅ Gjør litt research. Hvilke andre datoer skiller seg ut som avgjørende i historien om ML og AI?
+
+---
+## 1950: Maskiner som tenker
+
+Alan Turing, en virkelig bemerkelsesverdig person som ble kåret [av publikum i 2019](https://wikipedia.org/wiki/Icons:_The_Greatest_Person_of_the_20th_Century) til den største vitenskapsmannen i det 20. århundre, er kreditert for å ha bidratt til å legge grunnlaget for konseptet om en 'maskin som kan tenke.' Han tok opp kampen med skeptikere og sitt eget behov for empirisk bevis for dette konseptet, blant annet ved å skape [Turing-testen](https://www.bbc.com/news/technology-18475646), som du vil utforske i våre NLP-leksjoner.
+
+---
+## 1956: Dartmouth Summer Research Project
+
+"Dartmouth Summer Research Project on artificial intelligence var en banebrytende begivenhet for kunstig intelligens som et fagfelt," og det var her begrepet 'kunstig intelligens' ble introdusert ([kilde](https://250.dartmouth.edu/highlights/artificial-intelligence-ai-coined-dartmouth)).
+
+> Hvert aspekt av læring eller enhver annen egenskap ved intelligens kan i prinsippet beskrives så presist at en maskin kan lages for å simulere det.
+
+---
+
+Lederforskeren, matematikkprofessor John McCarthy, håpet "å gå videre basert på antagelsen om at hvert aspekt av læring eller enhver annen egenskap ved intelligens kan i prinsippet beskrives så presist at en maskin kan lages for å simulere det." Deltakerne inkluderte en annen pioner innen feltet, Marvin Minsky.
+
+Workshoppen er kreditert for å ha initiert og oppmuntret til flere diskusjoner, inkludert "fremveksten av symbolske metoder, systemer fokusert på begrensede domener (tidlige ekspert-systemer), og deduktive systemer versus induktive systemer." ([kilde](https://wikipedia.org/wiki/Dartmouth_workshop)).
+
+---
+## 1956 - 1974: "De gylne årene"
+
+Fra 1950-tallet til midten av 70-tallet var optimismen høy med håp om at AI kunne løse mange problemer. I 1967 uttalte Marvin Minsky selvsikkert at "Innen en generasjon ... vil problemet med å skape 'kunstig intelligens' i stor grad være løst." (Minsky, Marvin (1967), Computation: Finite and Infinite Machines, Englewood Cliffs, N.J.: Prentice-Hall)
+
+Forskning på naturlig språkprosessering blomstret, søk ble raffinert og gjort mer kraftfullt, og konseptet med 'mikroverdener' ble skapt, hvor enkle oppgaver ble utført ved hjelp av instruksjoner i vanlig språk.
+
+---
+
+Forskning ble godt finansiert av statlige organer, fremskritt ble gjort innen beregning og algoritmer, og prototyper av intelligente maskiner ble bygget. Noen av disse maskinene inkluderer:
+
+* [Shakey-roboten](https://wikipedia.org/wiki/Shakey_the_robot), som kunne manøvrere og bestemme hvordan oppgaver skulle utføres 'intelligent'.
+
+    ![Shakey, en intelligent robot](../../../../1-Introduction/2-history-of-ML/images/shakey.jpg)
+    > Shakey i 1972
+
+---
+
+* Eliza, en tidlig 'chatterbot', kunne samtale med mennesker og fungere som en primitiv 'terapeut'. Du vil lære mer om Eliza i NLP-leksjonene.
+
+    ![Eliza, en bot](../../../../1-Introduction/2-history-of-ML/images/eliza.png)
+    > En versjon av Eliza, en chatbot
+
+---
+
+* "Blocks world" var et eksempel på en mikroverden hvor blokker kunne stables og sorteres, og eksperimenter med å lære maskiner å ta beslutninger kunne testes. Fremskritt bygget med biblioteker som [SHRDLU](https://wikipedia.org/wiki/SHRDLU) hjalp til med å drive språkprosessering fremover.
+
+    [![blocks world med SHRDLU](https://img.youtube.com/vi/QAJz4YKUwqw/0.jpg)](https://www.youtube.com/watch?v=QAJz4YKUwqw "blocks world med SHRDLU")
+
+    > 🎥 Klikk på bildet over for en video: Blocks world med SHRDLU
+
+---
+## 1974 - 1980: "AI-vinter"
+
+På midten av 1970-tallet ble det klart at kompleksiteten ved å lage 'intelligente maskiner' hadde blitt undervurdert og at løftene, gitt den tilgjengelige beregningskraften, hadde blitt overdrevet. Finansiering tørket opp, og tilliten til feltet avtok. Noen problemer som påvirket tilliten inkluderte:
+---
+- **Begrensninger**. Beregningskraften var for begrenset.
+- **Kombinatorisk eksplosjon**. Antallet parametere som måtte trenes vokste eksponentielt etter hvert som mer ble forventet av datamaskiner, uten en parallell utvikling av beregningskraft og kapasitet.
+- **Mangel på data**. Det var mangel på data som hindret prosessen med å teste, utvikle og forbedre algoritmer.
+- **Spør vi de riktige spørsmålene?**. Selve spørsmålene som ble stilt begynte å bli stilt spørsmål ved. Forskere begynte å møte kritikk for sine tilnærminger:
+  - Turing-tester ble utfordret, blant annet gjennom 'kinesisk rom-teorien' som hevdet at "programmering av en digital datamaskin kan få den til å fremstå som om den forstår språk, men kunne ikke produsere ekte forståelse." ([kilde](https://plato.stanford.edu/entries/chinese-room/))
+  - Etikken ved å introdusere kunstige intelligenser som "terapeuten" ELIZA i samfunnet ble utfordret.
+
+---
+
+Samtidig begynte ulike AI-skoler å dannes. En dikotomi ble etablert mellom ["scruffy" vs. "neat AI"](https://wikipedia.org/wiki/Neats_and_scruffies)-praksiser. _Scruffy_-laboratorier justerte programmer i timevis til de oppnådde ønskede resultater. _Neat_-laboratorier "fokuserte på logikk og formell problemløsning". ELIZA og SHRDLU var velkjente _scruffy_-systemer. På 1980-tallet, da etterspørselen etter å gjøre ML-systemer reproduserbare økte, tok _neat_-tilnærmingen gradvis ledelsen ettersom dens resultater er mer forklarbare.
+
+---
+## 1980-tallet: Ekspertsystemer
+
+Etter hvert som feltet vokste, ble dets nytte for næringslivet tydeligere, og på 1980-tallet økte også spredningen av 'ekspertsystemer'. "Ekspertsystemer var blant de første virkelig vellykkede formene for kunstig intelligens (AI)-programvare." ([kilde](https://wikipedia.org/wiki/Expert_system)).
+
+Denne typen system er faktisk _hybrid_, bestående delvis av en regelmotor som definerer forretningskrav, og en inferensmotor som utnyttet reglesystemet for å utlede nye fakta.
+
+Denne perioden så også økende oppmerksomhet rettet mot nevrale nettverk.
+
+---
+## 1987 - 1993: AI 'Chill'
+
+Spredningen av spesialisert maskinvare for ekspertsystemer hadde den uheldige effekten av å bli for spesialisert. Fremveksten av personlige datamaskiner konkurrerte også med disse store, spesialiserte, sentraliserte systemene. Demokratifiseringen av databehandling hadde begynt, og den banet til slutt vei for den moderne eksplosjonen av big data.
+
+---
+## 1993 - 2011
+
+Denne epoken markerte en ny æra for ML og AI, hvor noen av problemene som tidligere hadde vært forårsaket av mangel på data og beregningskraft kunne løses. Mengden data begynte å øke raskt og bli mer tilgjengelig, på godt og vondt, spesielt med introduksjonen av smarttelefonen rundt 2007. Beregningskraften utvidet seg eksponentielt, og algoritmer utviklet seg parallelt. Feltet begynte å modnes etter hvert som de frie og eksperimentelle dagene fra fortiden begynte å krystallisere seg til en ekte disiplin.
+
+---
+## Nå
+
+I dag berører maskinlæring og AI nesten alle deler av livene våre. Denne perioden krever nøye forståelse av risikoene og de potensielle effektene av disse algoritmene på menneskeliv. Som Microsofts Brad Smith har uttalt: "Informasjonsteknologi reiser spørsmål som går til kjernen av grunnleggende menneskerettighetsbeskyttelser som personvern og ytringsfrihet. Disse spørsmålene øker ansvaret for teknologiselskaper som skaper disse produktene. Etter vår mening krever de også gjennomtenkt statlig regulering og utvikling av normer rundt akseptabel bruk" ([kilde](https://www.technologyreview.com/2019/12/18/102365/the-future-of-ais-impact-on-society/)).
+
+---
+
+Det gjenstår å se hva fremtiden bringer, men det er viktig å forstå disse datasystemene og programvaren og algoritmene de kjører. Vi håper at dette pensumet vil hjelpe deg med å få en bedre forståelse slik at du kan ta dine egne beslutninger.
+
+[![Historien om dyp læring](https://img.youtube.com/vi/mTtDfKgLm54/0.jpg)](https://www.youtube.com/watch?v=mTtDfKgLm54 "Historien om dyp læring")
+> 🎥 Klikk på bildet over for en video: Yann LeCun diskuterer historien om dyp læring i denne forelesningen
+
+---
+## 🚀Utfordring
+
+Fordyp deg i et av disse historiske øyeblikkene og lær mer om menneskene bak dem. Det finnes fascinerende karakterer, og ingen vitenskapelig oppdagelse ble noen gang skapt i et kulturelt vakuum. Hva oppdager du?
+
+## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+---
+## Gjennomgang og selvstudium
+
+Her er ting du kan se og lytte til:
+
+[Denne podcasten hvor Amy Boyd diskuterer utviklingen av AI](http://runasradio.com/Shows/Show/739)
+
+[![Historien om AI av Amy Boyd](https://img.youtube.com/vi/EJt3_bFYKss/0.jpg)](https://www.youtube.com/watch?v=EJt3_bFYKss "Historien om AI av Amy Boyd")
+
+---
+
+## Oppgave
+
+[Lag en tidslinje](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/1-Introduction/2-history-of-ML/assignment.md

@@ -0,0 +1,25 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "eb6e4d5afd1b21a57d2b9e6d0aac3969",
+  "translation_date": "2025-09-05T21:46:00+00:00",
+  "source_file": "1-Introduction/2-history-of-ML/assignment.md",
+  "language_code": "no"
+}
+-->
+# Lag en tidslinje
+
+## Instruksjoner
+
+Ved å bruke [dette repoet](https://github.com/Digital-Humanities-Toolkit/timeline-builder), lag en tidslinje over et aspekt av historien til algoritmer, matematikk, statistikk, AI eller ML, eller en kombinasjon av disse. Du kan fokusere på én person, én idé, eller en lang tidsperiode med tanker. Sørg for å legge til multimedieelementer.
+
+## Vurderingskriterier
+
+| Kriterier | Eksemplarisk                                      | Tilfredsstillende                      | Trenger forbedring                                              |
+| --------- | ------------------------------------------------- | -------------------------------------- | --------------------------------------------------------------- |
+|           | En publisert tidslinje presenteres som en GitHub-side | Koden er ufullstendig og ikke publisert | Tidslinjen er ufullstendig, dårlig undersøkt og ikke publisert |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/1-Introduction/3-fairness/README.md

@@ -0,0 +1,171 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "9a6b702d1437c0467e3c5c28d763dac2",
+  "translation_date": "2025-09-05T21:39:15+00:00",
+  "source_file": "1-Introduction/3-fairness/README.md",
+  "language_code": "no"
+}
+-->
+# Bygge maskinlæringsløsninger med ansvarlig AI
+
+![Oppsummering av ansvarlig AI i maskinlæring i en sketchnote](../../../../sketchnotes/ml-fairness.png)
+> Sketchnote av [Tomomi Imura](https://www.twitter.com/girlie_mac)
+
+## [Quiz før forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+## Introduksjon
+
+I dette kurset vil du begynne å utforske hvordan maskinlæring påvirker våre daglige liv. Allerede nå er systemer og modeller involvert i beslutningsprosesser som helsevesendiagnoser, lånesøknader eller oppdagelse av svindel. Derfor er det viktig at disse modellene fungerer godt og gir pålitelige resultater. Akkurat som med andre programvareapplikasjoner, kan AI-systemer feile eller gi uønskede utfall. Derfor er det avgjørende å kunne forstå og forklare oppførselen til en AI-modell.
+
+Tenk på hva som kan skje hvis dataene du bruker til å bygge disse modellene mangler visse demografiske grupper, som rase, kjønn, politisk syn eller religion, eller hvis de overrepresenterer visse grupper. Hva skjer hvis modellens resultater tolkes til å favorisere en bestemt gruppe? Hva er konsekvensene for applikasjonen? Og hva skjer hvis modellen gir et skadelig utfall? Hvem er ansvarlig for oppførselen til AI-systemet? Dette er noen av spørsmålene vi vil utforske i dette kurset.
+
+I denne leksjonen vil du:
+
+- Øke bevisstheten om viktigheten av rettferdighet i maskinlæring og skader relatert til urettferdighet.
+- Bli kjent med praksisen med å utforske avvik og uvanlige scenarier for å sikre pålitelighet og sikkerhet.
+- Forstå behovet for å styrke alle ved å designe inkluderende systemer.
+- Utforske hvor viktig det er å beskytte personvern og sikkerhet for data og mennesker.
+- Se viktigheten av en "glassboks"-tilnærming for å forklare oppførselen til AI-modeller.
+- Være oppmerksom på hvordan ansvarlighet er essensielt for å bygge tillit til AI-systemer.
+
+## Forutsetninger
+
+Som en forutsetning, vennligst ta "Ansvarlige AI-prinsipper" læringsstien og se videoen nedenfor om emnet:
+
+Lær mer om ansvarlig AI ved å følge denne [læringsstien](https://docs.microsoft.com/learn/modules/responsible-ai-principles/?WT.mc_id=academic-77952-leestott)
+
+[![Microsofts tilnærming til ansvarlig AI](https://img.youtube.com/vi/dnC8-uUZXSc/0.jpg)](https://youtu.be/dnC8-uUZXSc "Microsofts tilnærming til ansvarlig AI")
+
+> 🎥 Klikk på bildet over for en video: Microsofts tilnærming til ansvarlig AI
+
+## Rettferdighet
+
+AI-systemer bør behandle alle rettferdig og unngå å påvirke lignende grupper på ulike måter. For eksempel, når AI-systemer gir veiledning om medisinsk behandling, lånesøknader eller ansettelser, bør de gi samme anbefalinger til alle med lignende symptomer, økonomiske forhold eller kvalifikasjoner. Vi mennesker bærer med oss arvede skjevheter som påvirker våre beslutninger og handlinger. Disse skjevhetene kan også være til stede i dataene vi bruker til å trene AI-systemer. Slike skjevheter kan noen ganger oppstå utilsiktet. Det er ofte vanskelig å være bevisst på når man introduserer skjevheter i data.
+
+**"Urettferdighet"** omfatter negative konsekvenser, eller "skader", for en gruppe mennesker, som definert av rase, kjønn, alder eller funksjonshemming. De viktigste skadene relatert til rettferdighet kan klassifiseres som:
+
+- **Allokering**, hvis for eksempel et kjønn eller en etnisitet favoriseres over en annen.
+- **Kvalitet på tjenesten**. Hvis du trener data for ett spesifikt scenario, men virkeligheten er mye mer kompleks, kan det føre til dårlig ytelse. For eksempel en såpedispenser som ikke klarte å registrere personer med mørk hud. [Referanse](https://gizmodo.com/why-cant-this-soap-dispenser-identify-dark-skin-1797931773)
+- **Nedvurdering**. Å urettferdig kritisere eller merke noe eller noen. For eksempel ble en bildemerkingsteknologi beryktet for å feilmerke bilder av mørkhudede mennesker som gorillaer.
+- **Over- eller underrepresentasjon**. Ideen om at en bestemt gruppe ikke er synlig i et bestemt yrke, og enhver tjeneste eller funksjon som fortsetter å fremme dette, bidrar til skade.
+- **Stereotypisering**. Å assosiere en gitt gruppe med forhåndsbestemte egenskaper. For eksempel kan et språkoversettingssystem mellom engelsk og tyrkisk ha unøyaktigheter på grunn av ord med stereotypiske kjønnsassosiasjoner.
+
+![oversettelse til tyrkisk](../../../../1-Introduction/3-fairness/images/gender-bias-translate-en-tr.png)
+> oversettelse til tyrkisk
+
+![oversettelse tilbake til engelsk](../../../../1-Introduction/3-fairness/images/gender-bias-translate-tr-en.png)
+> oversettelse tilbake til engelsk
+
+Når vi designer og tester AI-systemer, må vi sørge for at AI er rettferdig og ikke programmert til å ta skjeve eller diskriminerende beslutninger, noe som også er forbudt for mennesker. Å garantere rettferdighet i AI og maskinlæring forblir en kompleks sosioteknisk utfordring.
+
+### Pålitelighet og sikkerhet
+
+For å bygge tillit må AI-systemer være pålitelige, sikre og konsistente under normale og uventede forhold. Det er viktig å vite hvordan AI-systemer vil oppføre seg i ulike situasjoner, spesielt når det gjelder avvik. Når vi bygger AI-løsninger, må vi fokusere mye på hvordan vi håndterer et bredt spekter av omstendigheter som AI-løsningene kan møte. For eksempel må en selvkjørende bil prioritere menneskers sikkerhet. Derfor må AI som driver bilen, ta hensyn til alle mulige scenarier bilen kan møte, som natt, tordenvær eller snøstormer, barn som løper over gaten, kjæledyr, veiarbeid osv. Hvor godt et AI-system kan håndtere et bredt spekter av forhold pålitelig og sikkert, reflekterer nivået av forberedelse dataforskeren eller AI-utvikleren har vurdert under design eller testing av systemet.
+
+> [🎥 Klikk her for en video: ](https://www.microsoft.com/videoplayer/embed/RE4vvIl)
+
+### Inkludering
+
+AI-systemer bør designes for å engasjere og styrke alle. Når dataforskere og AI-utviklere designer og implementerer AI-systemer, identifiserer og adresserer de potensielle barrierer i systemet som utilsiktet kan ekskludere mennesker. For eksempel finnes det 1 milliard mennesker med funksjonshemminger over hele verden. Med fremskritt innen AI kan de lettere få tilgang til et bredt spekter av informasjon og muligheter i hverdagen. Ved å adressere barrierene skapes det muligheter for å innovere og utvikle AI-produkter med bedre opplevelser som gagner alle.
+
+> [🎥 Klikk her for en video: inkludering i AI](https://www.microsoft.com/videoplayer/embed/RE4vl9v)
+
+### Sikkerhet og personvern
+
+AI-systemer bør være trygge og respektere folks personvern. Folk har mindre tillit til systemer som setter deres personvern, informasjon eller liv i fare. Når vi trener maskinlæringsmodeller, er vi avhengige av data for å oppnå de beste resultatene. I denne prosessen må vi vurdere opprinnelsen til dataene og deres integritet. For eksempel, ble dataene sendt inn av brukere eller var de offentlig tilgjengelige? Videre, mens vi arbeider med dataene, er det avgjørende å utvikle AI-systemer som kan beskytte konfidensiell informasjon og motstå angrep. Etter hvert som AI blir mer utbredt, blir det stadig viktigere og mer komplekst å beskytte personvern og sikre viktig personlig og forretningsmessig informasjon. Personvern og datasikkerhet krever spesielt nøye oppmerksomhet for AI, fordi tilgang til data er essensielt for at AI-systemer skal kunne gi nøyaktige og informerte prediksjoner og beslutninger om mennesker.
+
+> [🎥 Klikk her for en video: sikkerhet i AI](https://www.microsoft.com/videoplayer/embed/RE4voJF)
+
+- Som bransje har vi gjort betydelige fremskritt innen personvern og sikkerhet, drevet i stor grad av reguleringer som GDPR (General Data Protection Regulation).
+- Likevel må vi med AI-systemer erkjenne spenningen mellom behovet for mer personlige data for å gjøre systemer mer personlige og effektive – og personvern.
+- Akkurat som med fremveksten av tilkoblede datamaskiner via internett, ser vi også en stor økning i antall sikkerhetsproblemer relatert til AI.
+- Samtidig har vi sett AI bli brukt til å forbedre sikkerhet. For eksempel drives de fleste moderne antivirusprogrammer i dag av AI-heuristikk.
+- Vi må sørge for at våre dataforskningsprosesser harmonerer med de nyeste praksisene for personvern og sikkerhet.
+
+### Åpenhet
+
+AI-systemer bør være forståelige. En viktig del av åpenhet er å forklare oppførselen til AI-systemer og deres komponenter. Forbedring av forståelsen av AI-systemer krever at interessenter forstår hvordan og hvorfor de fungerer, slik at de kan identifisere potensielle ytelsesproblemer, sikkerhets- og personvernhensyn, skjevheter, ekskluderende praksis eller utilsiktede utfall. Vi mener også at de som bruker AI-systemer, bør være ærlige og åpne om når, hvorfor og hvordan de velger å bruke dem, samt begrensningene til systemene de bruker. For eksempel, hvis en bank bruker et AI-system for å støtte sine utlånsbeslutninger, er det viktig å undersøke resultatene og forstå hvilke data som påvirker systemets anbefalinger. Regjeringer begynner å regulere AI på tvers av bransjer, så dataforskere og organisasjoner må forklare om et AI-system oppfyller regulatoriske krav, spesielt når det oppstår et uønsket utfall.
+
+> [🎥 Klikk her for en video: åpenhet i AI](https://www.microsoft.com/videoplayer/embed/RE4voJF)
+
+- Fordi AI-systemer er så komplekse, er det vanskelig å forstå hvordan de fungerer og tolke resultatene.
+- Denne mangelen på forståelse påvirker hvordan disse systemene administreres, operasjonaliseres og dokumenteres.
+- Enda viktigere påvirker denne mangelen på forståelse beslutningene som tas basert på resultatene disse systemene produserer.
+
+### Ansvarlighet
+
+De som designer og implementerer AI-systemer, må være ansvarlige for hvordan systemene deres fungerer. Behovet for ansvarlighet er spesielt viktig for sensitive teknologier som ansiktsgjenkjenning. Nylig har det vært en økende etterspørsel etter ansiktsgjenkjenningsteknologi, spesielt fra rettshåndhevelsesorganisasjoner som ser potensialet i teknologien for bruk som å finne savnede barn. Imidlertid kan disse teknologiene potensielt brukes av en regjering til å sette borgernes grunnleggende friheter i fare, for eksempel ved å muliggjøre kontinuerlig overvåking av spesifikke individer. Derfor må dataforskere og organisasjoner være ansvarlige for hvordan deres AI-system påvirker enkeltpersoner eller samfunnet.
+
+[![Ledende AI-forsker advarer om masseovervåking gjennom ansiktsgjenkjenning](../../../../1-Introduction/3-fairness/images/accountability.png)](https://www.youtube.com/watch?v=Wldt8P5V6D0 "Microsofts tilnærming til ansvarlig AI")
+
+> 🎥 Klikk på bildet over for en video: Advarsler om masseovervåking gjennom ansiktsgjenkjenning
+
+Til syvende og sist er et av de største spørsmålene for vår generasjon, som den første generasjonen som bringer AI til samfunnet, hvordan vi kan sikre at datamaskiner forblir ansvarlige overfor mennesker, og hvordan vi kan sikre at de som designer datamaskiner, forblir ansvarlige overfor alle andre.
+
+## Konsekvensvurdering
+
+Før du trener en maskinlæringsmodell, er det viktig å gjennomføre en konsekvensvurdering for å forstå formålet med AI-systemet; hva den tiltenkte bruken er; hvor det vil bli implementert; og hvem som vil samhandle med systemet. Dette er nyttig for vurderere eller testere som evaluerer systemet for å vite hvilke faktorer de skal ta hensyn til når de identifiserer potensielle risikoer og forventede konsekvenser.
+
+Følgende er fokusområder når du gjennomfører en konsekvensvurdering:
+
+* **Negative konsekvenser for enkeltpersoner**. Å være klar over eventuelle begrensninger eller krav, ikke-støttet bruk eller kjente begrensninger som hindrer systemets ytelse, er avgjørende for å sikre at systemet ikke brukes på en måte som kan skade enkeltpersoner.
+* **Datakrav**. Å forstå hvordan og hvor systemet vil bruke data, gjør det mulig for vurderere å utforske eventuelle datakrav du må være oppmerksom på (f.eks. GDPR eller HIPAA-reguleringer). I tillegg bør du undersøke om kilden eller mengden av data er tilstrekkelig for trening.
+* **Oppsummering av konsekvenser**. Samle en liste over potensielle skader som kan oppstå ved bruk av systemet. Gjennom hele ML-livssyklusen bør du vurdere om de identifiserte problemene er adressert eller redusert.
+* **Gjeldende mål** for hver av de seks kjerneprinsippene. Vurder om målene fra hvert prinsipp er oppfylt, og om det er noen mangler.
+
+## Feilsøking med ansvarlig AI
+
+Akkurat som med feilsøking av en programvareapplikasjon, er feilsøking av et AI-system en nødvendig prosess for å identifisere og løse problemer i systemet. Det er mange faktorer som kan påvirke at en modell ikke presterer som forventet eller ansvarlig. De fleste tradisjonelle modellytelsesmålinger er kvantitative aggregater av en modells ytelse, som ikke er tilstrekkelige for å analysere hvordan en modell bryter med prinsippene for ansvarlig AI. Videre er en maskinlæringsmodell en "svart boks" som gjør det vanskelig å forstå hva som driver dens utfall eller forklare hvorfor den gjør feil. Senere i dette kurset vil vi lære hvordan vi bruker Responsible AI-dashbordet for å hjelpe med feilsøking av AI-systemer. Dashbordet gir et helhetlig verktøy for dataforskere og AI-utviklere til å utføre:
+
+* **Feilanalyse**. For å identifisere feilfordelingen i modellen som kan påvirke systemets rettferdighet eller pålitelighet.
+* **Modelloversikt**. For å oppdage hvor det er ulikheter i modellens ytelse på tvers av datakohorter.
+* **Dataanalyse**. For å forstå datadistribusjonen og identifisere potensielle skjevheter i dataene som kan føre til problemer med rettferdighet, inkludering og pålitelighet.
+* **Modellfortolkning**. For å forstå hva som påvirker eller driver modellens prediksjoner. Dette hjelper med å forklare modellens oppførsel, som er viktig for åpenhet og ansvarlighet.
+
+## 🚀 Utfordring
+
+For å forhindre at skader introduseres i utgangspunktet, bør vi:
+
+- ha et mangfold av bakgrunner og perspektiver blant de som jobber med systemer
+- investere i datasett som reflekterer mangfoldet i samfunnet vårt
+- utvikle bedre metoder gjennom hele maskinlæringslivssyklusen for å oppdage og korrigere ansvarlig AI når det oppstår
+
+Tenk på virkelige scenarier der en modells upålitelighet er tydelig i modellbygging og bruk. Hva annet bør vi vurdere?
+
+## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+## Gjennomgang og selvstudium
+
+I denne leksjonen har du lært noen grunnleggende konsepter om rettferdighet og urettferdighet i maskinlæring.
+Se denne workshopen for å fordype deg i temaene:
+
+- På jakt etter ansvarlig AI: Fra prinsipper til praksis av Besmira Nushi, Mehrnoosh Sameki og Amit Sharma
+
+[![Responsible AI Toolbox: En åpen kildekode-rammeverk for å bygge ansvarlig AI](https://img.youtube.com/vi/tGgJCrA-MZU/0.jpg)](https://www.youtube.com/watch?v=tGgJCrA-MZU "RAI Toolbox: En åpen kildekode-rammeverk for å bygge ansvarlig AI")
+
+
+> 🎥 Klikk på bildet over for en video: RAI Toolbox: En åpen kildekode-rammeverk for å bygge ansvarlig AI av Besmira Nushi, Mehrnoosh Sameki og Amit Sharma
+
+Les også:
+
+- Microsofts RAI ressursenter: [Responsible AI Resources – Microsoft AI](https://www.microsoft.com/ai/responsible-ai-resources?activetab=pivot1%3aprimaryr4) 
+
+- Microsofts FATE forskningsgruppe: [FATE: Fairness, Accountability, Transparency, and Ethics in AI - Microsoft Research](https://www.microsoft.com/research/theme/fate/) 
+
+RAI Toolbox:
+
+- [Responsible AI Toolbox GitHub repository](https://github.com/microsoft/responsible-ai-toolbox)
+
+Les om Azure Machine Learning sine verktøy for å sikre rettferdighet:
+
+- [Azure Machine Learning](https://docs.microsoft.com/azure/machine-learning/concept-fairness-ml?WT.mc_id=academic-77952-leestott) 
+
+## Oppgave
+
+[Utforsk RAI Toolbox](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/1-Introduction/3-fairness/assignment.md

@@ -0,0 +1,25 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "dbda60e7b1fe5f18974e7858eff0004e",
+  "translation_date": "2025-09-05T21:40:15+00:00",
+  "source_file": "1-Introduction/3-fairness/assignment.md",
+  "language_code": "no"
+}
+-->
+# Utforsk Responsible AI Toolbox
+
+## Instruksjoner
+
+I denne leksjonen lærte du om Responsible AI Toolbox, et "åpen kildekode, samfunnsdrevet prosjekt for å hjelpe dataforskere med å analysere og forbedre AI-systemer." For denne oppgaven, utforsk en av RAI Toolbox sine [notebooks](https://github.com/microsoft/responsible-ai-toolbox/blob/main/notebooks/responsibleaidashboard/getting-started.ipynb) og rapporter funnene dine i et papir eller en presentasjon.
+
+## Vurderingskriterier
+
+| Kriterier | Fremragende | Tilfredsstillende | Trenger forbedring |
+| --------- | ----------- | ----------------- | ------------------ |
+|           | Et papir eller PowerPoint-presentasjon blir levert som diskuterer Fairlearns systemer, notebooken som ble kjørt, og konklusjonene som ble trukket fra den | Et papir blir levert uten konklusjoner | Ingen papir blir levert |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/1-Introduction/4-techniques-of-ML/README.md

@@ -0,0 +1,132 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "9d91f3af3758fdd4569fb410575995ef",
+  "translation_date": "2025-09-05T21:41:24+00:00",
+  "source_file": "1-Introduction/4-techniques-of-ML/README.md",
+  "language_code": "no"
+}
+-->
+# Teknikker for maskinlæring
+
+Prosessen med å bygge, bruke og vedlikeholde maskinlæringsmodeller og dataene de bruker, er svært forskjellig fra mange andre utviklingsarbeidsflyter. I denne leksjonen vil vi avmystifisere prosessen og skissere de viktigste teknikkene du trenger å kjenne til. Du vil:
+
+- Forstå prosessene som ligger til grunn for maskinlæring på et overordnet nivå.
+- Utforske grunnleggende konsepter som 'modeller', 'prediksjoner' og 'treningsdata'.
+
+## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
+
+[![ML for nybegynnere - Teknikker for maskinlæring](https://img.youtube.com/vi/4NGM0U2ZSHU/0.jpg)](https://youtu.be/4NGM0U2ZSHU "ML for nybegynnere - Teknikker for maskinlæring")
+
+> 🎥 Klikk på bildet over for en kort video som går gjennom denne leksjonen.
+
+## Introduksjon
+
+På et overordnet nivå består håndverket med å lage maskinlæringsprosesser (ML) av flere steg:
+
+1. **Bestem spørsmålet**. De fleste ML-prosesser starter med å stille et spørsmål som ikke kan besvares med et enkelt betingelsesbasert program eller regelbasert motor. Disse spørsmålene dreier seg ofte om prediksjoner basert på en samling data.
+2. **Samle og forbered data**. For å kunne besvare spørsmålet ditt trenger du data. Kvaliteten og, noen ganger, mengden av dataene dine vil avgjøre hvor godt du kan besvare det opprinnelige spørsmålet. Visualisering av data er en viktig del av denne fasen. Denne fasen inkluderer også å dele dataene inn i en trenings- og testgruppe for å bygge en modell.
+3. **Velg en treningsmetode**. Avhengig av spørsmålet ditt og naturen til dataene dine, må du velge hvordan du vil trene en modell for best å reflektere dataene og lage nøyaktige prediksjoner basert på dem. Dette er den delen av ML-prosessen som krever spesifikk ekspertise og ofte en betydelig mengde eksperimentering.
+4. **Tren modellen**. Ved hjelp av treningsdataene dine bruker du ulike algoritmer for å trene en modell til å gjenkjenne mønstre i dataene. Modellen kan bruke interne vekter som kan justeres for å prioritere visse deler av dataene over andre for å bygge en bedre modell.
+5. **Evaluer modellen**. Du bruker data som modellen aldri har sett før (testdataene dine) fra den innsamlede samlingen for å se hvordan modellen presterer.
+6. **Parameterjustering**. Basert på modellens ytelse kan du gjenta prosessen med forskjellige parametere eller variabler som styrer oppførselen til algoritmene som brukes til å trene modellen.
+7. **Prediksjon**. Bruk nye input for å teste modellens nøyaktighet.
+
+## Hvilket spørsmål skal du stille?
+
+Datamaskiner er spesielt dyktige til å oppdage skjulte mønstre i data. Denne egenskapen er svært nyttig for forskere som har spørsmål om et gitt område som ikke enkelt kan besvares ved å lage en betingelsesbasert regelmotor. Gitt en aktuariell oppgave, for eksempel, kan en dataforsker være i stand til å konstruere håndlagde regler rundt dødeligheten til røykere vs. ikke-røykere.
+
+Når mange andre variabler tas med i ligningen, kan imidlertid en ML-modell vise seg å være mer effektiv til å forutsi fremtidige dødelighetsrater basert på tidligere helsehistorikk. Et mer oppløftende eksempel kan være å lage værprediksjoner for april måned på et gitt sted basert på data som inkluderer breddegrad, lengdegrad, klimaendringer, nærhet til havet, mønstre i jetstrømmen og mer.
+
+✅ Denne [presentasjonen](https://www2.cisl.ucar.edu/sites/default/files/2021-10/0900%20June%2024%20Haupt_0.pdf) om værmodeller gir et historisk perspektiv på bruk av ML i væranalyse.  
+
+## Oppgaver før bygging
+
+Før du begynner å bygge modellen din, er det flere oppgaver du må fullføre. For å teste spørsmålet ditt og danne en hypotese basert på modellens prediksjoner, må du identifisere og konfigurere flere elementer.
+
+### Data
+
+For å kunne besvare spørsmålet ditt med en viss grad av sikkerhet, trenger du en god mengde data av riktig type. Det er to ting du må gjøre på dette tidspunktet:
+
+- **Samle data**. Med tanke på den forrige leksjonen om rettferdighet i dataanalyse, samle dataene dine med omhu. Vær oppmerksom på kildene til disse dataene, eventuelle iboende skjevheter de kan ha, og dokumenter opprinnelsen.
+- **Forbered data**. Det er flere steg i prosessen med databehandling. Du kan trenge å samle data og normalisere dem hvis de kommer fra ulike kilder. Du kan forbedre kvaliteten og mengden av dataene gjennom ulike metoder, som å konvertere strenger til tall (som vi gjør i [Clustering](../../5-Clustering/1-Visualize/README.md)). Du kan også generere nye data basert på de opprinnelige (som vi gjør i [Classification](../../4-Classification/1-Introduction/README.md)). Du kan rense og redigere dataene (som vi gjør før [Web App](../../3-Web-App/README.md)-leksjonen). Til slutt kan det hende du må randomisere og blande dem, avhengig av treningsmetodene dine.
+
+✅ Etter å ha samlet og behandlet dataene dine, ta et øyeblikk for å se om formen deres vil tillate deg å adressere det tiltenkte spørsmålet. Det kan være at dataene ikke vil fungere godt for den gitte oppgaven, som vi oppdager i våre [Clustering](../../5-Clustering/1-Visualize/README.md)-leksjoner!
+
+### Funksjoner og mål
+
+En [funksjon](https://www.datasciencecentral.com/profiles/blogs/an-introduction-to-variable-and-feature-selection) er en målbar egenskap ved dataene dine. I mange datasett uttrykkes det som en kolonneoverskrift som 'dato', 'størrelse' eller 'farge'. Funksjonsvariabelen din, vanligvis representert som `X` i kode, representerer inputvariabelen som vil bli brukt til å trene modellen.
+
+Et mål er det du prøver å forutsi. Målet, vanligvis representert som `y` i kode, representerer svaret på spørsmålet du prøver å stille til dataene dine: i desember, hvilken **farge** vil gresskar være billigst? I San Francisco, hvilke nabolag vil ha de beste eiendoms**prisene**? Noen ganger refereres målet også til som etikettattributt.
+
+### Velge funksjonsvariabelen din
+
+🎓 **Funksjonsvalg og funksjonsekstraksjon** Hvordan vet du hvilken variabel du skal velge når du bygger en modell? Du vil sannsynligvis gå gjennom en prosess med funksjonsvalg eller funksjonsekstraksjon for å velge de riktige variablene for den mest effektive modellen. De er imidlertid ikke det samme: "Funksjonsekstraksjon lager nye funksjoner fra funksjoner av de opprinnelige funksjonene, mens funksjonsvalg returnerer et delsett av funksjonene." ([kilde](https://wikipedia.org/wiki/Feature_selection))
+
+### Visualiser dataene dine
+
+En viktig del av verktøysettet til en dataforsker er evnen til å visualisere data ved hjelp av flere utmerkede biblioteker som Seaborn eller MatPlotLib. Å representere dataene dine visuelt kan hjelpe deg med å avdekke skjulte korrelasjoner som du kan utnytte. Visualiseringene dine kan også hjelpe deg med å avdekke skjevheter eller ubalanserte data (som vi oppdager i [Classification](../../4-Classification/2-Classifiers-1/README.md)).
+
+### Del opp datasettet ditt
+
+Før trening må du dele datasettet ditt inn i to eller flere deler av ulik størrelse som fortsatt representerer dataene godt.
+
+- **Trening**. Denne delen av datasettet tilpasses modellen din for å trene den. Dette settet utgjør majoriteten av det opprinnelige datasettet.
+- **Testing**. Et testdatasett er en uavhengig gruppe data, ofte hentet fra de opprinnelige dataene, som du bruker for å bekrefte ytelsen til den bygde modellen.
+- **Validering**. Et valideringssett er en mindre uavhengig gruppe eksempler som du bruker for å finjustere modellens hyperparametere eller arkitektur for å forbedre modellen. Avhengig av størrelsen på dataene dine og spørsmålet du stiller, trenger du kanskje ikke å bygge dette tredje settet (som vi bemerker i [Time Series Forecasting](../../7-TimeSeries/1-Introduction/README.md)).
+
+## Bygge en modell
+
+Ved hjelp av treningsdataene dine er målet ditt å bygge en modell, eller en statistisk representasjon av dataene dine, ved hjelp av ulike algoritmer for å **trene** den. Å trene en modell eksponerer den for data og lar den gjøre antakelser om oppdagede mønstre, validere dem og akseptere eller avvise dem.
+
+### Bestem treningsmetoden
+
+Avhengig av spørsmålet ditt og naturen til dataene dine, vil du velge en metode for å trene dem. Ved å gå gjennom [Scikit-learn's dokumentasjon](https://scikit-learn.org/stable/user_guide.html) - som vi bruker i dette kurset - kan du utforske mange måter å trene en modell på. Avhengig av erfaringen din, kan det hende du må prøve flere forskjellige metoder for å bygge den beste modellen. Du vil sannsynligvis gå gjennom en prosess der dataforskere evaluerer ytelsen til en modell ved å mate den med ukjente data, sjekke for nøyaktighet, skjevhet og andre kvalitetsreduserende problemer, og velge den mest passende treningsmetoden for oppgaven.
+
+### Tren en modell
+
+Med treningsdataene dine er du klar til å 'tilpasse' dem for å lage en modell. Du vil legge merke til at i mange ML-biblioteker finner du koden 'model.fit' - det er på dette tidspunktet du sender inn funksjonsvariabelen din som en matrise av verdier (vanligvis 'X') og en målvariabel (vanligvis 'y').
+
+### Evaluer modellen
+
+Når treningsprosessen er fullført (det kan ta mange iterasjoner, eller 'epoker', å trene en stor modell), vil du kunne evaluere modellens kvalitet ved å bruke testdata for å måle ytelsen. Disse dataene er et delsett av de opprinnelige dataene som modellen ikke tidligere har analysert. Du kan skrive ut en tabell med metrikker om modellens kvalitet.
+
+🎓 **Modelltilpasning**
+
+I sammenheng med maskinlæring refererer modelltilpasning til nøyaktigheten av modellens underliggende funksjon når den forsøker å analysere data den ikke er kjent med.
+
+🎓 **Undertilpasning** og **overtilpasning** er vanlige problemer som reduserer modellens kvalitet, ettersom modellen enten tilpasser seg for dårlig eller for godt. Dette fører til at modellen lager prediksjoner som enten er for tett knyttet til eller for løst knyttet til treningsdataene. En overtilpasset modell forutsier treningsdataene for godt fordi den har lært detaljene og støyen i dataene for godt. En undertilpasset modell er ikke nøyaktig, da den verken kan analysere treningsdataene eller data den ikke har 'sett' på en korrekt måte.
+
+![overtilpasset modell](../../../../1-Introduction/4-techniques-of-ML/images/overfitting.png)
+> Infografikk av [Jen Looper](https://twitter.com/jenlooper)
+
+## Parameterjustering
+
+Når den første treningen er fullført, observer kvaliteten på modellen og vurder å forbedre den ved å justere dens 'hyperparametere'. Les mer om prosessen [i dokumentasjonen](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-tune-hyperparameters?WT.mc_id=academic-77952-leestott).
+
+## Prediksjon
+
+Dette er øyeblikket hvor du kan bruke helt nye data for å teste modellens nøyaktighet. I en 'anvendt' ML-setting, der du bygger nettressurser for å bruke modellen i produksjon, kan denne prosessen innebære å samle brukerinput (for eksempel et knappetrykk) for å sette en variabel og sende den til modellen for inferens eller evaluering.
+
+I disse leksjonene vil du oppdage hvordan du bruker disse stegene til å forberede, bygge, teste, evaluere og forutsi - alle oppgavene til en dataforsker og mer, mens du utvikler deg på reisen til å bli en 'full stack' ML-ingeniør.
+
+---
+
+## 🚀Utfordring
+
+Lag et flytskjema som reflekterer stegene til en ML-praktiker. Hvor ser du deg selv akkurat nå i prosessen? Hvor tror du at du vil møte vanskeligheter? Hva virker enkelt for deg?
+
+## [Quiz etter leksjonen](https://ff-quizzes.netlify.app/en/ml/)
+
+## Gjennomgang og selvstudium
+
+Søk på nettet etter intervjuer med dataforskere som diskuterer sitt daglige arbeid. Her er [et](https://www.youtube.com/watch?v=Z3IjgbbCEfs).
+
+## Oppgave
+
+[Intervju en dataforsker](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/1-Introduction/4-techniques-of-ML/assignment.md

@@ -0,0 +1,25 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "70d65aeddc06170bc1aed5b27805f930",
+  "translation_date": "2025-09-05T21:42:07+00:00",
+  "source_file": "1-Introduction/4-techniques-of-ML/assignment.md",
+  "language_code": "no"
+}
+-->
+# Intervju en data scientist
+
+## Instruksjoner
+
+I din bedrift, i en brukergruppe, eller blant vennene dine eller medstudenter, snakk med noen som jobber profesjonelt som data scientist. Skriv en kort oppgave (500 ord) om deres daglige arbeidsoppgaver. Er de spesialister, eller jobber de 'full stack'?
+
+## Vurderingskriterier
+
+| Kriterier | Fremragende                                                                         | Tilfredsstillende                                                  | Trenger forbedring    |
+| --------- | ----------------------------------------------------------------------------------- | ------------------------------------------------------------------ | --------------------- |
+|           | En oppgave med korrekt lengde, med tilskrevne kilder, presentert som en .doc-fil    | Oppgaven er dårlig tilskrevet eller kortere enn den påkrevde lengden | Ingen oppgave er levert |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/1-Introduction/README.md

@@ -0,0 +1,36 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "cf8ecc83f28e5b98051d2179eca08e08",
+  "translation_date": "2025-09-05T21:37:38+00:00",
+  "source_file": "1-Introduction/README.md",
+  "language_code": "no"
+}
+-->
+# Introduksjon til maskinlæring
+
+I denne delen av læreplanen vil du bli introdusert til de grunnleggende konseptene som ligger til grunn for feltet maskinlæring, hva det er, og lære om historien og teknikkene forskere bruker for å arbeide med det. La oss utforske denne nye verdenen av ML sammen!
+
+![globe](../../../1-Introduction/images/globe.jpg)
+> Foto av <a href="https://unsplash.com/@bill_oxford?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Bill Oxford</a> på <a href="https://unsplash.com/s/photos/globe?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
+  
+### Leksjoner
+
+1. [Introduksjon til maskinlæring](1-intro-to-ML/README.md)
+1. [Historien til maskinlæring og AI](2-history-of-ML/README.md)
+1. [Rettferdighet og maskinlæring](3-fairness/README.md)
+1. [Teknikker innen maskinlæring](4-techniques-of-ML/README.md)
+### Krediteringer
+
+"Introduksjon til maskinlæring" ble skrevet med ♥️ av et team av folk inkludert [Muhammad Sakib Khan Inan](https://twitter.com/Sakibinan), [Ornella Altunyan](https://twitter.com/ornelladotcom) og [Jen Looper](https://twitter.com/jenlooper)
+
+"Historien til maskinlæring" ble skrevet med ♥️ av [Jen Looper](https://twitter.com/jenlooper) og [Amy Boyd](https://twitter.com/AmyKateNicho)
+
+"Rettferdighet og maskinlæring" ble skrevet med ♥️ av [Tomomi Imura](https://twitter.com/girliemac) 
+
+"Teknikker innen maskinlæring" ble skrevet med ♥️ av [Jen Looper](https://twitter.com/jenlooper) og [Chris Noring](https://twitter.com/softchris)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/2-Regression/1-Tools/README.md

@@ -0,0 +1,238 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "fa81d226c71d5af7a2cade31c1c92b88",
+  "translation_date": "2025-09-05T21:13:58+00:00",
+  "source_file": "2-Regression/1-Tools/README.md",
+  "language_code": "no"
+}
+-->
+# Kom i gang med Python og Scikit-learn for regresjonsmodeller
+
+![Oppsummering av regresjoner i en sketchnote](../../../../sketchnotes/ml-regression.png)
+
+> Sketchnote av [Tomomi Imura](https://www.twitter.com/girlie_mac)
+
+## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
+
+> ### [Denne leksjonen er også tilgjengelig i R!](../../../../2-Regression/1-Tools/solution/R/lesson_1.html)
+
+## Introduksjon
+
+I disse fire leksjonene vil du lære hvordan du bygger regresjonsmodeller. Vi skal snart diskutere hva disse brukes til. Men før du gjør noe som helst, sørg for at du har de riktige verktøyene på plass for å starte prosessen!
+
+I denne leksjonen vil du lære å:
+
+- Konfigurere datamaskinen din for lokale maskinlæringsoppgaver.
+- Jobbe med Jupyter-notatbøker.
+- Bruke Scikit-learn, inkludert installasjon.
+- Utforske lineær regresjon gjennom en praktisk øvelse.
+
+## Installasjoner og konfigurasjoner
+
+[![ML for nybegynnere - Sett opp verktøyene dine for å bygge maskinlæringsmodeller](https://img.youtube.com/vi/-DfeD2k2Kj0/0.jpg)](https://youtu.be/-DfeD2k2Kj0 "ML for nybegynnere - Sett opp verktøyene dine for å bygge maskinlæringsmodeller")
+
+> 🎥 Klikk på bildet over for en kort video som viser hvordan du konfigurerer datamaskinen din for maskinlæring.
+
+1. **Installer Python**. Sørg for at [Python](https://www.python.org/downloads/) er installert på datamaskinen din. Du vil bruke Python til mange oppgaver innen datavitenskap og maskinlæring. De fleste datamaskiner har allerede en Python-installasjon. Det finnes også nyttige [Python Coding Packs](https://code.visualstudio.com/learn/educators/installers?WT.mc_id=academic-77952-leestott) som kan gjøre oppsettet enklere for noen brukere.
+
+   Noen bruksområder for Python krever én versjon av programvaren, mens andre krever en annen versjon. Derfor er det nyttig å jobbe i et [virtuelt miljø](https://docs.python.org/3/library/venv.html).
+
+2. **Installer Visual Studio Code**. Sørg for at Visual Studio Code er installert på datamaskinen din. Følg disse instruksjonene for å [installere Visual Studio Code](https://code.visualstudio.com/) for grunnleggende installasjon. Du skal bruke Python i Visual Studio Code i dette kurset, så det kan være lurt å friske opp hvordan du [konfigurerer Visual Studio Code](https://docs.microsoft.com/learn/modules/python-install-vscode?WT.mc_id=academic-77952-leestott) for Python-utvikling.
+
+   > Bli komfortabel med Python ved å jobbe gjennom denne samlingen av [Learn-moduler](https://docs.microsoft.com/users/jenlooper-2911/collections/mp1pagggd5qrq7?WT.mc_id=academic-77952-leestott)
+   >
+   > [![Sett opp Python med Visual Studio Code](https://img.youtube.com/vi/yyQM70vi7V8/0.jpg)](https://youtu.be/yyQM70vi7V8 "Sett opp Python med Visual Studio Code")
+   >
+   > 🎥 Klikk på bildet over for en video: bruk Python i VS Code.
+
+3. **Installer Scikit-learn** ved å følge [disse instruksjonene](https://scikit-learn.org/stable/install.html). Siden du må sørge for at du bruker Python 3, anbefales det at du bruker et virtuelt miljø. Merk at hvis du installerer dette biblioteket på en M1 Mac, finnes det spesielle instruksjoner på siden som er lenket over.
+
+4. **Installer Jupyter Notebook**. Du må [installere Jupyter-pakken](https://pypi.org/project/jupyter/).
+
+## Ditt ML-utviklingsmiljø
+
+Du skal bruke **notatbøker** for å utvikle Python-koden din og lage maskinlæringsmodeller. Denne typen filer er et vanlig verktøy for dataforskere, og de kan identifiseres ved suffikset eller filtypen `.ipynb`.
+
+Notatbøker er et interaktivt miljø som lar utvikleren både kode og legge til notater og skrive dokumentasjon rundt koden, noe som er ganske nyttig for eksperimentelle eller forskningsorienterte prosjekter.
+
+[![ML for nybegynnere - Sett opp Jupyter-notatbøker for å begynne å bygge regresjonsmodeller](https://img.youtube.com/vi/7E-jC8FLA2E/0.jpg)](https://youtu.be/7E-jC8FLA2E "ML for nybegynnere - Sett opp Jupyter-notatbøker for å begynne å bygge regresjonsmodeller")
+
+> 🎥 Klikk på bildet over for en kort video som viser denne øvelsen.
+
+### Øvelse - jobb med en notatbok
+
+I denne mappen finner du filen _notebook.ipynb_.
+
+1. Åpne _notebook.ipynb_ i Visual Studio Code.
+
+   En Jupyter-server vil starte med Python 3+. Du vil finne områder i notatboken som kan `kjøres`, altså kodeblokker. Du kan kjøre en kodeblokk ved å velge ikonet som ser ut som en avspillingsknapp.
+
+2. Velg `md`-ikonet og legg til litt markdown, og følgende tekst: **# Velkommen til din notatbok**.
+
+   Deretter legger du til litt Python-kode.
+
+3. Skriv **print('hello notebook')** i kodeblokken.
+4. Velg pilen for å kjøre koden.
+
+   Du bør se den utskrevne meldingen:
+
+    ```output
+    hello notebook
+    ```
+
+![VS Code med en åpen notatbok](../../../../2-Regression/1-Tools/images/notebook.jpg)
+
+Du kan blande koden din med kommentarer for å selv-dokumentere notatboken.
+
+✅ Tenk et øyeblikk på hvor forskjellig arbeidsmiljøet til en webutvikler er sammenlignet med en dataforsker.
+
+## Kom i gang med Scikit-learn
+
+Nå som Python er satt opp i ditt lokale miljø, og du er komfortabel med Jupyter-notatbøker, la oss bli like komfortable med Scikit-learn (uttales `sci` som i `science`). Scikit-learn tilbyr en [omfattende API](https://scikit-learn.org/stable/modules/classes.html#api-ref) for å hjelpe deg med å utføre ML-oppgaver.
+
+Ifølge deres [nettsted](https://scikit-learn.org/stable/getting_started.html), "Scikit-learn er et åpen kildekode-bibliotek for maskinlæring som støtter både overvåket og ikke-overvåket læring. Det tilbyr også ulike verktøy for modelltilpasning, dataprosessering, modellvalg og evaluering, samt mange andre nyttige funksjoner."
+
+I dette kurset vil du bruke Scikit-learn og andre verktøy for å bygge maskinlæringsmodeller for å utføre det vi kaller 'tradisjonelle maskinlæringsoppgaver'. Vi har bevisst unngått nevrale nettverk og dyp læring, da disse dekkes bedre i vårt kommende 'AI for nybegynnere'-pensum.
+
+Scikit-learn gjør det enkelt å bygge modeller og evaluere dem for bruk. Det fokuserer primært på bruk av numeriske data og inneholder flere ferdiglagde datasett som kan brukes som læringsverktøy. Det inkluderer også forhåndsbygde modeller som studenter kan prøve. La oss utforske prosessen med å laste inn forhåndspakkede data og bruke en innebygd estimator for å lage vår første ML-modell med Scikit-learn ved hjelp av noen grunnleggende data.
+
+## Øvelse - din første Scikit-learn-notatbok
+
+> Denne opplæringen er inspirert av [eksempelet på lineær regresjon](https://scikit-learn.org/stable/auto_examples/linear_model/plot_ols.html#sphx-glr-auto-examples-linear-model-plot-ols-py) på Scikit-learns nettsted.
+
+[![ML for nybegynnere - Ditt første lineære regresjonsprosjekt i Python](https://img.youtube.com/vi/2xkXL5EUpS0/0.jpg)](https://youtu.be/2xkXL5EUpS0 "ML for nybegynnere - Ditt første lineære regresjonsprosjekt i Python")
+
+> 🎥 Klikk på bildet over for en kort video som viser denne øvelsen.
+
+I _notebook.ipynb_-filen som er tilknyttet denne leksjonen, tøm alle cellene ved å trykke på 'søppelbøtte'-ikonet.
+
+I denne delen skal du jobbe med et lite datasett om diabetes som er innebygd i Scikit-learn for læringsformål. Tenk deg at du ønsket å teste en behandling for diabetikere. Maskinlæringsmodeller kan hjelpe deg med å avgjøre hvilke pasienter som vil respondere bedre på behandlingen, basert på kombinasjoner av variabler. Selv en veldig grunnleggende regresjonsmodell, når den visualiseres, kan vise informasjon om variabler som kan hjelpe deg med å organisere dine teoretiske kliniske studier.
+
+✅ Det finnes mange typer regresjonsmetoder, og hvilken du velger avhenger av spørsmålet du ønsker å besvare. Hvis du vil forutsi sannsynlig høyde for en person med en gitt alder, vil du bruke lineær regresjon, siden du søker en **numerisk verdi**. Hvis du er interessert i å finne ut om en type mat skal anses som vegansk eller ikke, ser du etter en **kategoriinndeling**, og da vil du bruke logistisk regresjon. Du vil lære mer om logistisk regresjon senere. Tenk litt på noen spørsmål du kan stille til data, og hvilken av disse metodene som ville være mest passende.
+
+La oss komme i gang med denne oppgaven.
+
+### Importer biblioteker
+
+For denne oppgaven skal vi importere noen biblioteker:
+
+- **matplotlib**. Et nyttig [verktøy for grafer](https://matplotlib.org/) som vi skal bruke til å lage en linjediagram.
+- **numpy**. [numpy](https://numpy.org/doc/stable/user/whatisnumpy.html) er et nyttig bibliotek for håndtering av numeriske data i Python.
+- **sklearn**. Dette er [Scikit-learn](https://scikit-learn.org/stable/user_guide.html)-biblioteket.
+
+Importer noen biblioteker for å hjelpe med oppgavene dine.
+
+1. Legg til imports ved å skrive følgende kode:
+
+   ```python
+   import matplotlib.pyplot as plt
+   import numpy as np
+   from sklearn import datasets, linear_model, model_selection
+   ```
+
+   Over importerer du `matplotlib`, `numpy`, og du importerer `datasets`, `linear_model` og `model_selection` fra `sklearn`. `model_selection` brukes til å dele data i trenings- og testsett.
+
+### Diabetes-datasettet
+
+Det innebygde [diabetes-datasettet](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) inkluderer 442 datasettprøver om diabetes, med 10 funksjonsvariabler, inkludert:
+
+- age: alder i år
+- bmi: kroppsmasseindeks
+- bp: gjennomsnittlig blodtrykk
+- s1 tc: T-celler (en type hvite blodceller)
+
+✅ Dette datasettet inkluderer konseptet 'kjønn' som en funksjonsvariabel viktig for forskning på diabetes. Mange medisinske datasett inkluderer denne typen binær klassifisering. Tenk litt på hvordan slike kategoriseringer kan ekskludere visse deler av befolkningen fra behandlinger.
+
+Nå, last inn X- og y-dataene.
+
+> 🎓 Husk, dette er overvåket læring, og vi trenger et navngitt 'y'-mål.
+
+I en ny kodecelle, last inn diabetes-datasettet ved å kalle `load_diabetes()`. Inputen `return_X_y=True` signaliserer at `X` vil være en datamatrise, og `y` vil være regresjonsmålet.
+
+1. Legg til noen print-kommandoer for å vise formen på datamatrisen og dens første element:
+
+    ```python
+    X, y = datasets.load_diabetes(return_X_y=True)
+    print(X.shape)
+    print(X[0])
+    ```
+
+    Det du får tilbake som svar, er en tuple. Det du gjør, er å tilordne de to første verdiene i tuplen til henholdsvis `X` og `y`. Lær mer [om tupler](https://wikipedia.org/wiki/Tuple).
+
+    Du kan se at disse dataene har 442 elementer formet i matriser med 10 elementer:
+
+    ```text
+    (442, 10)
+    [ 0.03807591  0.05068012  0.06169621  0.02187235 -0.0442235  -0.03482076
+    -0.04340085 -0.00259226  0.01990842 -0.01764613]
+    ```
+
+    ✅ Tenk litt på forholdet mellom dataene og regresjonsmålet. Lineær regresjon forutsier forholdet mellom funksjonen X og målvariabelen y. Kan du finne [målet](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) for diabetes-datasettet i dokumentasjonen? Hva demonstrerer dette datasettet, gitt målet?
+
+2. Velg deretter en del av dette datasettet for å plotte ved å velge den tredje kolonnen i datasettet. Du kan gjøre dette ved å bruke `:`-operatoren for å velge alle rader, og deretter velge den tredje kolonnen ved hjelp av indeksen (2). Du kan også omforme dataene til å være en 2D-matrise - som kreves for plotting - ved å bruke `reshape(n_rows, n_columns)`. Hvis en av parameterne er -1, beregnes den tilsvarende dimensjonen automatisk.
+
+   ```python
+   X = X[:, 2]
+   X = X.reshape((-1,1))
+   ```
+
+   ✅ Når som helst, skriv ut dataene for å sjekke formen.
+
+3. Nå som du har data klare til å bli plottet, kan du se om en maskin kan hjelpe med å bestemme en logisk inndeling mellom tallene i dette datasettet. For å gjøre dette, må du dele både dataene (X) og målet (y) i test- og treningssett. Scikit-learn har en enkel måte å gjøre dette på; du kan dele testdataene dine på et gitt punkt.
+
+   ```python
+   X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.33)
+   ```
+
+4. Nå er du klar til å trene modellen din! Last inn den lineære regresjonsmodellen og tren den med X- og y-treningssettene dine ved å bruke `model.fit()`:
+
+    ```python
+    model = linear_model.LinearRegression()
+    model.fit(X_train, y_train)
+    ```
+
+    ✅ `model.fit()` er en funksjon du vil se i mange ML-biblioteker som TensorFlow.
+
+5. Deretter lager du en prediksjon ved hjelp av testdataene, ved å bruke funksjonen `predict()`. Dette vil brukes til å tegne linjen mellom datagruppene.
+
+    ```python
+    y_pred = model.predict(X_test)
+    ```
+
+6. Nå er det på tide å vise dataene i et diagram. Matplotlib er et veldig nyttig verktøy for denne oppgaven. Lag et spredningsdiagram av alle X- og y-testdataene, og bruk prediksjonen til å tegne en linje på det mest passende stedet mellom modellens datagrupper.
+
+    ```python
+    plt.scatter(X_test, y_test,  color='black')
+    plt.plot(X_test, y_pred, color='blue', linewidth=3)
+    plt.xlabel('Scaled BMIs')
+    plt.ylabel('Disease Progression')
+    plt.title('A Graph Plot Showing Diabetes Progression Against BMI')
+    plt.show()
+    ```
+
+   ![et spredningsdiagram som viser datapunkter rundt diabetes](../../../../2-Regression/1-Tools/images/scatterplot.png)
+✅ Tenk litt over hva som skjer her. En rett linje går gjennom mange små datapunkter, men hva gjør den egentlig? Kan du se hvordan du bør kunne bruke denne linjen til å forutsi hvor et nytt, ukjent datapunkt bør passe i forhold til y-aksen i plottet? Prøv å sette ord på den praktiske bruken av denne modellen.
+
+Gratulerer, du har bygget din første lineære regresjonsmodell, laget en prediksjon med den, og vist den i et plott!
+
+---
+## 🚀Utfordring
+
+Plott en annen variabel fra dette datasettet. Hint: rediger denne linjen: `X = X[:,2]`. Gitt målet for dette datasettet, hva kan du oppdage om utviklingen av diabetes som sykdom?
+## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+## Gjennomgang & Selvstudium
+
+I denne opplæringen jobbet du med enkel lineær regresjon, i stedet for univariat eller multippel lineær regresjon. Les litt om forskjellene mellom disse metodene, eller ta en titt på [denne videoen](https://www.coursera.org/lecture/quantifying-relationships-regression-models/linear-vs-nonlinear-categorical-variables-ai2Ef).
+
+Les mer om konseptet regresjon og tenk over hvilke typer spørsmål som kan besvares med denne teknikken. Ta denne [opplæringen](https://docs.microsoft.com/learn/modules/train-evaluate-regression-models?WT.mc_id=academic-77952-leestott) for å utdype forståelsen din.
+
+## Oppgave
+
+[Et annet datasett](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/2-Regression/1-Tools/assignment.md

@@ -0,0 +1,27 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "74a5cf83e4ebc302afbcbc4f418afd0a",
+  "translation_date": "2025-09-05T21:15:00+00:00",
+  "source_file": "2-Regression/1-Tools/assignment.md",
+  "language_code": "no"
+}
+-->
+# Regressjon med Scikit-learn
+
+## Instruksjoner
+
+Ta en titt på [Linnerud-datasettet](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_linnerud.html#sklearn.datasets.load_linnerud) i Scikit-learn. Dette datasettet har flere [målvariabler](https://scikit-learn.org/stable/datasets/toy_dataset.html#linnerrud-dataset): 'Det består av tre treningsvariabler (data) og tre fysiologiske variabler (mål) samlet inn fra tjue middelaldrende menn på et treningssenter'.
+
+Med egne ord, beskriv hvordan man kan lage en regresjonsmodell som viser sammenhengen mellom midjemål og hvor mange situps som utføres. Gjør det samme for de andre datapunktene i dette datasettet.
+
+## Vurderingskriterier
+
+| Kriterier                     | Eksemplarisk                        | Tilfredsstillende             | Trenger forbedring         |
+| ----------------------------- | ----------------------------------- | ----------------------------- | -------------------------- |
+| Send inn en beskrivende paragraf | En godt skrevet paragraf er sendt inn | Noen få setninger er sendt inn | Ingen beskrivelse er sendt inn |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør betraktes som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/2-Regression/1-Tools/solution/Julia/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+  "translation_date": "2025-09-05T21:15:14+00:00",
+  "source_file": "2-Regression/1-Tools/solution/Julia/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/2-Regression/2-Data/README.md

@@ -0,0 +1,226 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "7c077988328ebfe33b24d07945f16eca",
+  "translation_date": "2025-09-05T21:16:31+00:00",
+  "source_file": "2-Regression/2-Data/README.md",
+  "language_code": "no"
+}
+-->
+# Bygg en regresjonsmodell med Scikit-learn: forbered og visualiser data
+
+![Infografikk for datavisualisering](../../../../2-Regression/2-Data/images/data-visualization.png)
+
+Infografikk av [Dasani Madipalli](https://twitter.com/dasani_decoded)
+
+## [Quiz før forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+> ### [Denne leksjonen er tilgjengelig i R!](../../../../2-Regression/2-Data/solution/R/lesson_2.html)
+
+## Introduksjon
+
+Nå som du har satt opp verktøyene du trenger for å begynne å bygge maskinlæringsmodeller med Scikit-learn, er du klar til å begynne å stille spørsmål til dataene dine. Når du jobber med data og bruker ML-løsninger, er det svært viktig å forstå hvordan du stiller de riktige spørsmålene for å utnytte potensialet i datasettet ditt.
+
+I denne leksjonen vil du lære:
+
+- Hvordan forberede dataene dine for modellbygging.
+- Hvordan bruke Matplotlib til datavisualisering.
+
+## Stille de riktige spørsmålene til dataene dine
+
+Spørsmålet du ønsker svar på vil avgjøre hvilken type ML-algoritmer du vil bruke. Og kvaliteten på svaret du får tilbake vil være sterkt avhengig av kvaliteten på dataene dine.
+
+Ta en titt på [dataene](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) som er gitt for denne leksjonen. Du kan åpne denne .csv-filen i VS Code. Et raskt blikk viser umiddelbart at det finnes tomme felter og en blanding av tekst og numeriske data. Det er også en merkelig kolonne kalt 'Package' hvor dataene er en blanding av 'sacks', 'bins' og andre verdier. Dataene er faktisk litt rotete.
+
+[![ML for nybegynnere - Hvordan analysere og rense et datasett](https://img.youtube.com/vi/5qGjczWTrDQ/0.jpg)](https://youtu.be/5qGjczWTrDQ "ML for nybegynnere - Hvordan analysere og rense et datasett")
+
+> 🎥 Klikk på bildet over for en kort video som viser hvordan du forbereder dataene for denne leksjonen.
+
+Det er faktisk ikke veldig vanlig å få et datasett som er helt klart til bruk for å lage en ML-modell rett ut av boksen. I denne leksjonen vil du lære hvordan du forbereder et rådatasett ved hjelp av standard Python-biblioteker. Du vil også lære ulike teknikker for å visualisere dataene.
+
+## Case-studie: 'gresskarmarkedet'
+
+I denne mappen finner du en .csv-fil i rotmappen `data` kalt [US-pumpkins.csv](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) som inneholder 1757 linjer med data om markedet for gresskar, sortert i grupper etter by. Dette er rådata hentet fra [Specialty Crops Terminal Markets Standard Reports](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) distribuert av United States Department of Agriculture.
+
+### Forberede data
+
+Disse dataene er i det offentlige domene. De kan lastes ned i mange separate filer, per by, fra USDA-nettstedet. For å unngå for mange separate filer har vi slått sammen alle bydataene til ett regneark, så vi har allerede _forberedt_ dataene litt. La oss nå ta en nærmere titt på dataene.
+
+### Gresskardata - tidlige konklusjoner
+
+Hva legger du merke til med disse dataene? Du har allerede sett at det er en blanding av tekst, tall, tomme felter og merkelige verdier som du må forstå.
+
+Hvilket spørsmål kan du stille til disse dataene ved hjelp av en regresjonsteknikk? Hva med "Forutsi prisen på et gresskar som selges i løpet av en gitt måned". Når du ser på dataene igjen, er det noen endringer du må gjøre for å skape den datastrukturen som er nødvendig for oppgaven.
+
+## Øvelse - analyser gresskardataene
+
+La oss bruke [Pandas](https://pandas.pydata.org/), (navnet står for `Python Data Analysis`) et verktøy som er svært nyttig for å forme data, til å analysere og forberede disse gresskardataene.
+
+### Først, sjekk for manglende datoer
+
+Du må først ta steg for å sjekke for manglende datoer:
+
+1. Konverter datoene til et månedsformat (disse er amerikanske datoer, så formatet er `MM/DD/YYYY`).
+2. Ekstraher måneden til en ny kolonne.
+
+Åpne _notebook.ipynb_-filen i Visual Studio Code og importer regnearket til en ny Pandas dataframe.
+
+1. Bruk funksjonen `head()` for å se de første fem radene.
+
+    ```python
+    import pandas as pd
+    pumpkins = pd.read_csv('../data/US-pumpkins.csv')
+    pumpkins.head()
+    ```
+
+    ✅ Hvilken funksjon ville du brukt for å se de siste fem radene?
+
+1. Sjekk om det er manglende data i den nåværende dataframen:
+
+    ```python
+    pumpkins.isnull().sum()
+    ```
+
+    Det er manglende data, men kanskje det ikke vil ha betydning for oppgaven.
+
+1. For å gjøre dataframen din enklere å jobbe med, velg kun de kolonnene du trenger, ved å bruke funksjonen `loc` som henter ut en gruppe rader (gitt som første parameter) og kolonner (gitt som andre parameter) fra den originale dataframen. Uttrykket `:` i eksempelet nedenfor betyr "alle rader".
+
+    ```python
+    columns_to_select = ['Package', 'Low Price', 'High Price', 'Date']
+    pumpkins = pumpkins.loc[:, columns_to_select]
+    ```
+
+### Deretter, bestem gjennomsnittsprisen på gresskar
+
+Tenk på hvordan du kan bestemme gjennomsnittsprisen på et gresskar i en gitt måned. Hvilke kolonner ville du valgt for denne oppgaven? Hint: du trenger 3 kolonner.
+
+Løsning: ta gjennomsnittet av kolonnene `Low Price` og `High Price` for å fylle den nye kolonnen Price, og konverter Date-kolonnen til kun å vise måneden. Heldigvis, ifølge sjekken ovenfor, er det ingen manglende data for datoer eller priser.
+
+1. For å beregne gjennomsnittet, legg til følgende kode:
+
+    ```python
+    price = (pumpkins['Low Price'] + pumpkins['High Price']) / 2
+
+    month = pd.DatetimeIndex(pumpkins['Date']).month
+
+    ```
+
+   ✅ Du kan gjerne skrive ut data du ønsker å sjekke ved å bruke `print(month)`.
+
+2. Kopier deretter de konverterte dataene til en ny Pandas dataframe:
+
+    ```python
+    new_pumpkins = pd.DataFrame({'Month': month, 'Package': pumpkins['Package'], 'Low Price': pumpkins['Low Price'],'High Price': pumpkins['High Price'], 'Price': price})
+    ```
+
+    Hvis du skriver ut dataframen din, vil du se et rent og ryddig datasett som du kan bruke til å bygge din nye regresjonsmodell.
+
+### Men vent! Det er noe merkelig her
+
+Hvis du ser på kolonnen `Package`, blir gresskar solgt i mange forskjellige konfigurasjoner. Noen blir solgt i '1 1/9 bushel'-mål, og noen i '1/2 bushel'-mål, noen per gresskar, noen per pund, og noen i store bokser med varierende bredder.
+
+> Gresskar virker veldig vanskelig å veie konsekvent
+
+Når du graver i de originale dataene, er det interessant at alt med `Unit of Sale` lik 'EACH' eller 'PER BIN' også har `Package`-typen per tomme, per bin, eller 'each'. Gresskar virker veldig vanskelig å veie konsekvent, så la oss filtrere dem ved å velge kun gresskar med strengen 'bushel' i kolonnen `Package`.
+
+1. Legg til et filter øverst i filen, under den opprinnelige .csv-importen:
+
+    ```python
+    pumpkins = pumpkins[pumpkins['Package'].str.contains('bushel', case=True, regex=True)]
+    ```
+
+    Hvis du skriver ut dataene nå, kan du se at du kun får de 415 eller så radene med data som inneholder gresskar per bushel.
+
+### Men vent! Det er én ting til å gjøre
+
+La du merke til at bushel-mengden varierer per rad? Du må normalisere prisingen slik at du viser prisen per bushel, så gjør litt matematikk for å standardisere det.
+
+1. Legg til disse linjene etter blokken som oppretter new_pumpkins-dataframen:
+
+    ```python
+    new_pumpkins.loc[new_pumpkins['Package'].str.contains('1 1/9'), 'Price'] = price/(1 + 1/9)
+
+    new_pumpkins.loc[new_pumpkins['Package'].str.contains('1/2'), 'Price'] = price/(1/2)
+    ```
+
+✅ Ifølge [The Spruce Eats](https://www.thespruceeats.com/how-much-is-a-bushel-1389308), avhenger vekten av en bushel av typen produkt, siden det er et volummål. "En bushel med tomater, for eksempel, skal veie 56 pund... Blader og grønnsaker tar opp mer plass med mindre vekt, så en bushel med spinat er bare 20 pund." Det er ganske komplisert! La oss ikke bry oss med å gjøre en bushel-til-pund-konvertering, og i stedet prise per bushel. All denne studien av bushels med gresskar viser imidlertid hvor viktig det er å forstå naturen til dataene dine!
+
+Nå kan du analysere prisingen per enhet basert på deres bushel-mål. Hvis du skriver ut dataene en gang til, kan du se hvordan det er standardisert.
+
+✅ La du merke til at gresskar som selges per halv-bushel er veldig dyre? Kan du finne ut hvorfor? Hint: små gresskar er mye dyrere enn store, sannsynligvis fordi det er så mange flere av dem per bushel, gitt det ubrukte rommet som tas opp av ett stort hullete pai-gresskar.
+
+## Visualiseringsstrategier
+
+En del av rollen til en dataforsker er å demonstrere kvaliteten og naturen til dataene de jobber med. For å gjøre dette lager de ofte interessante visualiseringer, eller diagrammer, grafer og tabeller, som viser ulike aspekter av dataene. På denne måten kan de visuelt vise relasjoner og mangler som ellers er vanskelig å avdekke.
+
+[![ML for nybegynnere - Hvordan visualisere data med Matplotlib](https://img.youtube.com/vi/SbUkxH6IJo0/0.jpg)](https://youtu.be/SbUkxH6IJo0 "ML for nybegynnere - Hvordan visualisere data med Matplotlib")
+
+> 🎥 Klikk på bildet over for en kort video som viser hvordan du visualiserer dataene for denne leksjonen.
+
+Visualiseringer kan også hjelpe med å avgjøre hvilken maskinlæringsteknikk som er mest passende for dataene. Et spredningsdiagram som ser ut til å følge en linje, for eksempel, indikerer at dataene er en god kandidat for en lineær regresjonsøvelse.
+
+Et datavisualiseringsbibliotek som fungerer godt i Jupyter-notebooks er [Matplotlib](https://matplotlib.org/) (som du også så i forrige leksjon).
+
+> Få mer erfaring med datavisualisering i [disse opplæringene](https://docs.microsoft.com/learn/modules/explore-analyze-data-with-python?WT.mc_id=academic-77952-leestott).
+
+## Øvelse - eksperimenter med Matplotlib
+
+Prøv å lage noen grunnleggende diagrammer for å vise den nye dataframen du nettopp opprettet. Hva ville et grunnleggende linjediagram vise?
+
+1. Importer Matplotlib øverst i filen, under Pandas-importen:
+
+    ```python
+    import matplotlib.pyplot as plt
+    ```
+
+1. Kjør hele notebooken på nytt for å oppdatere.
+1. Nederst i notebooken, legg til en celle for å plotte dataene som en boks:
+
+    ```python
+    price = new_pumpkins.Price
+    month = new_pumpkins.Month
+    plt.scatter(price, month)
+    plt.show()
+    ```
+
+    ![Et spredningsdiagram som viser pris til måned-forhold](../../../../2-Regression/2-Data/images/scatterplot.png)
+
+    Er dette et nyttig diagram? Overrasker noe ved det deg?
+
+    Det er ikke spesielt nyttig, da alt det gjør er å vise dataene dine som en spredning av punkter i en gitt måned.
+
+### Gjør det nyttig
+
+For å få diagrammer til å vise nyttige data, må du vanligvis gruppere dataene på en eller annen måte. La oss prøve å lage et diagram hvor y-aksen viser månedene og dataene demonstrerer distribusjonen av data.
+
+1. Legg til en celle for å lage et gruppert stolpediagram:
+
+    ```python
+    new_pumpkins.groupby(['Month'])['Price'].mean().plot(kind='bar')
+    plt.ylabel("Pumpkin Price")
+    ```
+
+    ![Et stolpediagram som viser pris til måned-forhold](../../../../2-Regression/2-Data/images/barchart.png)
+
+    Dette er en mer nyttig datavisualisering! Det ser ut til å indikere at den høyeste prisen for gresskar forekommer i september og oktober. Stemmer det med forventningene dine? Hvorfor eller hvorfor ikke?
+
+---
+
+## 🚀Utfordring
+
+Utforsk de forskjellige typene visualiseringer som Matplotlib tilbyr. Hvilke typer er mest passende for regresjonsproblemer?
+
+## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+## Gjennomgang & Selvstudium
+
+Ta en titt på de mange måtene å visualisere data på. Lag en liste over de ulike bibliotekene som er tilgjengelige og noter hvilke som er best for gitte typer oppgaver, for eksempel 2D-visualiseringer vs. 3D-visualiseringer. Hva oppdager du?
+
+## Oppgave
+
+[Utforsk visualisering](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/2-Regression/2-Data/assignment.md

@@ -0,0 +1,23 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "4485a1ed4dd1b5647365e3d87456515d",
+  "translation_date": "2025-09-05T21:17:12+00:00",
+  "source_file": "2-Regression/2-Data/assignment.md",
+  "language_code": "no"
+}
+-->
+# Utforske Visualiseringer
+
+Det finnes flere forskjellige biblioteker tilgjengelige for datavisualisering. Lag noen visualiseringer ved hjelp av Gresskar-dataene i denne leksjonen med matplotlib og seaborn i en eksempel-notatbok. Hvilke biblioteker er enklest å jobbe med?
+
+## Vurderingskriterier
+
+| Kriterier | Eksemplarisk | Tilfredsstillende | Trenger Forbedring |
+| --------- | ------------ | ----------------- | ------------------- |
+|           | En notatbok er levert med to utforskninger/visualiseringer | En notatbok er levert med én utforskning/visualisering | En notatbok er ikke levert |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/2-Regression/2-Data/solution/Julia/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+  "translation_date": "2025-09-05T21:17:24+00:00",
+  "source_file": "2-Regression/2-Data/solution/Julia/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/2-Regression/3-Linear/README.md

@@ -0,0 +1,380 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "40e64f004f3cb50aa1d8661672d3cd92",
+  "translation_date": "2025-09-05T21:07:11+00:00",
+  "source_file": "2-Regression/3-Linear/README.md",
+  "language_code": "no"
+}
+-->
+# Bygg en regresjonsmodell med Scikit-learn: regresjon på fire måter
+
+![Infografikk for lineær vs. polynomisk regresjon](../../../../2-Regression/3-Linear/images/linear-polynomial.png)
+> Infografikk av [Dasani Madipalli](https://twitter.com/dasani_decoded)
+## [Quiz før forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+> ### [Denne leksjonen er også tilgjengelig i R!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
+### Introduksjon 
+
+Så langt har du utforsket hva regresjon er med eksempeldata hentet fra gresskarpris-datasettet som vi skal bruke gjennom hele denne leksjonen. Du har også visualisert det ved hjelp av Matplotlib.
+
+Nå er du klar til å dykke dypere inn i regresjon for maskinlæring. Mens visualisering hjelper deg med å forstå data, ligger den virkelige kraften i maskinlæring i _å trene modeller_. Modeller trenes på historiske data for automatisk å fange opp datamønstre, 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 hjelpe oss med å forutsi gresskarpriser basert på ulike inngangsdata. 
+
+[![ML for nybegynnere - Forstå lineær regresjon](https://img.youtube.com/vi/CRxFT8oTDMg/0.jpg)](https://youtu.be/CRxFT8oTDMg "ML for nybegynnere - Forstå lineær regresjon")
+
+> 🎥 Klikk på bildet over for en kort videooversikt over lineær regresjon.
+
+> Gjennom hele dette kurset antar vi minimal kunnskap om matematikk og søker å gjøre det tilgjengelig for studenter fra andre felt. Se etter notater, 🧮 utrop, diagrammer og andre læringsverktøy for å hjelpe med forståelsen.
+
+### Forutsetninger
+
+Du bør nå være kjent med strukturen til gresskar-datasettet vi undersøker. Du finner det forhåndslastet og forhåndsrenset i denne leksjonens _notebook.ipynb_-fil. I filen vises gresskarprisen per bushel i en ny data frame. Sørg for at du kan kjøre disse notatbøkene i kjerner i Visual Studio Code.
+
+### Forberedelse
+
+Som en påminnelse, du laster inn disse dataene for å stille spørsmål til dem. 
+
+- Når er det best å kjøpe gresskar? 
+- Hvilken pris kan jeg forvente for en kasse med miniatyrgresskar?
+- Bør jeg kjøpe dem i halv-bushelkurver eller i 1 1/9 bushel-esker?
+La oss fortsette å grave i disse dataene.
+
+I forrige leksjon opprettet du en Pandas data frame og fylte den med en del av det opprinnelige datasettet, og standardiserte prisen per bushel. Ved å gjøre det var du imidlertid bare i stand til å samle rundt 400 datapunkter, og kun for høstmånedene. 
+
+Ta en titt på dataene som vi har forhåndslastet i denne leksjonens tilhørende notatbok. Dataene er forhåndslastet, og et første spredningsdiagram er laget for å vise månedsdata. Kanskje vi kan få litt mer innsikt i dataene ved å rense dem ytterligere.
+
+## En lineær regresjonslinje
+
+Som du lærte i leksjon 1, er målet med en lineær regresjonsøvelse å kunne tegne en linje for å:
+
+- **Vise variabelsammenhenger**. Vise forholdet mellom variabler
+- **Gjøre forutsigelser**. Gjøre nøyaktige forutsigelser om hvor et nytt datapunkt vil falle i forhold til den linjen. 
+ 
+Det er typisk for **minste kvadraters regresjon** å tegne denne typen linje. Begrepet 'minste kvadrater' betyr at alle datapunktene rundt regresjonslinjen kvadreres og deretter summeres. Ideelt sett er denne summen så liten som mulig, fordi vi ønsker et lavt antall feil, eller `minste kvadrater`. 
+
+Vi gjør dette fordi vi ønsker å modellere en linje som har minst mulig kumulativ avstand fra alle datapunktene våre. Vi kvadrerer også termene før vi legger dem sammen, siden vi er opptatt av størrelsen snarere enn retningen.
+
+> **🧮 Vis meg matematikken** 
+> 
+> Denne linjen, kalt _linjen for beste tilpasning_, 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'. Stigningen på linjen er `b`, og `a` er skjæringspunktet med y-aksen, som refererer til verdien av `Y` når `X = 0`. 
+>
+>![beregn stigningen](../../../../2-Regression/3-Linear/images/slope.png)
+>
+> Først, beregn stigningen `b`. Infografikk av [Jen Looper](https://twitter.com/jenlooper)
+>
+> Med andre ord, og med henvisning til det opprinnelige spørsmålet om gresskar-dataene: "forutsi prisen på et gresskar per bushel etter måned", ville `X` referere til prisen og `Y` til salgsdatoen. 
+>
+>![fullfør ligningen](../../../../2-Regression/3-Linear/images/calculation.png)
+>
+> 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å vise stigningen på linjen, som også avhenger av skjæringspunktet, eller hvor `Y` er plassert når `X = 0`.
+>
+> Du kan se metoden for beregning av disse verdiene på nettstedet [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html). Besøk også [denne minste 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 hjelp av et spredningsdiagram kan du raskt visualisere denne koeffisienten. Et diagram med datapunkter spredt i en ryddig linje har høy korrelasjon, men et diagram med datapunkter spredt overalt mellom X og Y har lav korrelasjon.
+
+En god lineær regresjonsmodell vil være en som har en høy (nærmere 1 enn 0) korrelasjonskoeffisient ved bruk av minste kvadraters regresjonsmetode med en regresjonslinje.
+
+✅ Kjør notatboken som følger med denne leksjonen, og se på spredningsdiagrammet for måned til pris. Ser dataene som knytter måned til pris for gresskarsalg ut til å ha høy eller lav korrelasjon, ifølge din visuelle tolkning av spredningsdiagrammet? Endrer det seg hvis du bruker en mer detaljert måling i stedet for `Måned`, for eksempel *dag i året* (dvs. antall dager siden begynnelsen av året)?
+
+I koden nedenfor antar vi at vi har renset dataene og fått en data frame kalt `new_pumpkins`, som ligner på følgende:
+
+ID | Måned | DagIÅret | Sort | By | Pakke | Lav pris | Høy pris | Pris
+---|-------|----------|------|-----|--------|----------|----------|-----
+70 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364
+71 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 18.0 | 18.0 | 16.363636
+72 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 18.0 | 18.0 | 16.363636
+73 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 17.0 | 17.0 | 15.454545
+74 | 10 | 281 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364
+
+> Koden for å rense dataene er tilgjengelig i [`notebook.ipynb`](../../../../2-Regression/3-Linear/notebook.ipynb). Vi har utført de samme rensetrinnene som i forrige leksjon, og har beregnet `DagIÅret`-kolonnen ved hjelp av følgende uttrykk: 
+
+```python
+day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days)
+```
+
+Nå som du har en forståelse av 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 prisene. Noen som kjøper gresskar til en høstfest kan ha nytte av denne informasjonen for å optimalisere kjøpene sine.
+
+## Lete etter korrelasjon
+
+[![ML for nybegynnere - Lete etter korrelasjon: Nøkkelen til lineær regresjon](https://img.youtube.com/vi/uoRq-lW2eQo/0.jpg)](https://youtu.be/uoRq-lW2eQo "ML for nybegynnere - Lete etter korrelasjon: Nøkkelen til lineær regresjon")
+
+> 🎥 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:
+
+<img alt="Gjennomsnittspris per måned" src="../2-Data/images/barchart.png" width="50%"/>
+
+Dette antyder at det bør være en viss korrelasjon, og vi kan prøve å trene en lineær regresjonsmodell for å forutsi forholdet mellom `Måned` og `Pris`, eller mellom `DagIÅret` og `Pris`. Her er spredningsdiagrammet som viser det sistnevnte forholdet:
+
+<img alt="Spredningsdiagram av pris vs. dag i året" src="images/scatter-dayofyear.png" width="50%" /> 
+
+La oss se om det er en korrelasjon ved hjelp av `corr`-funksjonen:
+
+```python
+print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
+print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
+```
+
+Det ser ut til at korrelasjonen er ganske liten, -0.15 for `Måned` og -0.17 for `DagIÅret`, men det kan være et annet viktig forhold. Det ser ut til at det er forskjellige prisgrupper som tilsvarer ulike gresskarsorter. For å bekrefte denne hypotesen, la oss plotte hver gresskarkategori med en annen farge. Ved å sende en `ax`-parameter til `scatter`-plottefunksjonen kan vi plotte alle punkter på samme graf:
+
+```python
+ax=None
+colors = ['red','blue','green','yellow']
+for i,var in enumerate(new_pumpkins['Variety'].unique()):
+    df = new_pumpkins[new_pumpkins['Variety']==var]
+    ax = df.plot.scatter('DayOfYear','Price',ax=ax,c=colors[i],label=var)
+```
+
+<img alt="Spredningsdiagram av pris vs. dag i året" src="images/scatter-dayofyear-color.png" width="50%" /> 
+
+Vår undersøkelse antyder at sorten har større effekt på den totale prisen enn selve salgsdatoen. Vi kan se dette med et stolpediagram:
+
+```python
+new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
+```
+
+<img alt="Stolpediagram av pris vs. sort" src="images/price-by-variety.png" width="50%" /> 
+
+La oss for øyeblikket fokusere kun på én gresskarsort, 'pie type', og se hvilken effekt datoen har på prisen:
+
+```python
+pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
+pie_pumpkins.plot.scatter('DayOfYear','Price') 
+```
+<img alt="Spredningsdiagram av pris vs. dag i året" src="images/pie-pumpkins-scatter.png" width="50%" /> 
+
+Hvis vi nå beregner korrelasjonen mellom `Pris` og `DagIÅret` ved hjelp av `corr`-funksjonen, vil vi få noe som `-0.27` - noe som betyr at det gir mening å trene en prediktiv modell.
+
+> 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 gir mening å fjerne alle tomme celler:
+
+```python
+pie_pumpkins.dropna(inplace=True)
+pie_pumpkins.info()
+```
+
+En annen tilnærming ville være å fylle de tomme verdiene med gjennomsnittsverdier fra den tilsvarende kolonnen.
+
+## Enkel lineær regresjon
+
+[![ML for nybegynnere - Lineær og polynomisk regresjon med Scikit-learn](https://img.youtube.com/vi/e4c_UP2fSjg/0.jpg)](https://youtu.be/e4c_UP2fSjg "ML for nybegynnere - Lineær og polynomisk regresjon med Scikit-learn")
+
+> 🎥 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.
+
+```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 å skille inngangsverdier (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 pakken for lineær regresjon skulle forstå dem riktig. Lineær regresjon forventer et 2D-array som inngang, 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 formen N×1, hvor N er datasettets størrelse.
+
+Deretter må vi dele dataene inn 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 det bare to linjer med kode å trene den faktiske lineære regresjonsmodellen. Vi definerer `LinearRegression`-objektet og tilpasser det til dataene våre ved hjelp av `fit`-metoden:
+
+```python
+lin_reg = LinearRegression()
+lin_reg.fit(X_train,y_train)
+```
+
+`LinearRegression`-objektet inneholder etter `fit`-prosessen alle koeffisientene for regresjonen, som kan nås ved hjelp av `.coef_`-egenskapen. I vårt tilfelle er det bare én koeffisient, som bør være rundt `-0.017`. Dette betyr at prisene ser ut til å synke litt over tid, men ikke mye, rundt 2 cent per dag. Vi kan også få tilgang til skjæringspunktet med Y-aksen ved hjelp av `lin_reg.intercept_` - det vil være rundt `21` i vårt tilfelle, noe som indikerer prisen ved begynnelsen av året.
+
+For å se hvor nøyaktig modellen vår er, kan vi forutsi priser på et testdatasett og deretter måle hvor nærme forutsigelsene våre er de forventede verdiene. Dette kan gjøres ved hjelp av middelkvadratfeil (MSE)-metrikken, som er gjennomsnittet av alle kvadrerte forskjeller mellom forventet og forutsagt verdi.
+
+```python
+pred = lin_reg.predict(X_test)
+
+mse = np.sqrt(mean_squared_error(y_test,pred))
+print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
+```
+Feilen vår ser ut til å være rundt 2 punkter, som er ~17 %. Ikke så bra. En annen indikator på modellkvalitet er **determinasjonskoeffisienten**, som kan beregnes 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 inputdata, og fungerer som den *dårligste lineære prediktoren*, som bare er gjennomsnittsverdien av resultatet. Verdien 1 betyr at vi kan perfekt forutsi alle forventede utfall. I vårt tilfelle er koeffisienten rundt 0,06, som er ganske lav.
+
+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)
+plt.plot(X_test,pred)
+```
+
+<img alt="Lineær regresjon" src="images/linear-results.png" width="50%" />
+
+## Polynomisk regresjon
+
+En annen type lineær regresjon er polynomisk regresjon. Selv om det noen ganger er en lineær sammenheng mellom variabler - jo større gresskaret er i volum, jo høyere pris - kan det noen ganger være slik at disse sammenhengene ikke kan 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 polynomisk regresjon.
+
+Se en gang til på sammenhengen mellom dato og pris. Ser dette spredningsdiagrammet ut som det nødvendigvis bør analyseres med en rett linje? Kan ikke priser svinge? I dette tilfellet kan du prøve polynomisk regresjon.
+
+✅ Polynomier er matematiske uttrykk som kan bestå av én eller flere variabler og koeffisienter.
+
+Polynomisk regresjon skaper en kurvet linje for bedre å tilpasse seg ikke-lineære data. I vårt tilfelle, hvis vi inkluderer en kvadrert `DayOfYear`-variabel i inputdataene, bør vi kunne tilpasse dataene våre med en parabolsk kurve, som vil ha 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 ulike trinn i databehandlingen. En **pipeline** er en kjede av **estimators**. I vårt tilfelle vil vi lage en pipeline som først legger til polynomiske funksjoner til modellen vår, og deretter trener regresjonen:
+
+```python
+from sklearn.preprocessing import PolynomialFeatures
+from sklearn.pipeline import make_pipeline
+
+pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
+
+pipeline.fit(X_train,y_train)
+```
+
+Ved å bruke `PolynomialFeatures(2)` betyr det at vi vil inkludere alle andregrads polynomier fra inputdataene. I vårt tilfelle vil det bare bety `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 polynomier av høyere grad hvis vi ønsker.
+
+Pipelines kan brukes på samme måte som det opprinnelige `LinearRegression`-objektet, dvs. vi kan `fit` pipelinen, og deretter bruke `predict` for å få prediksjonsresultatene. Her er grafen som viser testdataene og tilnærmingskurven:
+
+<img alt="Polynomisk regresjon" src="images/poly-results.png" width="50%" />
+
+Ved å bruke polynomisk regresjon kan vi få litt lavere MSE og høyere determinasjon, men ikke betydelig. Vi må ta hensyn til andre funksjoner!
+
+> Du kan se at de laveste gresskarprisene observeres et sted rundt Halloween. Hvordan kan du forklare dette?
+
+🎃 Gratulerer, du har nettopp laget en modell som kan hjelpe med å forutsi prisen på pai-gresskar. Du kan sannsynligvis gjenta samme prosedyre for alle gresskartyper, men det ville være tidkrevende. La oss nå lære hvordan vi kan ta gresskarsort i betraktning i modellen vår!
+
+## Kategoriske funksjoner
+
+I en ideell verden ønsker vi å kunne forutsi priser for ulike gresskarsorter ved hjelp av samme modell. Imidlertid er `Variety`-kolonnen litt annerledes enn kolonner som `Month`, fordi den inneholder ikke-numeriske verdier. Slike kolonner kalles **kategoriske**.
+
+[![ML for nybegynnere - Kategoriske funksjoner med lineær regresjon](https://img.youtube.com/vi/DYGliioIAE0/0.jpg)](https://youtu.be/DYGliioIAE0 "ML for nybegynnere - Kategoriske funksjoner med lineær regresjon")
+
+> 🎥 Klikk på bildet over for en kort videooversikt om bruk av kategoriske funksjoner.
+
+Her kan du se hvordan gjennomsnittsprisen avhenger av sort:
+
+<img alt="Gjennomsnittspris etter sort" src="images/price-by-variety.png" width="50%" />
+
+For å ta sort i betraktning, må vi først konvertere den til numerisk form, eller **enkode** den. Det finnes flere måter vi kan gjøre dette på:
+
+* Enkel **numerisk enkoding** vil bygge en tabell over ulike sorter, og deretter erstatte sortnavnet med en indeks i den tabellen. Dette er ikke den beste ideen 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 sammenhengen mellom indeksnummeret og prisen tydelig ikke-lineær, selv om vi sørger for at indeksene er ordnet på en spesifikk måte.
+* **One-hot enkoding** vil erstatte `Variety`-kolonnen med 4 forskjellige kolonner, én for hver sort. Hver kolonne vil inneholde `1` hvis den tilsvarende raden er av en gitt sort, og `0` ellers. Dette betyr at det vil være fire koeffisienter i lineær regresjon, én for hver gresskarsort, som er ansvarlig for "startpris" (eller rettere sagt "tilleggspris") for den spesifikke sorten.
+
+Koden nedenfor viser hvordan vi kan one-hot enkode en sort:
+
+```python
+pd.get_dummies(new_pumpkins['Variety'])
+```
+
+ ID | FAIRYTALE | MINIATURE | MIXED HEIRLOOM VARIETIES | PIE TYPE
+----|-----------|-----------|--------------------------|----------
+70 | 0 | 0 | 0 | 1
+71 | 0 | 0 | 0 | 1
+... | ... | ... | ... | ...
+1738 | 0 | 1 | 0 | 0
+1739 | 0 | 1 | 0 | 0
+1740 | 0 | 1 | 0 | 0
+1741 | 0 | 1 | 0 | 0
+1742 | 0 | 1 | 0 | 0
+
+For å trene lineær regresjon ved bruk av one-hot enkodet sort som input, trenger vi bare å initialisere `X` og `y`-dataene korrekt:
+
+```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 den gjennomsnittlige kvadratiske feilen er omtrent den samme, men vi får en mye høyere determinasjonskoeffisient (~77 %). For å få enda mer nøyaktige prediksjoner kan vi ta flere kategoriske funksjoner i betraktning, samt numeriske funksjoner, som `Month` eller `DayOfYear`. For å få én stor funksjonsmatrise kan vi bruke `join`:
+
+```python
+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']
+```
+
+Her tar vi også hensyn til `City` og `Package`-type, som gir oss MSE 2,84 (10 %) og determinasjon 0,94!
+
+## Alt samlet
+
+For å lage den beste modellen kan vi bruke kombinerte (one-hot enkodede kategoriske + numeriske) data fra eksempelet ovenfor sammen med polynomisk regresjon. Her er den komplette koden for enkelhets skyld:
+
+```python
+# set up training data
+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']
+
+# make train-test split
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
+
+# setup and train the pipeline
+pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
+pipeline.fit(X_train,y_train)
+
+# predict results for test data
+pred = pipeline.predict(X_test)
+
+# calculate MSE and determination
+mse = np.sqrt(mean_squared_error(y_test,pred))
+print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
+
+score = pipeline.score(X_train,y_train)
+print('Model determination: ', score)
+```
+
+Dette bør gi oss den beste determinasjonskoeffisienten på nesten 97 %, og MSE=2,23 (~8 % prediksjonsfeil).
+
+| Modell | MSE | Determinasjon |
+|--------|-----|---------------|
+| `DayOfYear` Lineær | 2,77 (17,2 %) | 0,07 |
+| `DayOfYear` Polynomisk | 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 Polynomisk | 2,23 (8,25 %) | 0,97 |
+
+🏆 Bra jobbet! Du har 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.
+
+---
+## 🚀Utfordring
+
+Test flere forskjellige variabler i denne notatboken for å se hvordan korrelasjon samsvarer med modellens nøyaktighet.
+
+## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+## Gjennomgang og 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 for å lære mer er [Stanford Statistical Learning course](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning).
+
+## Oppgave
+
+[Bygg en modell](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/2-Regression/3-Linear/assignment.md

@@ -0,0 +1,25 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "cc471fa89c293bc735dd3a9a0fb79b1b",
+  "translation_date": "2025-09-05T21:08:34+00:00",
+  "source_file": "2-Regression/3-Linear/assignment.md",
+  "language_code": "no"
+}
+-->
+# Lag en regresjonsmodell
+
+## Instruksjoner
+
+I denne leksjonen lærte du hvordan du bygger en modell ved hjelp av både lineær og polynomisk regresjon. Bruk denne kunnskapen til å finne et datasett eller bruk ett av Scikit-learns innebygde datasett for å lage en ny modell. Forklar i notatboken din hvorfor du valgte teknikken du gjorde, og demonstrer modellens nøyaktighet. Hvis den ikke er nøyaktig, forklar hvorfor.
+
+## Vurderingskriterier
+
+| Kriterier | Eksemplarisk                                               | Tilfredsstillende          | Trenger forbedring             |
+| --------- | ---------------------------------------------------------- | -------------------------- | ------------------------------ |
+|           | presenterer en fullstendig notatbok med en godt dokumentert løsning | løsningen er ufullstendig  | løsningen er mangelfull eller feilaktig |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/2-Regression/3-Linear/solution/Julia/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+  "translation_date": "2025-09-05T21:08:45+00:00",
+  "source_file": "2-Regression/3-Linear/solution/Julia/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/2-Regression/4-Logistic/README.md

@@ -0,0 +1,408 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "abf86d845c84330bce205a46b382ec88",
+  "translation_date": "2025-09-05T21:11:16+00:00",
+  "source_file": "2-Regression/4-Logistic/README.md",
+  "language_code": "no"
+}
+-->
+# Logistisk regresjon for å forutsi kategorier
+
+![Infografikk om logistisk vs. lineær regresjon](../../../../2-Regression/4-Logistic/images/linear-vs-logistic.png)
+
+## [Quiz før forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+> ### [Denne leksjonen er tilgjengelig i R!](../../../../2-Regression/4-Logistic/solution/R/lesson_4.html)
+
+## Introduksjon
+
+I denne siste leksjonen om regresjon, en av de grunnleggende _klassiske_ ML-teknikkene, skal vi se nærmere på logistisk regresjon. Du kan bruke denne teknikken til å oppdage mønstre for å forutsi binære kategorier. Er dette godteri sjokolade eller ikke? Er denne sykdommen smittsom eller ikke? Vil denne kunden velge dette produktet eller ikke?
+
+I denne leksjonen vil du lære:
+
+- Et nytt bibliotek for datavisualisering
+- Teknikker for logistisk regresjon
+
+✅ Fordyp deg i å arbeide med denne typen regresjon i dette [Learn-modulet](https://docs.microsoft.com/learn/modules/train-evaluate-classification-models?WT.mc_id=academic-77952-leestott)
+
+## Forutsetning
+
+Etter å ha jobbet med gresskar-dataene, er vi nå kjent nok med dem til å innse at det finnes én binær kategori vi kan jobbe med: `Color`.
+
+La oss bygge en logistisk regresjonsmodell for å forutsi, gitt noen variabler, _hvilken farge et gitt gresskar sannsynligvis har_ (oransje 🎃 eller hvit 👻).
+
+> Hvorfor snakker vi om binær klassifisering i en leksjon om regresjon? Bare av språklig bekvemmelighet, siden logistisk regresjon [egentlig er en klassifiseringsmetode](https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression), om enn en lineær-basert en. Lær om andre måter å klassifisere data på i neste leksjonsgruppe.
+
+## Definer spørsmålet
+
+For vårt formål vil vi uttrykke dette som en binær: 'Hvit' eller 'Ikke hvit'. Det finnes også en 'stripet' kategori i datasettet vårt, men det er få forekomster av den, så vi vil ikke bruke den. Den forsvinner uansett når vi fjerner nullverdier fra datasettet.
+
+> 🎃 Fun fact: Vi kaller noen ganger hvite gresskar for 'spøkelsesgresskar'. De er ikke veldig lette å skjære ut, så de er ikke like populære som de oransje, men de ser kule ut! Så vi kunne også formulert spørsmålet vårt som: 'Spøkelse' eller 'Ikke spøkelse'. 👻
+
+## Om logistisk regresjon
+
+Logistisk regresjon skiller seg fra lineær regresjon, som du lærte om tidligere, på noen viktige måter.
+
+[![ML for nybegynnere - Forstå logistisk regresjon for maskinlæringsklassifisering](https://img.youtube.com/vi/KpeCT6nEpBY/0.jpg)](https://youtu.be/KpeCT6nEpBY "ML for nybegynnere - Forstå logistisk regresjon for maskinlæringsklassifisering")
+
+> 🎥 Klikk på bildet ovenfor for en kort videooversikt over logistisk regresjon.
+
+### Binær klassifisering
+
+Logistisk regresjon tilbyr ikke de samme funksjonene som lineær regresjon. Den førstnevnte gir en prediksjon om en binær kategori ("hvit eller ikke hvit"), mens den sistnevnte er i stand til å forutsi kontinuerlige verdier, for eksempel gitt opprinnelsen til et gresskar og tidspunktet for innhøstingen, _hvor mye prisen vil stige_.
+
+![Gresskar klassifiseringsmodell](../../../../2-Regression/4-Logistic/images/pumpkin-classifier.png)
+> Infografikk av [Dasani Madipalli](https://twitter.com/dasani_decoded)
+
+### Andre klassifiseringer
+
+Det finnes andre typer logistisk regresjon, inkludert multinomial og ordinal:
+
+- **Multinomial**, som innebærer å ha mer enn én kategori - "Oransje, Hvit og Stripet".
+- **Ordinal**, som innebærer ordnede kategorier, nyttig hvis vi ønsket å ordne resultatene våre logisk, som våre gresskar som er ordnet etter et begrenset antall størrelser (mini, sm, med, lg, xl, xxl).
+
+![Multinomial vs ordinal regresjon](../../../../2-Regression/4-Logistic/images/multinomial-vs-ordinal.png)
+
+### Variabler trenger IKKE å korrelere
+
+Husker du hvordan lineær regresjon fungerte bedre med mer korrelerte variabler? Logistisk regresjon er det motsatte - variablene trenger ikke å samsvare. Dette fungerer for disse dataene som har noe svake korrelasjoner.
+
+### Du trenger mye rene data
+
+Logistisk regresjon gir mer nøyaktige resultater hvis du bruker mer data; vårt lille datasett er ikke optimalt for denne oppgaven, så husk det.
+
+[![ML for nybegynnere - Dataanalyse og forberedelse for logistisk regresjon](https://img.youtube.com/vi/B2X4H9vcXTs/0.jpg)](https://youtu.be/B2X4H9vcXTs "ML for nybegynnere - Dataanalyse og forberedelse for logistisk regresjon")
+
+> 🎥 Klikk på bildet ovenfor for en kort videooversikt over forberedelse av data for lineær regresjon
+
+✅ Tenk på hvilke typer data som egner seg godt for logistisk regresjon
+
+## Øvelse - rydd opp i dataene
+
+Først, rydd opp i dataene litt, fjern nullverdier og velg bare noen av kolonnene:
+
+1. Legg til følgende kode:
+
+    ```python
+  
+    columns_to_select = ['City Name','Package','Variety', 'Origin','Item Size', 'Color']
+    pumpkins = full_pumpkins.loc[:, columns_to_select]
+
+    pumpkins.dropna(inplace=True)
+    ```
+
+    Du kan alltid ta en titt på din nye dataframe:
+
+    ```python
+    pumpkins.info
+    ```
+
+### Visualisering - kategorisk plott
+
+Nå har du lastet opp [startnotatboken](../../../../2-Regression/4-Logistic/notebook.ipynb) med gresskar-data igjen og ryddet den slik at du har et datasett som inneholder noen få variabler, inkludert `Color`. La oss visualisere dataene i notatboken ved hjelp av et annet bibliotek: [Seaborn](https://seaborn.pydata.org/index.html), som er bygget på Matplotlib som vi brukte tidligere.
+
+Seaborn tilbyr noen smarte måter å visualisere dataene dine på. For eksempel kan du sammenligne distribusjoner av dataene for hver `Variety` og `Color` i et kategorisk plott.
+
+1. Lag et slikt plott ved å bruke funksjonen `catplot`, med gresskar-dataene `pumpkins`, og spesifisere en fargekartlegging for hver gresskarkategori (oransje eller hvit):
+
+    ```python
+    import seaborn as sns
+    
+    palette = {
+    'ORANGE': 'orange',
+    'WHITE': 'wheat',
+    }
+
+    sns.catplot(
+    data=pumpkins, y="Variety", hue="Color", kind="count",
+    palette=palette, 
+    )
+    ```
+
+    ![Et rutenett med visualiserte data](../../../../2-Regression/4-Logistic/images/pumpkins_catplot_1.png)
+
+    Ved å observere dataene kan du se hvordan `Color`-dataene relaterer seg til `Variety`.
+
+    ✅ Gitt dette kategoriske plottet, hvilke interessante utforskninger kan du forestille deg?
+
+### Datapreprosessering: funksjons- og etikettkoding
+Datasettet vårt inneholder strengverdier for alle kolonnene. Å jobbe med kategoriske data er intuitivt for mennesker, men ikke for maskiner. Maskinlæringsalgoritmer fungerer godt med tall. Derfor er koding et veldig viktig steg i datapreprosesseringen, siden det lar oss gjøre kategoriske data om til numeriske data, uten å miste informasjon. God koding fører til å bygge en god modell.
+
+For funksjonskoding finnes det to hovedtyper av kodere:
+
+1. Ordinal koder: passer godt for ordinale variabler, som er kategoriske variabler der dataene følger en logisk rekkefølge, som kolonnen `Item Size` i datasettet vårt. Den lager en kartlegging slik at hver kategori representeres av et tall, som er rekkefølgen til kategorien i kolonnen.
+
+    ```python
+    from sklearn.preprocessing import OrdinalEncoder
+
+    item_size_categories = [['sml', 'med', 'med-lge', 'lge', 'xlge', 'jbo', 'exjbo']]
+    ordinal_features = ['Item Size']
+    ordinal_encoder = OrdinalEncoder(categories=item_size_categories)
+    ```
+
+2. Kategorisk koder: passer godt for nominelle variabler, som er kategoriske variabler der dataene ikke følger en logisk rekkefølge, som alle funksjonene bortsett fra `Item Size` i datasettet vårt. Det er en one-hot encoding, som betyr at hver kategori representeres av en binær kolonne: den kodede variabelen er lik 1 hvis gresskaret tilhører den `Variety` og 0 ellers.
+
+    ```python
+    from sklearn.preprocessing import OneHotEncoder
+
+    categorical_features = ['City Name', 'Package', 'Variety', 'Origin']
+    categorical_encoder = OneHotEncoder(sparse_output=False)
+    ```
+Deretter brukes `ColumnTransformer` til å kombinere flere kodere i ett enkelt steg og anvende dem på de riktige kolonnene.
+
+```python
+    from sklearn.compose import ColumnTransformer
+    
+    ct = ColumnTransformer(transformers=[
+        ('ord', ordinal_encoder, ordinal_features),
+        ('cat', categorical_encoder, categorical_features)
+        ])
+    
+    ct.set_output(transform='pandas')
+    encoded_features = ct.fit_transform(pumpkins)
+```
+For å kode etiketten bruker vi scikit-learn-klassen `LabelEncoder`, som er en hjelpeklasse for å normalisere etiketter slik at de bare inneholder verdier mellom 0 og n_classes-1 (her, 0 og 1).
+
+```python
+    from sklearn.preprocessing import LabelEncoder
+
+    label_encoder = LabelEncoder()
+    encoded_label = label_encoder.fit_transform(pumpkins['Color'])
+```
+Når vi har kodet funksjonene og etiketten, kan vi slå dem sammen til en ny dataframe `encoded_pumpkins`.
+
+```python
+    encoded_pumpkins = encoded_features.assign(Color=encoded_label)
+```
+✅ Hva er fordelene med å bruke en ordinal koder for kolonnen `Item Size`?
+
+### Analyser forholdet mellom variabler
+
+Nå som vi har forhåndsprosesserte dataene, kan vi analysere forholdet mellom funksjonene og etiketten for å få en idé om hvor godt modellen vil kunne forutsi etiketten gitt funksjonene.
+Den beste måten å utføre denne typen analyse på er å plotte dataene. Vi bruker igjen Seaborn-funksjonen `catplot` for å visualisere forholdet mellom `Item Size`, `Variety` og `Color` i et kategorisk plott. For å bedre plotte dataene bruker vi den kodede kolonnen `Item Size` og den ukodede kolonnen `Variety`.
+
+```python
+    palette = {
+    'ORANGE': 'orange',
+    'WHITE': 'wheat',
+    }
+    pumpkins['Item Size'] = encoded_pumpkins['ord__Item Size']
+
+    g = sns.catplot(
+        data=pumpkins,
+        x="Item Size", y="Color", row='Variety',
+        kind="box", orient="h",
+        sharex=False, margin_titles=True,
+        height=1.8, aspect=4, palette=palette,
+    )
+    g.set(xlabel="Item Size", ylabel="").set(xlim=(0,6))
+    g.set_titles(row_template="{row_name}")
+```
+![Et kategorisk plott av visualiserte data](../../../../2-Regression/4-Logistic/images/pumpkins_catplot_2.png)
+
+### Bruk et swarm-plott
+
+Siden `Color` er en binær kategori (Hvit eller Ikke), trenger den 'en [spesialisert tilnærming](https://seaborn.pydata.org/tutorial/categorical.html?highlight=bar) til visualisering'. Det finnes andre måter å visualisere forholdet mellom denne kategorien og andre variabler.
+
+Du kan visualisere variabler side om side med Seaborn-plott.
+
+1. Prøv et 'swarm'-plott for å vise distribusjonen av verdier:
+
+    ```python
+    palette = {
+    0: 'orange',
+    1: 'wheat'
+    }
+    sns.swarmplot(x="Color", y="ord__Item Size", data=encoded_pumpkins, palette=palette)
+    ```
+
+    ![Et swarm-plott av visualiserte data](../../../../2-Regression/4-Logistic/images/swarm_2.png)
+
+**Vær oppmerksom**: koden ovenfor kan generere en advarsel, siden Seaborn har problemer med å representere så mange datapunkter i et swarm-plott. En mulig løsning er å redusere størrelsen på markøren ved å bruke parameteren 'size'. Vær imidlertid oppmerksom på at dette påvirker lesbarheten til plottet.
+
+> **🧮 Vis meg matematikken**
+>
+> Logistisk regresjon baserer seg på konseptet 'maksimal sannsynlighet' ved bruk av [sigmoid-funksjoner](https://wikipedia.org/wiki/Sigmoid_function). En 'Sigmoid-funksjon' på et plott ser ut som en 'S'-form. Den tar en verdi og kartlegger den til et sted mellom 0 og 1. Kurven kalles også en 'logistisk kurve'. Formelen ser slik ut:
+>
+> ![logistisk funksjon](../../../../2-Regression/4-Logistic/images/sigmoid.png)
+>
+> der sigmoids midtpunkt befinner seg ved x's 0-punkt, L er kurvens maksimumsverdi, og k er kurvens bratthet. Hvis resultatet av funksjonen er mer enn 0.5, vil etiketten i spørsmålet bli gitt klassen '1' av det binære valget. Hvis ikke, vil den bli klassifisert som '0'.
+
+## Bygg modellen din
+
+Å bygge en modell for å finne disse binære klassifiseringene er overraskende enkelt i Scikit-learn.
+
+[![ML for nybegynnere - Logistisk regresjon for klassifisering av data](https://img.youtube.com/vi/MmZS2otPrQ8/0.jpg)](https://youtu.be/MmZS2otPrQ8 "ML for nybegynnere - Logistisk regresjon for klassifisering av data")
+
+> 🎥 Klikk på bildet ovenfor for en kort videooversikt over å bygge en lineær regresjonsmodell
+
+1. Velg variablene du vil bruke i klassifiseringsmodellen din og del opp trenings- og testsett ved å kalle `train_test_split()`:
+
+    ```python
+    from sklearn.model_selection import train_test_split
+    
+    X = encoded_pumpkins[encoded_pumpkins.columns.difference(['Color'])]
+    y = encoded_pumpkins['Color']
+
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
+    
+    ```
+
+2. Nå kan du trene modellen din ved å kalle `fit()` med treningsdataene dine, og skrive ut resultatet:
+
+    ```python
+    from sklearn.metrics import f1_score, classification_report 
+    from sklearn.linear_model import LogisticRegression
+
+    model = LogisticRegression()
+    model.fit(X_train, y_train)
+    predictions = model.predict(X_test)
+
+    print(classification_report(y_test, predictions))
+    print('Predicted labels: ', predictions)
+    print('F1-score: ', f1_score(y_test, predictions))
+    ```
+
+    Ta en titt på modellens resultattavle. Det er ikke dårlig, med tanke på at du bare har rundt 1000 rader med data:
+
+    ```output
+                       precision    recall  f1-score   support
+    
+                    0       0.94      0.98      0.96       166
+                    1       0.85      0.67      0.75        33
+    
+        accuracy                                0.92       199
+        macro avg           0.89      0.82      0.85       199
+        weighted avg        0.92      0.92      0.92       199
+    
+        Predicted labels:  [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0
+        0 0 0 0 0 1 0 1 0 0 1 0 0 0 0 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+        1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0
+        0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0
+        0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
+        0 0 0 1 0 0 0 0 0 0 0 0 1 1]
+        F1-score:  0.7457627118644068
+    ```
+
+## Bedre forståelse via en forvirringsmatrise
+
+Mens du kan få en resultattavlerapport [termer](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html?highlight=classification_report#sklearn.metrics.classification_report) ved å skrive ut elementene ovenfor, kan du kanskje forstå modellen din bedre ved å bruke en [forvirringsmatrise](https://scikit-learn.org/stable/modules/model_evaluation.html#confusion-matrix) for å hjelpe oss med å forstå hvordan modellen presterer.
+
+> 🎓 En '[forvirringsmatrise](https://wikipedia.org/wiki/Confusion_matrix)' (eller 'feilmatrise') er en tabell som uttrykker modellens sanne vs. falske positive og negative, og dermed måler nøyaktigheten av prediksjonene.
+
+1. For å bruke en forvirringsmatrise, kall `confusion_matrix()`:
+
+    ```python
+    from sklearn.metrics import confusion_matrix
+    confusion_matrix(y_test, predictions)
+    ```
+
+    Ta en titt på modellens forvirringsmatrise:
+
+    ```output
+    array([[162,   4],
+           [ 11,  22]])
+    ```
+
+I Scikit-learn er rader (akse 0) faktiske etiketter og kolonner (akse 1) predikerte etiketter.
+
+|       |   0   |   1   |
+| :---: | :---: | :---: |
+|   0   |  TN   |  FP   |
+|   1   |  FN   |  TP   |
+
+Hva skjer her? La oss si at modellen vår blir bedt om å klassifisere gresskar mellom to binære kategorier, kategori 'hvit' og kategori 'ikke-hvit'.
+
+- Hvis modellen din forutsier et gresskar som ikke hvitt og det faktisk tilhører kategorien 'ikke-hvit', kaller vi det en sann negativ, vist av det øverste venstre tallet.
+- Hvis modellen din forutsier et gresskar som hvitt og det faktisk tilhører kategorien 'ikke-hvit', kaller vi det en falsk negativ, vist av det nederste venstre tallet.
+- Hvis modellen din forutsier et gresskar som ikke hvitt og det faktisk tilhører kategorien 'hvit', kaller vi det en falsk positiv, vist av det øverste høyre tallet.
+- Hvis modellen din forutsier et gresskar som hvitt og det faktisk tilhører kategorien 'hvit', kaller vi det en sann positiv, vist av det nederste høyre tallet.
+
+Som du kanskje har gjettet, er det å foretrekke å ha et større antall sanne positive og sanne negative og et lavere antall falske positive og falske negative, noe som innebærer at modellen presterer bedre.
+Hvordan henger forvirringsmatrisen sammen med presisjon og tilbakekalling? Husk, klassifiseringsrapporten som ble skrevet ut ovenfor viste presisjon (0.85) og tilbakekalling (0.67).
+
+Presisjon = tp / (tp + fp) = 22 / (22 + 4) = 0.8461538461538461
+
+Tilbakekalling = tp / (tp + fn) = 22 / (22 + 11) = 0.6666666666666666
+
+✅ Spørsmål: Ifølge forvirringsmatrisen, hvordan gjorde modellen det? Svar: Ikke dårlig; det er et godt antall sanne negative, men også noen få falske negative.
+
+La oss gå tilbake til begrepene vi så tidligere ved hjelp av forvirringsmatrisens kartlegging av TP/TN og FP/FN:
+
+🎓 Presisjon: TP/(TP + FP) Andelen relevante instanser blant de hentede instansene (f.eks. hvilke etiketter som ble godt merket)
+
+🎓 Tilbakekalling: TP/(TP + FN) Andelen relevante instanser som ble hentet, enten de var godt merket eller ikke
+
+🎓 f1-score: (2 * presisjon * tilbakekalling)/(presisjon + tilbakekalling) Et vektet gjennomsnitt av presisjon og tilbakekalling, der det beste er 1 og det verste er 0
+
+🎓 Støtte: Antall forekomster av hver etikett som ble hentet
+
+🎓 Nøyaktighet: (TP + TN)/(TP + TN + FP + FN) Prosentandelen av etiketter som ble korrekt forutsagt for et utvalg.
+
+🎓 Makro Gjennomsnitt: Beregningen av det uvektede gjennomsnittet av metrikker for hver etikett, uten å ta hensyn til ubalanse i etiketter.
+
+🎓 Vektet Gjennomsnitt: Beregningen av gjennomsnittet av metrikker for hver etikett, som tar hensyn til ubalanse i etiketter ved å vekte dem etter deres støtte (antall sanne instanser for hver etikett).
+
+✅ Kan du tenke deg hvilken metrikk du bør følge med på hvis du vil at modellen din skal redusere antall falske negative?
+
+## Visualiser ROC-kurven for denne modellen
+
+[![ML for nybegynnere - Analyse av logistisk regresjonsytelse med ROC-kurver](https://img.youtube.com/vi/GApO575jTA0/0.jpg)](https://youtu.be/GApO575jTA0 "ML for nybegynnere - Analyse av logistisk regresjonsytelse med ROC-kurver")
+
+
+> 🎥 Klikk på bildet ovenfor for en kort videooversikt over ROC-kurver
+
+La oss gjøre én visualisering til for å se den såkalte 'ROC'-kurven:
+
+```python
+from sklearn.metrics import roc_curve, roc_auc_score
+import matplotlib
+import matplotlib.pyplot as plt
+%matplotlib inline
+
+y_scores = model.predict_proba(X_test)
+fpr, tpr, thresholds = roc_curve(y_test, y_scores[:,1])
+
+fig = plt.figure(figsize=(6, 6))
+plt.plot([0, 1], [0, 1], 'k--')
+plt.plot(fpr, tpr)
+plt.xlabel('False Positive Rate')
+plt.ylabel('True Positive Rate')
+plt.title('ROC Curve')
+plt.show()
+```
+
+Ved hjelp av Matplotlib, plott modellens [Receiving Operating Characteristic](https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html?highlight=roc) eller ROC. ROC-kurver brukes ofte for å få en oversikt over utdataene fra en klassifiserer i form av sanne vs. falske positive. "ROC-kurver har vanligvis sanne positive på Y-aksen, og falske positive på X-aksen." Dermed er brattheten på kurven og avstanden mellom midtlinjen og kurven viktig: du vil ha en kurve som raskt går opp og over linjen. I vårt tilfelle er det falske positive i starten, og deretter går linjen opp og over riktig:
+
+![ROC](../../../../2-Regression/4-Logistic/images/ROC_2.png)
+
+Til slutt, bruk Scikit-learns [`roc_auc_score` API](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_auc_score.html?highlight=roc_auc#sklearn.metrics.roc_auc_score) for å beregne den faktiske 'Area Under the Curve' (AUC):
+
+```python
+auc = roc_auc_score(y_test,y_scores[:,1])
+print(auc)
+```
+Resultatet er `0.9749908725812341`. Siden AUC varierer fra 0 til 1, ønsker du en høy score, ettersom en modell som er 100 % korrekt i sine prediksjoner vil ha en AUC på 1; i dette tilfellet er modellen _ganske god_. 
+
+I fremtidige leksjoner om klassifiseringer vil du lære hvordan du kan iterere for å forbedre modellens resultater. Men for nå, gratulerer! Du har fullført disse regresjonsleksjonene!
+
+---
+## 🚀Utfordring
+
+Det er mye mer å utforske når det gjelder logistisk regresjon! Men den beste måten å lære på er å eksperimentere. Finn et datasett som egner seg til denne typen analyse og bygg en modell med det. Hva lærer du? tips: prøv [Kaggle](https://www.kaggle.com/search?q=logistic+regression+datasets) for interessante datasett.
+
+## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+## Gjennomgang & Selvstudium
+
+Les de første sidene av [denne artikkelen fra Stanford](https://web.stanford.edu/~jurafsky/slp3/5.pdf) om noen praktiske bruksområder for logistisk regresjon. Tenk på oppgaver som egner seg bedre for den ene eller den andre typen regresjonsoppgaver som vi har studert så langt. Hva ville fungert best?
+
+## Oppgave 
+
+[Prøv denne regresjonen på nytt](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/2-Regression/4-Logistic/assignment.md

@@ -0,0 +1,25 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "8af40209a41494068c1f42b14c0b450d",
+  "translation_date": "2025-09-05T21:12:13+00:00",
+  "source_file": "2-Regression/4-Logistic/assignment.md",
+  "language_code": "no"
+}
+-->
+# Prøve på nytt med regresjon
+
+## Instruksjoner
+
+I leksjonen brukte du et utvalg av gresskar-dataene. Nå skal du gå tilbake til de originale dataene og prøve å bruke alt, renset og standardisert, for å bygge en logistisk regresjonsmodell.
+
+## Vurderingskriterier
+
+| Kriterier | Fremragende                                                            | Tilfredsstillende                                            | Trenger forbedring                                          |
+| --------- | ---------------------------------------------------------------------- | ------------------------------------------------------------ | ----------------------------------------------------------- |
+|           | En notebook presenteres med en godt forklart og velfungerende modell   | En notebook presenteres med en modell som fungerer minimalt  | En notebook presenteres med en modell som fungerer dårlig eller ingen modell |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/2-Regression/4-Logistic/solution/Julia/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+  "translation_date": "2025-09-05T21:12:24+00:00",
+  "source_file": "2-Regression/4-Logistic/solution/Julia/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/2-Regression/README.md

@@ -0,0 +1,54 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "508582278dbb8edd2a8a80ac96ef416c",
+  "translation_date": "2025-09-05T21:05:04+00:00",
+  "source_file": "2-Regression/README.md",
+  "language_code": "no"
+}
+-->
+# Regresjonsmodeller for maskinlæring
+## Regionalt tema: Regresjonsmodeller for gresskarpriser i Nord-Amerika 🎃
+
+I Nord-Amerika blir gresskar ofte skåret ut til skumle ansikter for Halloween. La oss utforske mer om disse fascinerende grønnsakene!
+
+![jack-o-lanterns](../../../2-Regression/images/jack-o-lanterns.jpg)
+> Foto av <a href="https://unsplash.com/@teutschmann?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Beth Teutschmann</a> på <a href="https://unsplash.com/s/photos/jack-o-lanterns?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
+  
+## Hva du vil lære
+
+[![Introduksjon til regresjon](https://img.youtube.com/vi/5QnJtDad4iQ/0.jpg)](https://youtu.be/5QnJtDad4iQ "Introduksjonsvideo om regresjon - Klikk for å se!")
+> 🎥 Klikk på bildet over for en rask introduksjonsvideo til denne leksjonen
+
+Leksjonene i denne delen dekker typer regresjon i konteksten av maskinlæring. Regresjonsmodeller kan hjelpe med å bestemme _forholdet_ mellom variabler. Denne typen modell kan forutsi verdier som lengde, temperatur eller alder, og dermed avdekke sammenhenger mellom variabler mens den analyserer datapunkter.
+
+I denne serien av leksjoner vil du oppdage forskjellene mellom lineær og logistisk regresjon, og når du bør velge den ene fremfor den andre.
+
+[![ML for nybegynnere - Introduksjon til regresjonsmodeller for maskinlæring](https://img.youtube.com/vi/XA3OaoW86R8/0.jpg)](https://youtu.be/XA3OaoW86R8 "ML for nybegynnere - Introduksjon til regresjonsmodeller for maskinlæring")
+
+> 🎥 Klikk på bildet over for en kort video som introduserer regresjonsmodeller.
+
+I denne gruppen av leksjoner vil du bli satt opp for å begynne med maskinlæringsoppgaver, inkludert konfigurering av Visual Studio Code for å administrere notebooks, det vanlige miljøet for dataforskere. Du vil oppdage Scikit-learn, et bibliotek for maskinlæring, og du vil bygge dine første modeller, med fokus på regresjonsmodeller i dette kapittelet.
+
+> Det finnes nyttige lavkodeverktøy som kan hjelpe deg med å lære om arbeid med regresjonsmodeller. Prøv [Azure ML for denne oppgaven](https://docs.microsoft.com/learn/modules/create-regression-model-azure-machine-learning-designer/?WT.mc_id=academic-77952-leestott)
+
+### Leksjoner
+
+1. [Verktøyene du trenger](1-Tools/README.md)
+2. [Administrere data](2-Data/README.md)
+3. [Lineær og polynomisk regresjon](3-Linear/README.md)
+4. [Logistisk regresjon](4-Logistic/README.md)
+
+---
+### Krediteringer
+
+"ML med regresjon" ble skrevet med ♥️ av [Jen Looper](https://twitter.com/jenlooper)
+
+♥️ Quiz-bidragsytere inkluderer: [Muhammad Sakib Khan Inan](https://twitter.com/Sakibinan) og [Ornella Altunyan](https://twitter.com/ornelladotcom)
+
+Gresskardatasettet er foreslått av [dette prosjektet på Kaggle](https://www.kaggle.com/usda/a-year-of-pumpkin-prices), og dets data er hentet fra [Specialty Crops Terminal Markets Standard Reports](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) distribuert av United States Department of Agriculture. Vi har lagt til noen punkter rundt farge basert på variasjon for å normalisere distribusjonen. Disse dataene er i det offentlige domene.
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/3-Web-App/1-Web-App/README.md

@@ -0,0 +1,359 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "e0b75f73e4a90d45181dc5581fe2ef5c",
+  "translation_date": "2025-09-05T21:47:31+00:00",
+  "source_file": "3-Web-App/1-Web-App/README.md",
+  "language_code": "no"
+}
+-->
+# Bygg en webapplikasjon for å bruke en ML-modell
+
+I denne leksjonen skal du trene en ML-modell på et datasett som er helt utenomjordisk: _UFO-observasjoner fra det siste århundret_, hentet fra NUFORCs database.
+
+Du vil lære:
+
+- Hvordan 'pickle' en trent modell
+- Hvordan bruke den modellen i en Flask-applikasjon
+
+Vi fortsetter å bruke notebooks for å rense data og trene modellen vår, men du kan ta prosessen et steg videre ved å utforske hvordan man bruker en modell "ute i det fri", så å si: i en webapplikasjon.
+
+For å gjøre dette må du bygge en webapplikasjon ved hjelp av Flask.
+
+## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
+
+## Bygge en applikasjon
+
+Det finnes flere måter å bygge webapplikasjoner som kan bruke maskinlæringsmodeller. Din webarkitektur kan påvirke hvordan modellen din blir trent. Tenk deg at du jobber i en bedrift der data science-gruppen har trent en modell som de vil at du skal bruke i en applikasjon.
+
+### Vurderinger
+
+Det er mange spørsmål du må stille:
+
+- **Er det en webapplikasjon eller en mobilapplikasjon?** Hvis du bygger en mobilapplikasjon eller trenger å bruke modellen i en IoT-sammenheng, kan du bruke [TensorFlow Lite](https://www.tensorflow.org/lite/) og bruke modellen i en Android- eller iOS-applikasjon.
+- **Hvor skal modellen ligge?** I skyen eller lokalt?
+- **Støtte for offline bruk.** Må applikasjonen fungere offline?
+- **Hvilken teknologi ble brukt til å trene modellen?** Den valgte teknologien kan påvirke verktøyene du må bruke.
+    - **Bruke TensorFlow.** Hvis du trener en modell med TensorFlow, for eksempel, gir det økosystemet muligheten til å konvertere en TensorFlow-modell for bruk i en webapplikasjon ved hjelp av [TensorFlow.js](https://www.tensorflow.org/js/).
+    - **Bruke PyTorch.** Hvis du bygger en modell med et bibliotek som [PyTorch](https://pytorch.org/), har du muligheten til å eksportere den i [ONNX](https://onnx.ai/) (Open Neural Network Exchange)-format for bruk i JavaScript-webapplikasjoner som kan bruke [Onnx Runtime](https://www.onnxruntime.ai/). Denne muligheten vil bli utforsket i en fremtidig leksjon for en Scikit-learn-trent modell.
+    - **Bruke Lobe.ai eller Azure Custom Vision.** Hvis du bruker et ML SaaS (Software as a Service)-system som [Lobe.ai](https://lobe.ai/) eller [Azure Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77952-leestott) for å trene en modell, gir denne typen programvare måter å eksportere modellen for mange plattformer, inkludert å bygge en skreddersydd API som kan forespørres i skyen av din online-applikasjon.
+
+Du har også muligheten til å bygge en hel Flask-webapplikasjon som kan trene modellen selv i en nettleser. Dette kan også gjøres ved hjelp av TensorFlow.js i en JavaScript-sammenheng.
+
+For vårt formål, siden vi har jobbet med Python-baserte notebooks, la oss utforske trinnene du må ta for å eksportere en trent modell fra en slik notebook til et format som kan leses av en Python-bygget webapplikasjon.
+
+## Verktøy
+
+For denne oppgaven trenger du to verktøy: Flask og Pickle, begge som kjører på Python.
+
+✅ Hva er [Flask](https://palletsprojects.com/p/flask/)? Definert som et 'mikro-rammeverk' av sine skapere, gir Flask de grunnleggende funksjonene til webrammeverk ved bruk av Python og en templatemotor for å bygge nettsider. Ta en titt på [denne læringsmodulen](https://docs.microsoft.com/learn/modules/python-flask-build-ai-web-app?WT.mc_id=academic-77952-leestott) for å øve på å bygge med Flask.
+
+✅ Hva er [Pickle](https://docs.python.org/3/library/pickle.html)? Pickle 🥒 er et Python-modul som serialiserer og de-serialiserer en Python-objektstruktur. Når du 'pickler' en modell, serialiserer eller flater du ut strukturen dens for bruk på nettet. Vær forsiktig: pickle er ikke iboende sikkert, så vær forsiktig hvis du blir bedt om å 'un-pickle' en fil. En picklet fil har suffikset `.pkl`.
+
+## Øvelse - rense dataene dine
+
+I denne leksjonen skal du bruke data fra 80,000 UFO-observasjoner, samlet av [NUFORC](https://nuforc.org) (The National UFO Reporting Center). Disse dataene har noen interessante beskrivelser av UFO-observasjoner, for eksempel:
+
+- **Lang beskrivelse.** "En mann kommer ut fra en lysstråle som skinner på en gresslette om natten, og han løper mot Texas Instruments parkeringsplass".
+- **Kort beskrivelse.** "lysene jaget oss".
+
+Regnearket [ufos.csv](../../../../3-Web-App/1-Web-App/data/ufos.csv) inkluderer kolonner om `city`, `state` og `country` der observasjonen fant sted, objektets `shape` og dets `latitude` og `longitude`.
+
+I den tomme [notebook](../../../../3-Web-App/1-Web-App/notebook.ipynb) som er inkludert i denne leksjonen:
+
+1. importer `pandas`, `matplotlib` og `numpy` som du gjorde i tidligere leksjoner, og importer UFO-regnearket. Du kan ta en titt på et eksempel på datasettet:
+
+    ```python
+    import pandas as pd
+    import numpy as np
+    
+    ufos = pd.read_csv('./data/ufos.csv')
+    ufos.head()
+    ```
+
+1. Konverter UFO-dataene til en liten dataframe med nye titler. Sjekk de unike verdiene i `Country`-feltet.
+
+    ```python
+    ufos = pd.DataFrame({'Seconds': ufos['duration (seconds)'], 'Country': ufos['country'],'Latitude': ufos['latitude'],'Longitude': ufos['longitude']})
+    
+    ufos.Country.unique()
+    ```
+
+1. Nå kan du redusere mengden data vi trenger å håndtere ved å fjerne eventuelle nullverdier og kun importere observasjoner mellom 1-60 sekunder:
+
+    ```python
+    ufos.dropna(inplace=True)
+    
+    ufos = ufos[(ufos['Seconds'] >= 1) & (ufos['Seconds'] <= 60)]
+    
+    ufos.info()
+    ```
+
+1. Importer Scikit-learns `LabelEncoder`-bibliotek for å konvertere tekstverdier for land til et tall:
+
+    ✅ LabelEncoder koder data alfabetisk
+
+    ```python
+    from sklearn.preprocessing import LabelEncoder
+    
+    ufos['Country'] = LabelEncoder().fit_transform(ufos['Country'])
+    
+    ufos.head()
+    ```
+
+    Dataene dine bør se slik ut:
+
+    ```output
+    	Seconds	Country	Latitude	Longitude
+    2	20.0	3		53.200000	-2.916667
+    3	20.0	4		28.978333	-96.645833
+    14	30.0	4		35.823889	-80.253611
+    23	60.0	4		45.582778	-122.352222
+    24	3.0		3		51.783333	-0.783333
+    ```
+
+## Øvelse - bygg modellen din
+
+Nå kan du gjøre deg klar til å trene en modell ved å dele dataene inn i trenings- og testgrupper.
+
+1. Velg de tre funksjonene du vil trene på som din X-vektor, og y-vektoren vil være `Country`. Du vil kunne legge inn `Seconds`, `Latitude` og `Longitude` og få en land-ID tilbake.
+
+    ```python
+    from sklearn.model_selection import train_test_split
+    
+    Selected_features = ['Seconds','Latitude','Longitude']
+    
+    X = ufos[Selected_features]
+    y = ufos['Country']
+    
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
+    ```
+
+1. Tren modellen din ved hjelp av logistisk regresjon:
+
+    ```python
+    from sklearn.metrics import accuracy_score, classification_report
+    from sklearn.linear_model import LogisticRegression
+    model = LogisticRegression()
+    model.fit(X_train, y_train)
+    predictions = model.predict(X_test)
+    
+    print(classification_report(y_test, predictions))
+    print('Predicted labels: ', predictions)
+    print('Accuracy: ', accuracy_score(y_test, predictions))
+    ```
+
+Nøyaktigheten er ikke dårlig **(rundt 95%)**, ikke overraskende, siden `Country` og `Latitude/Longitude` korrelerer.
+
+Modellen du opprettet er ikke veldig revolusjonerende, siden du burde kunne utlede et `Country` fra dets `Latitude` og `Longitude`, men det er en god øvelse å prøve å trene fra rådata som du renset, eksporterte, og deretter bruke denne modellen i en webapplikasjon.
+
+## Øvelse - 'pickle' modellen din
+
+Nå er det på tide å _pickle_ modellen din! Du kan gjøre det med noen få linjer kode. Når den er _picklet_, last inn den picklete modellen og test den mot et eksempeldataarray som inneholder verdier for sekunder, breddegrad og lengdegrad.
+
+```python
+import pickle
+model_filename = 'ufo-model.pkl'
+pickle.dump(model, open(model_filename,'wb'))
+
+model = pickle.load(open('ufo-model.pkl','rb'))
+print(model.predict([[50,44,-12]]))
+```
+
+Modellen returnerer **'3'**, som er landkoden for Storbritannia. Utrolig! 👽
+
+## Øvelse - bygg en Flask-applikasjon
+
+Nå kan du bygge en Flask-applikasjon for å kalle modellen din og returnere lignende resultater, men på en mer visuelt tiltalende måte.
+
+1. Start med å opprette en mappe kalt **web-app** ved siden av _notebook.ipynb_-filen der _ufo-model.pkl_-filen ligger.
+
+1. I den mappen opprett tre flere mapper: **static**, med en mappe **css** inni, og **templates**. Du bør nå ha følgende filer og kataloger:
+
+    ```output
+    web-app/
+      static/
+        css/
+      templates/
+    notebook.ipynb
+    ufo-model.pkl
+    ```
+
+    ✅ Se løsningsmappen for en visning av den ferdige applikasjonen
+
+1. Den første filen du oppretter i _web-app_-mappen er **requirements.txt**-filen. Som _package.json_ i en JavaScript-applikasjon, lister denne filen opp avhengigheter som kreves av applikasjonen. I **requirements.txt** legg til linjene:
+
+    ```text
+    scikit-learn
+    pandas
+    numpy
+    flask
+    ```
+
+1. Nå, kjør denne filen ved å navigere til _web-app_:
+
+    ```bash
+    cd web-app
+    ```
+
+1. I terminalen din, skriv `pip install` for å installere bibliotekene som er oppført i _requirements.txt_:
+
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+1. Nå er du klar til å opprette tre flere filer for å fullføre applikasjonen:
+
+    1. Opprett **app.py** i roten.
+    2. Opprett **index.html** i _templates_-katalogen.
+    3. Opprett **styles.css** i _static/css_-katalogen.
+
+1. Bygg ut _styles.css_-filen med noen få stiler:
+
+    ```css
+    body {
+    	width: 100%;
+    	height: 100%;
+    	font-family: 'Helvetica';
+    	background: black;
+    	color: #fff;
+    	text-align: center;
+    	letter-spacing: 1.4px;
+    	font-size: 30px;
+    }
+    
+    input {
+    	min-width: 150px;
+    }
+    
+    .grid {
+    	width: 300px;
+    	border: 1px solid #2d2d2d;
+    	display: grid;
+    	justify-content: center;
+    	margin: 20px auto;
+    }
+    
+    .box {
+    	color: #fff;
+    	background: #2d2d2d;
+    	padding: 12px;
+    	display: inline-block;
+    }
+    ```
+
+1. Deretter bygger du ut _index.html_-filen:
+
+    ```html
+    <!DOCTYPE html>
+    <html>
+      <head>
+        <meta charset="UTF-8">
+        <title>🛸 UFO Appearance Prediction! 👽</title>
+        <link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
+      </head>
+    
+      <body>
+        <div class="grid">
+    
+          <div class="box">
+    
+            <p>According to the number of seconds, latitude and longitude, which country is likely to have reported seeing a UFO?</p>
+    
+            <form action="{{ url_for('predict')}}" method="post">
+              <input type="number" name="seconds" placeholder="Seconds" required="required" min="0" max="60" />
+              <input type="text" name="latitude" placeholder="Latitude" required="required" />
+              <input type="text" name="longitude" placeholder="Longitude" required="required" />
+              <button type="submit" class="btn">Predict country where the UFO is seen</button>
+            </form>
+    
+            <p>{{ prediction_text }}</p>
+    
+          </div>
+    
+        </div>
+    
+      </body>
+    </html>
+    ```
+
+    Ta en titt på templatingen i denne filen. Legg merke til 'mustache'-syntaksen rundt variabler som vil bli levert av applikasjonen, som prediksjonsteksten: `{{}}`. Det er også et skjema som sender en prediksjon til `/predict`-ruten.
+
+    Til slutt er du klar til å bygge Python-filen som driver forbruket av modellen og visningen av prediksjoner:
+
+1. I `app.py` legg til:
+
+    ```python
+    import numpy as np
+    from flask import Flask, request, render_template
+    import pickle
+    
+    app = Flask(__name__)
+    
+    model = pickle.load(open("./ufo-model.pkl", "rb"))
+    
+    
+    @app.route("/")
+    def home():
+        return render_template("index.html")
+    
+    
+    @app.route("/predict", methods=["POST"])
+    def predict():
+    
+        int_features = [int(x) for x in request.form.values()]
+        final_features = [np.array(int_features)]
+        prediction = model.predict(final_features)
+    
+        output = prediction[0]
+    
+        countries = ["Australia", "Canada", "Germany", "UK", "US"]
+    
+        return render_template(
+            "index.html", prediction_text="Likely country: {}".format(countries[output])
+        )
+    
+    
+    if __name__ == "__main__":
+        app.run(debug=True)
+    ```
+
+    > 💡 Tips: når du legger til [`debug=True`](https://www.askpython.com/python-modules/flask/flask-debug-mode) mens du kjører webapplikasjonen ved hjelp av Flask, vil eventuelle endringer du gjør i applikasjonen bli reflektert umiddelbart uten behov for å starte serveren på nytt. Vær oppmerksom! Ikke aktiver denne modusen i en produksjonsapplikasjon.
+
+Hvis du kjører `python app.py` eller `python3 app.py` - starter webserveren din opp lokalt, og du kan fylle ut et kort skjema for å få svar på ditt brennende spørsmål om hvor UFO-er har blitt observert!
+
+Før du gjør det, ta en titt på delene av `app.py`:
+
+1. Først lastes avhengighetene og applikasjonen starter.
+1. Deretter importeres modellen.
+1. Deretter rendres index.html på hjemmeruten.
+
+På `/predict`-ruten skjer flere ting når skjemaet sendes inn:
+
+1. Skjemavariablene samles og konverteres til et numpy-array. De sendes deretter til modellen, og en prediksjon returneres.
+2. Landene som vi ønsker skal vises, rendres på nytt som lesbar tekst fra deres predikerte landkode, og den verdien sendes tilbake til index.html for å bli rendret i templaten.
+
+Å bruke en modell på denne måten, med Flask og en picklet modell, er relativt enkelt. Det vanskeligste er å forstå hvilken form dataene må ha for å bli sendt til modellen for å få en prediksjon. Det avhenger helt av hvordan modellen ble trent. Denne har tre datapunkter som må legges inn for å få en prediksjon.
+
+I en profesjonell setting kan du se hvor viktig god kommunikasjon er mellom de som trener modellen og de som bruker den i en web- eller mobilapplikasjon. I vårt tilfelle er det bare én person, deg!
+
+---
+
+## 🚀 Utfordring
+
+I stedet for å jobbe i en notebook og importere modellen til Flask-applikasjonen, kan du trene modellen direkte i Flask-applikasjonen! Prøv å konvertere Python-koden din i notebooken, kanskje etter at dataene dine er renset, for å trene modellen fra applikasjonen på en rute kalt `train`. Hva er fordeler og ulemper med å bruke denne metoden?
+
+## [Quiz etter leksjonen](https://ff-quizzes.netlify.app/en/ml/)
+
+## Gjennomgang og selvstudium
+
+Det finnes mange måter å bygge en webapplikasjon for å bruke ML-modeller. Lag en liste over måtene du kan bruke JavaScript eller Python til å bygge en webapplikasjon som utnytter maskinlæring. Tenk på arkitektur: bør modellen bli værende i applikasjonen eller ligge i skyen? Hvis det siste, hvordan ville du få tilgang til den? Tegn opp en arkitekturmodell for en anvendt ML-webløsning.
+
+## Oppgave
+
+[Prøv en annen modell](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/3-Web-App/1-Web-App/assignment.md

@@ -0,0 +1,25 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "a8e8ae10be335cbc745b75ee552317ff",
+  "translation_date": "2025-09-05T21:48:15+00:00",
+  "source_file": "3-Web-App/1-Web-App/assignment.md",
+  "language_code": "no"
+}
+-->
+# Prøv en annen modell
+
+## Instruksjoner
+
+Nå som du har bygget en webapplikasjon ved hjelp av en trent regresjonsmodell, bruk en av modellene fra en tidligere leksjon om regresjon for å lage denne webapplikasjonen på nytt. Du kan beholde stilen eller designe den annerledes for å reflektere gresskar-dataene. Vær nøye med å endre inputene slik at de samsvarer med treningsmetoden til modellen din.
+
+## Vurderingskriterier
+
+| Kriterier                 | Fremragende                                              | Tilfredsstillende                                        | Trenger forbedring                  |
+| -------------------------- | ------------------------------------------------------- | ------------------------------------------------------- | ------------------------------------ |
+| | Webapplikasjonen fungerer som forventet og er distribuert i skyen | Webapplikasjonen har feil eller gir uventede resultater | Webapplikasjonen fungerer ikke som den skal |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/3-Web-App/README.md

@@ -0,0 +1,35 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "9836ff53cfef716ddfd70e06c5f43436",
+  "translation_date": "2025-09-05T21:46:21+00:00",
+  "source_file": "3-Web-App/README.md",
+  "language_code": "no"
+}
+-->
+# Bygg en nettapp for å bruke din ML-modell
+
+I denne delen av læreplanen vil du bli introdusert til et praktisk ML-tema: hvordan du lagrer din Scikit-learn-modell som en fil som kan brukes til å gjøre prediksjoner i en nettapplikasjon. Når modellen er lagret, vil du lære hvordan du bruker den i en nettapp bygget med Flask. Du vil først lage en modell ved hjelp av data som handler om UFO-observasjoner! Deretter vil du bygge en nettapp som lar deg skrive inn et antall sekunder sammen med en breddegrad og en lengdegrad for å forutsi hvilket land som rapporterte å ha sett en UFO.
+
+![UFO Parkering](../../../3-Web-App/images/ufo.jpg)
+
+Foto av <a href="https://unsplash.com/@mdherren?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Michael Herren</a> på <a href="https://unsplash.com/s/photos/ufo?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
+
+## Leksjoner
+
+1. [Bygg en nettapp](1-Web-App/README.md)
+
+## Krediteringer
+
+"Bygg en nettapp" ble skrevet med ♥️ av [Jen Looper](https://twitter.com/jenlooper).
+
+♥️ Quizene ble skrevet av Rohan Raj.
+
+Datasettet er hentet fra [Kaggle](https://www.kaggle.com/NUFORC/ufo-sightings).
+
+Arkitekturen for nettappen ble delvis foreslått av [denne artikkelen](https://towardsdatascience.com/how-to-easily-deploy-machine-learning-models-using-flask-b95af8fe34d4) og [denne repoen](https://github.com/abhinavsagar/machine-learning-deployment) av Abhinav Sagar.
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/4-Classification/1-Introduction/README.md

@@ -0,0 +1,313 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "aaf391d922bd6de5efba871d514c6d47",
+  "translation_date": "2025-09-05T21:55:45+00:00",
+  "source_file": "4-Classification/1-Introduction/README.md",
+  "language_code": "no"
+}
+-->
+# Introduksjon til klassifisering
+
+I disse fire leksjonene skal du utforske et grunnleggende fokusområde innen klassisk maskinlæring - _klassifisering_. Vi skal gå gjennom bruken av ulike klassifiseringsalgoritmer med et datasett om alle de fantastiske kjøkkenene i Asia og India. Håper du er sulten!
+
+![bare en klype!](../../../../4-Classification/1-Introduction/images/pinch.png)
+
+> Feir pan-asiatiske kjøkken i disse leksjonene! Bilde av [Jen Looper](https://twitter.com/jenlooper)
+
+Klassifisering er en form for [supervised learning](https://wikipedia.org/wiki/Supervised_learning) som har mye til felles med regresjonsteknikker. Hvis maskinlæring handler om å forutsi verdier eller navn på ting ved hjelp av datasett, faller klassifisering generelt inn i to grupper: _binær klassifisering_ og _multiklasse klassifisering_.
+
+[![Introduksjon til klassifisering](https://img.youtube.com/vi/eg8DJYwdMyg/0.jpg)](https://youtu.be/eg8DJYwdMyg "Introduksjon til klassifisering")
+
+> 🎥 Klikk på bildet over for en video: MITs John Guttag introduserer klassifisering
+
+Husk:
+
+- **Lineær regresjon** hjalp deg med å forutsi forholdet mellom variabler og lage nøyaktige spådommer om hvor et nytt datapunkt ville falle i forhold til den linjen. For eksempel kunne du forutsi _hva prisen på et gresskar ville være i september vs. desember_.
+- **Logistisk regresjon** hjalp deg med å oppdage "binære kategorier": ved dette prisnivået, _er dette gresskaret oransje eller ikke-oransje_?
+
+Klassifisering bruker ulike algoritmer for å bestemme andre måter å avgjøre en datapunktopps etikett eller klasse. La oss jobbe med dette matlagingsdatasettet for å se om vi, ved å observere en gruppe ingredienser, kan avgjøre hvilket kjøkken de tilhører.
+
+## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
+
+> ### [Denne leksjonen er tilgjengelig i R!](../../../../4-Classification/1-Introduction/solution/R/lesson_10.html)
+
+### Introduksjon
+
+Klassifisering er en av de grunnleggende aktivitetene for maskinlæringsforskere og dataforskere. Fra enkel klassifisering av en binær verdi ("er denne e-posten spam eller ikke?"), til kompleks bildeklassifisering og segmentering ved hjelp av datamaskinsyn, er det alltid nyttig å kunne sortere data i klasser og stille spørsmål om det.
+
+For å formulere prosessen på en mer vitenskapelig måte, skaper klassifiseringsmetoden din en prediktiv modell som gjør det mulig å kartlegge forholdet mellom inputvariabler og outputvariabler.
+
+![binær vs. multiklasse klassifisering](../../../../4-Classification/1-Introduction/images/binary-multiclass.png)
+
+> Binære vs. multiklasse problemer for klassifiseringsalgoritmer å håndtere. Infografikk av [Jen Looper](https://twitter.com/jenlooper)
+
+Før vi starter prosessen med å rense dataene våre, visualisere dem og forberede dem for våre ML-oppgaver, la oss lære litt om de ulike måtene maskinlæring kan brukes til å klassifisere data.
+
+Avledet fra [statistikk](https://wikipedia.org/wiki/Statistical_classification), bruker klassifisering med klassisk maskinlæring funksjoner som `smoker`, `weight` og `age` for å avgjøre _sannsynligheten for å utvikle X sykdom_. Som en supervised learning-teknikk, lik de regresjonsøvelsene du utførte tidligere, er dataene dine merket, og ML-algoritmene bruker disse merkene til å klassifisere og forutsi klasser (eller 'funksjoner') i et datasett og tilordne dem til en gruppe eller et utfall.
+
+✅ Ta et øyeblikk til å forestille deg et datasett om matretter. Hva ville en multiklassemodell kunne svare på? Hva ville en binær modell kunne svare på? Hva om du ville avgjøre om en gitt matrett sannsynligvis bruker bukkehornkløver? Hva om du ville se om du, gitt en pose med stjerneanis, artisjokker, blomkål og pepperrot, kunne lage en typisk indisk rett?
+
+[![Gale mysteriekurver](https://img.youtube.com/vi/GuTeDbaNoEU/0.jpg)](https://youtu.be/GuTeDbaNoEU "Gale mysteriekurver")
+
+> 🎥 Klikk på bildet over for en video. Hele premisset for showet 'Chopped' er 'mystery basket', der kokker må lage en rett ut av et tilfeldig utvalg ingredienser. Sikkert en ML-modell ville ha hjulpet!
+
+## Hei 'klassifiserer'
+
+Spørsmålet vi ønsker å stille til dette matlagingsdatasettet er faktisk et **multiklasse-spørsmål**, siden vi har flere potensielle nasjonale kjøkken å jobbe med. Gitt en gruppe ingredienser, hvilken av disse mange klassene passer dataene inn i?
+
+Scikit-learn tilbyr flere forskjellige algoritmer for å klassifisere data, avhengig av hvilken type problem du vil løse. I de neste to leksjonene skal du lære om flere av disse algoritmene.
+
+## Øvelse - rens og balanser dataene dine
+
+Den første oppgaven, før du starter dette prosjektet, er å rense og **balansere** dataene dine for å få bedre resultater. Start med den tomme _notebook.ipynb_-filen i roten av denne mappen.
+
+Det første du må installere er [imblearn](https://imbalanced-learn.org/stable/). Dette er en Scikit-learn-pakke som lar deg bedre balansere dataene (du vil lære mer om denne oppgaven om et øyeblikk).
+
+1. For å installere `imblearn`, kjør `pip install`, slik:
+
+    ```python
+    pip install imblearn
+    ```
+
+1. Importer pakkene du trenger for å importere dataene dine og visualisere dem, og importer også `SMOTE` fra `imblearn`.
+
+    ```python
+    import pandas as pd
+    import matplotlib.pyplot as plt
+    import matplotlib as mpl
+    import numpy as np
+    from imblearn.over_sampling import SMOTE
+    ```
+
+    Nå er du klar til å lese og importere dataene.
+
+1. Den neste oppgaven vil være å importere dataene:
+
+    ```python
+    df  = pd.read_csv('../data/cuisines.csv')
+    ```
+
+   Ved å bruke `read_csv()` vil innholdet i csv-filen _cusines.csv_ bli lest og plassert i variabelen `df`.
+
+1. Sjekk formen på dataene:
+
+    ```python
+    df.head()
+    ```
+
+   De første fem radene ser slik ut:
+
+    ```output
+    |     | Unnamed: 0 | cuisine | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood | yam | yeast | yogurt | zucchini |
+    | --- | ---------- | ------- | ------ | -------- | ----- | ---------- | ----- | ------------ | ------- | -------- | --- | ------- | ----------- | ---------- | ----------------------- | ---- | ---- | --- | ----- | ------ | -------- |
+    | 0   | 65         | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
+    | 1   | 66         | indian  | 1      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
+    | 2   | 67         | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
+    | 3   | 68         | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
+    | 4   | 69         | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 1      | 0        |
+    ```
+
+1. Få informasjon om disse dataene ved å kalle `info()`:
+
+    ```python
+    df.info()
+    ```
+
+    Utdataene dine ligner:
+
+    ```output
+    <class 'pandas.core.frame.DataFrame'>
+    RangeIndex: 2448 entries, 0 to 2447
+    Columns: 385 entries, Unnamed: 0 to zucchini
+    dtypes: int64(384), object(1)
+    memory usage: 7.2+ MB
+    ```
+
+## Øvelse - lære om matretter
+
+Nå begynner arbeidet å bli mer interessant. La oss oppdage fordelingen av data per kjøkken.
+
+1. Plott dataene som stolper ved å kalle `barh()`:
+
+    ```python
+    df.cuisine.value_counts().plot.barh()
+    ```
+
+    ![fordeling av matdata](../../../../4-Classification/1-Introduction/images/cuisine-dist.png)
+
+    Det er et begrenset antall kjøkken, men fordelingen av data er ujevn. Du kan fikse det! Før du gjør det, utforsk litt mer.
+
+1. Finn ut hvor mye data som er tilgjengelig per kjøkken og skriv det ut:
+
+    ```python
+    thai_df = df[(df.cuisine == "thai")]
+    japanese_df = df[(df.cuisine == "japanese")]
+    chinese_df = df[(df.cuisine == "chinese")]
+    indian_df = df[(df.cuisine == "indian")]
+    korean_df = df[(df.cuisine == "korean")]
+    
+    print(f'thai df: {thai_df.shape}')
+    print(f'japanese df: {japanese_df.shape}')
+    print(f'chinese df: {chinese_df.shape}')
+    print(f'indian df: {indian_df.shape}')
+    print(f'korean df: {korean_df.shape}')
+    ```
+
+    Utdataene ser slik ut:
+
+    ```output
+    thai df: (289, 385)
+    japanese df: (320, 385)
+    chinese df: (442, 385)
+    indian df: (598, 385)
+    korean df: (799, 385)
+    ```
+
+## Oppdage ingredienser
+
+Nå kan du grave dypere i dataene og lære hva som er de typiske ingrediensene per kjøkken. Du bør rense ut gjentakende data som skaper forvirring mellom kjøkken, så la oss lære om dette problemet.
+
+1. Lag en funksjon `create_ingredient()` i Python for å lage en ingrediens-datasett. Denne funksjonen vil starte med å fjerne en unyttig kolonne og sortere ingredienser etter antall:
+
+    ```python
+    def create_ingredient_df(df):
+        ingredient_df = df.T.drop(['cuisine','Unnamed: 0']).sum(axis=1).to_frame('value')
+        ingredient_df = ingredient_df[(ingredient_df.T != 0).any()]
+        ingredient_df = ingredient_df.sort_values(by='value', ascending=False,
+        inplace=False)
+        return ingredient_df
+    ```
+
+   Nå kan du bruke den funksjonen til å få en idé om de ti mest populære ingrediensene per kjøkken.
+
+1. Kall `create_ingredient()` og plott det ved å kalle `barh()`:
+
+    ```python
+    thai_ingredient_df = create_ingredient_df(thai_df)
+    thai_ingredient_df.head(10).plot.barh()
+    ```
+
+    ![thai](../../../../4-Classification/1-Introduction/images/thai.png)
+
+1. Gjør det samme for de japanske dataene:
+
+    ```python
+    japanese_ingredient_df = create_ingredient_df(japanese_df)
+    japanese_ingredient_df.head(10).plot.barh()
+    ```
+
+    ![japansk](../../../../4-Classification/1-Introduction/images/japanese.png)
+
+1. Nå for de kinesiske ingrediensene:
+
+    ```python
+    chinese_ingredient_df = create_ingredient_df(chinese_df)
+    chinese_ingredient_df.head(10).plot.barh()
+    ```
+
+    ![kinesisk](../../../../4-Classification/1-Introduction/images/chinese.png)
+
+1. Plott de indiske ingrediensene:
+
+    ```python
+    indian_ingredient_df = create_ingredient_df(indian_df)
+    indian_ingredient_df.head(10).plot.barh()
+    ```
+
+    ![indisk](../../../../4-Classification/1-Introduction/images/indian.png)
+
+1. Til slutt, plott de koreanske ingrediensene:
+
+    ```python
+    korean_ingredient_df = create_ingredient_df(korean_df)
+    korean_ingredient_df.head(10).plot.barh()
+    ```
+
+    ![koreansk](../../../../4-Classification/1-Introduction/images/korean.png)
+
+1. Nå, fjern de vanligste ingrediensene som skaper forvirring mellom ulike kjøkken, ved å kalle `drop()`:
+
+   Alle elsker ris, hvitløk og ingefær!
+
+    ```python
+    feature_df= df.drop(['cuisine','Unnamed: 0','rice','garlic','ginger'], axis=1)
+    labels_df = df.cuisine #.unique()
+    feature_df.head()
+    ```
+
+## Balanser datasettet
+
+Nå som du har renset dataene, bruk [SMOTE](https://imbalanced-learn.org/dev/references/generated/imblearn.over_sampling.SMOTE.html) - "Synthetic Minority Over-sampling Technique" - for å balansere det.
+
+1. Kall `fit_resample()`, denne strategien genererer nye prøver ved interpolasjon.
+
+    ```python
+    oversample = SMOTE()
+    transformed_feature_df, transformed_label_df = oversample.fit_resample(feature_df, labels_df)
+    ```
+
+    Ved å balansere dataene dine, vil du få bedre resultater når du klassifiserer dem. Tenk på en binær klassifisering. Hvis mesteparten av dataene dine er én klasse, vil en ML-modell forutsi den klassen oftere, bare fordi det er mer data for den. Å balansere dataene tar skjeve data og hjelper med å fjerne denne ubalansen.
+
+1. Nå kan du sjekke antall etiketter per ingrediens:
+
+    ```python
+    print(f'new label count: {transformed_label_df.value_counts()}')
+    print(f'old label count: {df.cuisine.value_counts()}')
+    ```
+
+    Utdataene dine ser slik ut:
+
+    ```output
+    new label count: korean      799
+    chinese     799
+    indian      799
+    japanese    799
+    thai        799
+    Name: cuisine, dtype: int64
+    old label count: korean      799
+    indian      598
+    chinese     442
+    japanese    320
+    thai        289
+    Name: cuisine, dtype: int64
+    ```
+
+    Dataene er fine og rene, balanserte og veldig delikate!
+
+1. Det siste trinnet er å lagre de balanserte dataene, inkludert etiketter og funksjoner, i et nytt datasett som kan eksporteres til en fil:
+
+    ```python
+    transformed_df = pd.concat([transformed_label_df,transformed_feature_df],axis=1, join='outer')
+    ```
+
+1. Du kan ta en siste titt på dataene ved å bruke `transformed_df.head()` og `transformed_df.info()`. Lagre en kopi av disse dataene for bruk i fremtidige leksjoner:
+
+    ```python
+    transformed_df.head()
+    transformed_df.info()
+    transformed_df.to_csv("../data/cleaned_cuisines.csv")
+    ```
+
+    Denne ferske CSV-filen kan nå finnes i rotdata-mappen.
+
+---
+
+## 🚀Utfordring
+
+Dette pensumet inneholder flere interessante datasett. Grav gjennom `data`-mappene og se om noen inneholder datasett som ville være passende for binær eller multiklasse klassifisering? Hvilke spørsmål ville du stille til dette datasettet?
+
+## [Quiz etter leksjonen](https://ff-quizzes.netlify.app/en/ml/)
+
+## Gjennomgang og selvstudium
+
+Utforsk SMOTEs API. Hvilke bruksområder er det best egnet for? Hvilke problemer løser det?
+
+## Oppgave 
+
+[Utforsk klassifiseringsmetoder](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/4-Classification/1-Introduction/assignment.md

@@ -0,0 +1,25 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "b2a01912beb24cfb0007f83594dba801",
+  "translation_date": "2025-09-05T21:56:25+00:00",
+  "source_file": "4-Classification/1-Introduction/assignment.md",
+  "language_code": "no"
+}
+-->
+# Utforsk klassifiseringsmetoder
+
+## Instruksjoner
+
+I [Scikit-learn dokumentasjonen](https://scikit-learn.org/stable/supervised_learning.html) finner du en omfattende liste over måter å klassifisere data på. Gjør en liten skattejakt i disse dokumentene: målet ditt er å finne klassifiseringsmetoder og matche et datasett fra dette pensumet, et spørsmål du kan stille om det, og en klassifiseringsteknikk. Lag et regneark eller en tabell i en .doc-fil og forklar hvordan datasettet kan fungere med klassifiseringsalgoritmen.
+
+## Vurderingskriterier
+
+| Kriterier | Eksemplarisk                                                                                                                       | Tilfredsstillende                                                                                                                  | Trenger forbedring                                                                                                                                             |
+| --------- | ----------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+|           | et dokument presenteres som gir en oversikt over 5 algoritmer sammen med en klassifiseringsteknikk. Oversikten er godt forklart og detaljert. | et dokument presenteres som gir en oversikt over 3 algoritmer sammen med en klassifiseringsteknikk. Oversikten er godt forklart og detaljert. | et dokument presenteres som gir en oversikt over færre enn tre algoritmer sammen med en klassifiseringsteknikk, og oversikten er verken godt forklart eller detaljert. |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/4-Classification/1-Introduction/solution/Julia/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+  "translation_date": "2025-09-05T21:56:38+00:00",
+  "source_file": "4-Classification/1-Introduction/solution/Julia/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/4-Classification/2-Classifiers-1/README.md

@@ -0,0 +1,253 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "1a6e9e46b34a2e559fbbfc1f95397c7b",
+  "translation_date": "2025-09-05T21:50:40+00:00",
+  "source_file": "4-Classification/2-Classifiers-1/README.md",
+  "language_code": "no"
+}
+-->
+# Klassifisering av matretter 1
+
+I denne leksjonen skal du bruke datasettet du lagret fra forrige leksjon, som inneholder balanserte og rene data om matretter.
+
+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.
+
+## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
+# Forberedelse
+
+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.
+
+## Øvelse - forutsi en nasjonal matrett
+
+1. Arbeid i denne leksjonens _notebook.ipynb_-mappe, og importer filen sammen med Pandas-biblioteket:
+
+    ```python
+    import pandas as pd
+    cuisines_df = pd.read_csv("../data/cleaned_cuisines.csv")
+    cuisines_df.head()
+    ```
+
+    Dataen ser slik ut:
+
+|     | Unnamed: 0 | cuisine | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood | yam | yeast | yogurt | zucchini |
+| --- | ---------- | ------- | ------ | -------- | ----- | ---------- | ----- | ------------ | ------- | -------- | --- | ------- | ----------- | ---------- | ----------------------- | ---- | ---- | --- | ----- | ------ | -------- |
+| 0   | 0          | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
+| 1   | 1          | indian  | 1      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
+| 2   | 2          | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
+| 3   | 3          | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
+| 4   | 4          | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 1      | 0        |
+  
+
+1. Importer nå flere biblioteker:
+
+    ```python
+    from sklearn.linear_model import LogisticRegression
+    from sklearn.model_selection import train_test_split, cross_val_score
+    from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report, precision_recall_curve
+    from sklearn.svm import SVC
+    import numpy as np
+    ```
+
+1. Del X- og y-koordinatene inn i to dataframes for trening. `cuisine` kan være etikett-datasettet:
+
+    ```python
+    cuisines_label_df = cuisines_df['cuisine']
+    cuisines_label_df.head()
+    ```
+
+    Det vil se slik ut:
+
+    ```output
+    0    indian
+    1    indian
+    2    indian
+    3    indian
+    4    indian
+    Name: cuisine, dtype: object
+    ```
+
+1. Fjern kolonnen `Unnamed: 0` og kolonnen `cuisine` ved å bruke `drop()`. Lagre resten av dataene som trenbare funksjoner:
+
+    ```python
+    cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)
+    cuisines_feature_df.head()
+    ```
+
+    Funksjonene dine ser slik ut:
+
+|      | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | artemisia | artichoke |  ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood |  yam | yeast | yogurt | zucchini |
+| ---: | -----: | -------: | ----: | ---------: | ----: | -----------: | ------: | -------: | --------: | --------: | ---: | ------: | ----------: | ---------: | ----------------------: | ---: | ---: | ---: | ----: | -----: | -------: |
+|    0 |      0 |        0 |     0 |          0 |     0 |            0 |       0 |        0 |         0 |         0 |  ... |       0 |           0 |          0 |                       0 |    0 |    0 |    0 |     0 |      0 |        0 | 0 |
+|    1 |      1 |        0 |     0 |          0 |     0 |            0 |       0 |        0 |         0 |         0 |  ... |       0 |           0 |          0 |                       0 |    0 |    0 |    0 |     0 |      0 |        0 | 0 |
+|    2 |      0 |        0 |     0 |          0 |     0 |            0 |       0 |        0 |         0 |         0 |  ... |       0 |           0 |          0 |                       0 |    0 |    0 |    0 |     0 |      0 |        0 | 0 |
+|    3 |      0 |        0 |     0 |          0 |     0 |            0 |       0 |        0 |         0 |         0 |  ... |       0 |           0 |          0 |                       0 |    0 |    0 |    0 |     0 |      0 |        0 | 0 |
+|    4 |      0 |        0 |     0 |          0 |     0 |            0 |       0 |        0 |         0 |         0 |  ... |       0 |           0 |          0 |                       0 |    0 |    0 |    0 |     0 |      1 |        0 | 0 |
+
+Nå er du klar til å trene modellen din!
+
+## Velge klassifiseringsmetode
+
+Nå som dataene dine er rene og klare for trening, må du bestemme hvilken algoritme du skal bruke til oppgaven.
+
+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:
+
+- Lineære modeller
+- Support Vector Machines
+- Stokastisk gradientnedstigning
+- Nærmeste naboer
+- Gaussiske prosesser
+- Beslutningstrær
+- Ensemble-metoder (voting Classifier)
+- 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.
+
+### Hvilken klassifiseringsmetode 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:
+
+![sammenligning av klassifiseringsmetoder](../../../../4-Classification/2-Classifiers-1/images/comparison.png)
+> Diagrammer generert fra 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)
+
+### 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:
+
+![jukselapp for multiklasse-problemer](../../../../4-Classification/2-Classifiers-1/images/cheatsheet.png)
+> En del av Microsofts Algorithm Cheat Sheet, som beskriver alternativer for multiklasse-klassifisering
+
+✅ Last ned denne jukselappen, skriv den ut, og heng den på veggen!
+
+### Resonnement
+
+La oss se om vi kan resonnere oss frem til ulike 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.
+- **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.
+
+### 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).  
+
+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.
+
+Ifølge dokumentasjonen, i multiklasse-tilfellet, 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’.)
+
+> 🎓 '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/)
+
+> 🎓 '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).
+
+Scikit-learn tilbyr denne tabellen for å forklare hvordan solvers håndterer ulike utfordringer presentert av forskjellige typer datastrukturer:
+
+![solvers](../../../../4-Classification/2-Classifiers-1/images/solvers.png)
+
+## Øvelse - del dataene
+
+Vi kan fokusere på logistisk regresjon for vår første treningsrunde siden du nylig lærte om dette i en tidligere leksjon.
+Del dataene dine inn i trenings- og testgrupper ved å bruke `train_test_split()`:
+
+```python
+X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)
+```
+
+## Øvelse - bruk logistisk regresjon
+
+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.
+
+1. Opprett en logistisk regresjon med multi_class satt til `ovr` og solver satt til `liblinear`:
+
+    ```python
+    lr = LogisticRegression(multi_class='ovr',solver='liblinear')
+    model = lr.fit(X_train, np.ravel(y_train))
+    
+    accuracy = model.score(X_test, y_test)
+    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%**!
+
+1. Du kan se denne modellen i aksjon ved å teste én rad med data (#50):
+
+    ```python
+    print(f'ingredients: {X_test.iloc[50][X_test.iloc[50]!=0].keys()}')
+    print(f'cuisine: {y_test.iloc[50]}')
+    ```
+
+    Resultatet skrives ut:
+
+   ```output
+   ingredients: Index(['cilantro', 'onion', 'pea', 'potato', 'tomato', 'vegetable_oil'], dtype='object')
+   cuisine: indian
+   ```
+
+   ✅ Prøv et annet radnummer og sjekk resultatene
+
+1. For å gå dypere, kan du sjekke nøyaktigheten til denne prediksjonen:
+
+    ```python
+    test= X_test.iloc[50].values.reshape(-1, 1).T
+    proba = model.predict_proba(test)
+    classes = model.classes_
+    resultdf = pd.DataFrame(data=proba, columns=classes)
+    
+    topPrediction = resultdf.T.sort_values(by=[0], ascending = [False])
+    topPrediction.head()
+    ```
+
+    Resultatet skrives ut - indisk mat er modellens beste gjetning, med høy sannsynlighet:
+
+    |          |        0 |
+    | -------: | -------: |
+    |   indian | 0.715851 |
+    |  chinese | 0.229475 |
+    | japanese | 0.029763 |
+    |   korean | 0.017277 |
+    |     thai | 0.007634 |
+
+    ✅ Kan du forklare hvorfor modellen er ganske sikker på at dette er indisk mat?
+
+1. Få mer detaljert informasjon ved å skrive ut en klassifikasjonsrapport, slik du gjorde i regresjonsleksjonene:
+
+    ```python
+    y_pred = model.predict(X_test)
+    print(classification_report(y_test,y_pred))
+    ```
+
+    |              | presisjon | recall | f1-score | støtte |
+    | ------------ | --------- | ------ | -------- | ------ |
+    | chinese      | 0.73      | 0.71   | 0.72     | 229    |
+    | indian       | 0.91      | 0.93   | 0.92     | 254    |
+    | japanese     | 0.70      | 0.75   | 0.72     | 220    |
+    | korean       | 0.86      | 0.76   | 0.81     | 242    |
+    | thai         | 0.79      | 0.85   | 0.82     | 254    |
+    | nøyaktighet  | 0.80      | 1199   |          |        |
+    | makro snitt  | 0.80      | 0.80   | 0.80     | 1199   |
+    | vektet snitt | 0.80      | 0.80   | 0.80     | 1199   |
+
+## 🚀Utfordring
+
+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.
+
+## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+## Gjennomgang & 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 
+
+[Studer solverne](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.

translations/no/4-Classification/2-Classifiers-1/assignment.md

@@ -0,0 +1,23 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "de6025f96841498b0577e9d1aee18d1f",
+  "translation_date": "2025-09-05T21:51:31+00:00",
+  "source_file": "4-Classification/2-Classifiers-1/assignment.md",
+  "language_code": "no"
+}
+-->
+# Studer løserne
+## Instruksjoner
+
+I denne leksjonen lærte du om de ulike løserne som kombinerer algoritmer med en maskinlæringsprosess for å skape en nøyaktig modell. Gå gjennom løserne som er oppført i leksjonen og velg to. Med dine egne ord, sammenlign og kontraster disse to løserne. Hvilken type problem adresserer de? Hvordan fungerer de med ulike datastrukturer? Hvorfor ville du valgt den ene fremfor den andre? 
+## Vurderingskriterier
+
+| Kriterier | Eksemplarisk                                                                                  | Tilfredsstillende                                | Trenger forbedring           |
+| --------- | --------------------------------------------------------------------------------------------- | ------------------------------------------------ | ---------------------------- |
+|           | En .doc-fil presenteres med to avsnitt, ett om hver løser, som sammenligner dem gjennomtenkt. | En .doc-fil presenteres med kun ett avsnitt      | Oppgaven er ufullstendig     |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/4-Classification/2-Classifiers-1/solution/Julia/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+  "translation_date": "2025-09-05T21:51:43+00:00",
+  "source_file": "4-Classification/2-Classifiers-1/solution/Julia/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/4-Classification/3-Classifiers-2/README.md

@@ -0,0 +1,249 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "49047911108adc49d605cddfb455749c",
+  "translation_date": "2025-09-05T21:54:02+00:00",
+  "source_file": "4-Classification/3-Classifiers-2/README.md",
+  "language_code": "no"
+}
+-->
+# Klassifisering av matretter 2
+
+I denne andre leksjonen om klassifisering vil du utforske flere måter å klassifisere numeriske data på. Du vil også lære om konsekvensene ved å velge én klassifikator fremfor en annen.
+
+## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
+
+### Forutsetninger
+
+Vi antar at du har fullført de tidligere leksjonene og har et renset datasett i `data`-mappen kalt _cleaned_cuisines.csv_ i roten av denne 4-leksjonsmappen.
+
+### Forberedelse
+
+Vi har lastet inn filen din _notebook.ipynb_ med det rensede datasettet og har delt det inn i X- og y-dataframes, klare for modellbyggingsprosessen.
+
+## Et klassifiseringskart
+
+Tidligere lærte du om de ulike alternativene du har når du klassifiserer data ved hjelp av Microsofts jukselapp. Scikit-learn tilbyr en lignende, men mer detaljert jukselapp som kan hjelpe deg med å snevre inn valget av estimatoren (et annet ord for klassifikator):
+
+![ML-kart fra Scikit-learn](../../../../4-Classification/3-Classifiers-2/images/map.png)
+> Tips: [besøk dette kartet online](https://scikit-learn.org/stable/tutorial/machine_learning_map/) og klikk langs stien for å lese dokumentasjonen.
+
+### Planen
+
+Dette kartet er veldig nyttig når du har en klar forståelse av dataene dine, da du kan 'gå' langs stiene til en beslutning:
+
+- Vi har >50 prøver
+- Vi ønsker å forutsi en kategori
+- Vi har merket data
+- Vi har færre enn 100K prøver
+- ✨ Vi kan velge en Linear SVC
+- Hvis det ikke fungerer, siden vi har numeriske data
+    - Vi kan prøve en ✨ KNeighbors Classifier 
+      - Hvis det ikke fungerer, prøv ✨ SVC og ✨ Ensemble Classifiers
+
+Dette er en veldig nyttig sti å følge.
+
+## Øvelse - del opp dataene
+
+Ved å følge denne stien bør vi starte med å importere noen biblioteker vi skal bruke.
+
+1. Importer de nødvendige bibliotekene:
+
+    ```python
+    from sklearn.neighbors import KNeighborsClassifier
+    from sklearn.linear_model import LogisticRegression
+    from sklearn.svm import SVC
+    from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
+    from sklearn.model_selection import train_test_split, cross_val_score
+    from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report, precision_recall_curve
+    import numpy as np
+    ```
+
+1. Del opp trenings- og testdataene:
+
+    ```python
+    X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)
+    ```
+
+## Linear SVC klassifikator
+
+Support-Vector clustering (SVC) er en del av Support-Vector-maskiner-familien av ML-teknikker (lær mer om disse nedenfor). I denne metoden kan du velge en 'kernel' for å bestemme hvordan etikettene skal grupperes. Parameteren 'C' refererer til 'regularisering', som regulerer påvirkningen av parametere. Kernel kan være en av [flere](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC); her setter vi den til 'linear' for å sikre at vi bruker lineær SVC. Sannsynlighet er som standard satt til 'false'; her setter vi den til 'true' for å samle sannsynlighetsestimater. Vi setter den tilfeldige tilstanden til '0' for å blande dataene for å få sannsynligheter.
+
+### Øvelse - bruk en lineær SVC
+
+Start med å lage en array av klassifikatorer. Du vil legge til gradvis i denne arrayen mens vi tester.
+
+1. Start med en Linear SVC:
+
+    ```python
+    C = 10
+    # Create different classifiers.
+    classifiers = {
+        'Linear SVC': SVC(kernel='linear', C=C, probability=True,random_state=0)
+    }
+    ```
+
+2. Tren modellen din ved hjelp av Linear SVC og skriv ut en rapport:
+
+    ```python
+    n_classifiers = len(classifiers)
+    
+    for index, (name, classifier) in enumerate(classifiers.items()):
+        classifier.fit(X_train, np.ravel(y_train))
+    
+        y_pred = classifier.predict(X_test)
+        accuracy = accuracy_score(y_test, y_pred)
+        print("Accuracy (train) for %s: %0.1f%% " % (name, accuracy * 100))
+        print(classification_report(y_test,y_pred))
+    ```
+
+    Resultatet er ganske bra:
+
+    ```output
+    Accuracy (train) for Linear SVC: 78.6% 
+                  precision    recall  f1-score   support
+    
+         chinese       0.71      0.67      0.69       242
+          indian       0.88      0.86      0.87       234
+        japanese       0.79      0.74      0.76       254
+          korean       0.85      0.81      0.83       242
+            thai       0.71      0.86      0.78       227
+    
+        accuracy                           0.79      1199
+       macro avg       0.79      0.79      0.79      1199
+    weighted avg       0.79      0.79      0.79      1199
+    ```
+
+## K-Neighbors klassifikator
+
+K-Neighbors er en del av "neighbors"-familien av ML-metoder, som kan brukes til både overvåket og ikke-overvåket læring. I denne metoden opprettes et forhåndsdefinert antall punkter, og data samles rundt disse punktene slik at generaliserte etiketter kan forutsies for dataene.
+
+### Øvelse - bruk K-Neighbors klassifikator
+
+Den forrige klassifikatoren var god og fungerte bra med dataene, men kanskje vi kan få bedre nøyaktighet. Prøv en K-Neighbors klassifikator.
+
+1. Legg til en linje i klassifikator-arrayen din (legg til en komma etter Linear SVC-elementet):
+
+    ```python
+    'KNN classifier': KNeighborsClassifier(C),
+    ```
+
+    Resultatet er litt dårligere:
+
+    ```output
+    Accuracy (train) for KNN classifier: 73.8% 
+                  precision    recall  f1-score   support
+    
+         chinese       0.64      0.67      0.66       242
+          indian       0.86      0.78      0.82       234
+        japanese       0.66      0.83      0.74       254
+          korean       0.94      0.58      0.72       242
+            thai       0.71      0.82      0.76       227
+    
+        accuracy                           0.74      1199
+       macro avg       0.76      0.74      0.74      1199
+    weighted avg       0.76      0.74      0.74      1199
+    ```
+
+    ✅ Lær om [K-Neighbors](https://scikit-learn.org/stable/modules/neighbors.html#neighbors)
+
+## Support Vector Classifier
+
+Support-Vector klassifikatorer er en del av [Support-Vector Machine](https://wikipedia.org/wiki/Support-vector_machine)-familien av ML-metoder som brukes til klassifiserings- og regresjonsoppgaver. SVMs "kartlegger treningsprøver til punkter i rommet" for å maksimere avstanden mellom to kategorier. Påfølgende data kartlegges inn i dette rommet slik at deres kategori kan forutsies.
+
+### Øvelse - bruk en Support Vector Classifier
+
+La oss prøve å få litt bedre nøyaktighet med en Support Vector Classifier.
+
+1. Legg til en komma etter K-Neighbors-elementet, og legg deretter til denne linjen:
+
+    ```python
+    'SVC': SVC(),
+    ```
+
+    Resultatet er ganske bra!
+
+    ```output
+    Accuracy (train) for SVC: 83.2% 
+                  precision    recall  f1-score   support
+    
+         chinese       0.79      0.74      0.76       242
+          indian       0.88      0.90      0.89       234
+        japanese       0.87      0.81      0.84       254
+          korean       0.91      0.82      0.86       242
+            thai       0.74      0.90      0.81       227
+    
+        accuracy                           0.83      1199
+       macro avg       0.84      0.83      0.83      1199
+    weighted avg       0.84      0.83      0.83      1199
+    ```
+
+    ✅ Lær om [Support-Vectors](https://scikit-learn.org/stable/modules/svm.html#svm)
+
+## Ensemble Classifiers
+
+La oss følge stien helt til slutten, selv om den forrige testen var ganske bra. La oss prøve noen 'Ensemble Classifiers', spesielt Random Forest og AdaBoost:
+
+```python
+  'RFST': RandomForestClassifier(n_estimators=100),
+  'ADA': AdaBoostClassifier(n_estimators=100)
+```
+
+Resultatet er veldig bra, spesielt for Random Forest:
+
+```output
+Accuracy (train) for RFST: 84.5% 
+              precision    recall  f1-score   support
+
+     chinese       0.80      0.77      0.78       242
+      indian       0.89      0.92      0.90       234
+    japanese       0.86      0.84      0.85       254
+      korean       0.88      0.83      0.85       242
+        thai       0.80      0.87      0.83       227
+
+    accuracy                           0.84      1199
+   macro avg       0.85      0.85      0.84      1199
+weighted avg       0.85      0.84      0.84      1199
+
+Accuracy (train) for ADA: 72.4% 
+              precision    recall  f1-score   support
+
+     chinese       0.64      0.49      0.56       242
+      indian       0.91      0.83      0.87       234
+    japanese       0.68      0.69      0.69       254
+      korean       0.73      0.79      0.76       242
+        thai       0.67      0.83      0.74       227
+
+    accuracy                           0.72      1199
+   macro avg       0.73      0.73      0.72      1199
+weighted avg       0.73      0.72      0.72      1199
+```
+
+✅ Lær om [Ensemble Classifiers](https://scikit-learn.org/stable/modules/ensemble.html)
+
+Denne metoden for maskinlæring "kombinerer prediksjonene fra flere base-estimatorer" for å forbedre modellens kvalitet. I vårt eksempel brukte vi Random Trees og AdaBoost. 
+
+- [Random Forest](https://scikit-learn.org/stable/modules/ensemble.html#forest), en gjennomsnittsmetode, bygger en 'skog' av 'beslutningstrær' med innført tilfeldighet for å unngå overtilpasning. Parameteren n_estimators er satt til antall trær.
+
+- [AdaBoost](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) tilpasser en klassifikator til et datasett og deretter tilpasser kopier av den klassifikatoren til det samme datasettet. Den fokuserer på vektene til feilklassifiserte elementer og justerer tilpasningen for neste klassifikator for å korrigere.
+
+---
+
+## 🚀Utfordring
+
+Hver av disse teknikkene har et stort antall parametere som du kan justere. Undersøk standardparametrene for hver av dem og tenk på hva justering av disse parameterne vil bety for modellens kvalitet.
+
+## [Quiz etter leksjonen](https://ff-quizzes.netlify.app/en/ml/)
+
+## Gjennomgang og selvstudium
+
+Det er mye sjargong i disse leksjonene, så ta et øyeblikk til å gå gjennom [denne listen](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) med nyttig terminologi!
+
+## Oppgave 
+
+[Parameterlek](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/4-Classification/3-Classifiers-2/assignment.md

@@ -0,0 +1,25 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "58dfdaf79fb73f7d34b22bdbacf57329",
+  "translation_date": "2025-09-05T21:54:33+00:00",
+  "source_file": "4-Classification/3-Classifiers-2/assignment.md",
+  "language_code": "no"
+}
+-->
+# Parameterlek
+
+## Instruksjoner
+
+Det finnes mange parametere som er satt som standard når man jobber med disse klassifiseringsmodellene. Intellisense i VS Code kan hjelpe deg med å utforske dem. Velg en av ML-klassifiseringsteknikkene i denne leksjonen og tren modellene på nytt ved å justere ulike parametere. Lag en notebook som forklarer hvorfor noen endringer forbedrer modellkvaliteten, mens andre forverrer den. Vær detaljert i svaret ditt.
+
+## Vurderingskriterier
+
+| Kriterier | Eksemplarisk                                                                                                         | Tilfredsstillende                                    | Trenger forbedring           |
+| --------- | -------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------- | ---------------------------- |
+|           | En notebook presenteres med en fullt utviklet klassifiseringsmodell, hvor parametere er justert og endringer forklart i tekstbokser | En notebook er delvis presentert eller dårlig forklart | En notebook er feilaktig eller mangelfull |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/4-Classification/3-Classifiers-2/solution/Julia/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+  "translation_date": "2025-09-05T21:54:45+00:00",
+  "source_file": "4-Classification/3-Classifiers-2/solution/Julia/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/4-Classification/4-Applied/README.md

@@ -0,0 +1,329 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "61bdec27ed2da8b098cd9065405d9bb0",
+  "translation_date": "2025-09-05T21:52:38+00:00",
+  "source_file": "4-Classification/4-Applied/README.md",
+  "language_code": "no"
+}
+-->
+# Bygg en webapp for matanbefalinger
+
+I denne leksjonen skal du bygge en klassifiseringsmodell ved hjelp av noen av teknikkene du har lært i tidligere leksjoner, samt det deilige matdatasettet som har blitt brukt gjennom denne serien. I tillegg skal du lage en liten webapp for å bruke en lagret modell, ved hjelp av Onnx sin web-runtime.
+
+En av de mest nyttige praktiske bruksområdene for maskinlæring er å lage anbefalingssystemer, og du kan ta det første steget i den retningen i dag!
+
+[![Presentere denne webappen](https://img.youtube.com/vi/17wdM9AHMfg/0.jpg)](https://youtu.be/17wdM9AHMfg "Applied ML")
+
+> 🎥 Klikk på bildet over for en video: Jen Looper lager en webapp ved hjelp av klassifisert matdata
+
+## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
+
+I denne leksjonen vil du lære:
+
+- Hvordan bygge en modell og lagre den som en Onnx-modell
+- Hvordan bruke Netron for å inspisere modellen
+- Hvordan bruke modellen din i en webapp for inferens
+
+## Bygg modellen din
+
+Å bygge anvendte ML-systemer er en viktig del av å utnytte disse teknologiene for dine forretningssystemer. Du kan bruke modeller i webapplikasjonene dine (og dermed bruke dem i en offline-kontekst om nødvendig) ved hjelp av Onnx.
+
+I en [tidligere leksjon](../../3-Web-App/1-Web-App/README.md) bygde du en regresjonsmodell om UFO-observasjoner, "picklet" den, og brukte den i en Flask-app. Selv om denne arkitekturen er veldig nyttig å kjenne til, er det en full-stack Python-app, og kravene dine kan inkludere bruk av en JavaScript-applikasjon.
+
+I denne leksjonen kan du bygge et grunnleggende JavaScript-basert system for inferens. Først må du imidlertid trene en modell og konvertere den for bruk med Onnx.
+
+## Øvelse - tren klassifiseringsmodell
+
+Først, tren en klassifiseringsmodell ved hjelp av det rensede matdatasettet vi brukte.
+
+1. Start med å importere nyttige biblioteker:
+
+    ```python
+    !pip install skl2onnx
+    import pandas as pd 
+    ```
+
+    Du trenger '[skl2onnx](https://onnx.ai/sklearn-onnx/)' for å hjelpe med å konvertere Scikit-learn-modellen din til Onnx-format.
+
+1. Deretter, arbeid med dataene dine på samme måte som du gjorde i tidligere leksjoner, ved å lese en CSV-fil med `read_csv()`:
+
+    ```python
+    data = pd.read_csv('../data/cleaned_cuisines.csv')
+    data.head()
+    ```
+
+1. Fjern de to første unødvendige kolonnene og lagre de gjenværende dataene som 'X':
+
+    ```python
+    X = data.iloc[:,2:]
+    X.head()
+    ```
+
+1. Lagre etikettene som 'y':
+
+    ```python
+    y = data[['cuisine']]
+    y.head()
+    
+    ```
+
+### Start treningsrutinen
+
+Vi skal bruke 'SVC'-biblioteket som har god nøyaktighet.
+
+1. Importer de relevante bibliotekene fra Scikit-learn:
+
+    ```python
+    from sklearn.model_selection import train_test_split
+    from sklearn.svm import SVC
+    from sklearn.model_selection import cross_val_score
+    from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report
+    ```
+
+1. Del opp trenings- og testsett:
+
+    ```python
+    X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3)
+    ```
+
+1. Bygg en SVC-klassifiseringsmodell slik du gjorde i den forrige leksjonen:
+
+    ```python
+    model = SVC(kernel='linear', C=10, probability=True,random_state=0)
+    model.fit(X_train,y_train.values.ravel())
+    ```
+
+1. Test modellen din ved å kalle `predict()`:
+
+    ```python
+    y_pred = model.predict(X_test)
+    ```
+
+1. Skriv ut en klassifiseringsrapport for å sjekke modellens kvalitet:
+
+    ```python
+    print(classification_report(y_test,y_pred))
+    ```
+
+    Som vi så tidligere, er nøyaktigheten god:
+
+    ```output
+                    precision    recall  f1-score   support
+    
+         chinese       0.72      0.69      0.70       257
+          indian       0.91      0.87      0.89       243
+        japanese       0.79      0.77      0.78       239
+          korean       0.83      0.79      0.81       236
+            thai       0.72      0.84      0.78       224
+    
+        accuracy                           0.79      1199
+       macro avg       0.79      0.79      0.79      1199
+    weighted avg       0.79      0.79      0.79      1199
+    ```
+
+### Konverter modellen din til Onnx
+
+Sørg for å gjøre konverteringen med riktig Tensor-nummer. Dette datasettet har 380 ingredienser oppført, så du må notere det nummeret i `FloatTensorType`:
+
+1. Konverter med et tensor-nummer på 380.
+
+    ```python
+    from skl2onnx import convert_sklearn
+    from skl2onnx.common.data_types import FloatTensorType
+    
+    initial_type = [('float_input', FloatTensorType([None, 380]))]
+    options = {id(model): {'nocl': True, 'zipmap': False}}
+    ```
+
+1. Lag onx-filen og lagre den som **model.onnx**:
+
+    ```python
+    onx = convert_sklearn(model, initial_types=initial_type, options=options)
+    with open("./model.onnx", "wb") as f:
+        f.write(onx.SerializeToString())
+    ```
+
+    > Merk, du kan sende inn [alternativer](https://onnx.ai/sklearn-onnx/parameterized.html) i konverteringsskriptet ditt. I dette tilfellet sendte vi inn 'nocl' som True og 'zipmap' som False. Siden dette er en klassifiseringsmodell, har du muligheten til å fjerne ZipMap som produserer en liste med ordbøker (ikke nødvendig). `nocl` refererer til klasseinformasjon som inkluderes i modellen. Reduser modellens størrelse ved å sette `nocl` til 'True'.
+
+Hvis du kjører hele notebooken, vil du nå bygge en Onnx-modell og lagre den i denne mappen.
+
+## Vis modellen din
+
+Onnx-modeller er ikke veldig synlige i Visual Studio Code, men det finnes en veldig god gratis programvare som mange forskere bruker for å visualisere modellen og sikre at den er riktig bygget. Last ned [Netron](https://github.com/lutzroeder/Netron) og åpne model.onnx-filen din. Du kan se den enkle modellen visualisert, med sine 380 input og klassifiserer listet opp:
+
+![Netron visual](../../../../4-Classification/4-Applied/images/netron.png)
+
+Netron er et nyttig verktøy for å se modellene dine.
+
+Nå er du klar til å bruke denne flotte modellen i en webapp. La oss bygge en app som vil være nyttig når du ser i kjøleskapet ditt og prøver å finne ut hvilken kombinasjon av ingredienser du kan bruke for å lage en bestemt matrett, som bestemt av modellen din.
+
+## Bygg en anbefalingswebapplikasjon
+
+Du kan bruke modellen din direkte i en webapp. Denne arkitekturen lar deg også kjøre den lokalt og til og med offline om nødvendig. Start med å lage en `index.html`-fil i samme mappe der du lagret `model.onnx`-filen.
+
+1. I denne filen _index.html_, legg til følgende markup:
+
+    ```html
+    <!DOCTYPE html>
+    <html>
+        <header>
+            <title>Cuisine Matcher</title>
+        </header>
+        <body>
+            ...
+        </body>
+    </html>
+    ```
+
+1. Nå, arbeid innenfor `body`-taggene, og legg til litt markup for å vise en liste med avkrysningsbokser som reflekterer noen ingredienser:
+
+    ```html
+    <h1>Check your refrigerator. What can you create?</h1>
+            <div id="wrapper">
+                <div class="boxCont">
+                    <input type="checkbox" value="4" class="checkbox">
+                    <label>apple</label>
+                </div>
+            
+                <div class="boxCont">
+                    <input type="checkbox" value="247" class="checkbox">
+                    <label>pear</label>
+                </div>
+            
+                <div class="boxCont">
+                    <input type="checkbox" value="77" class="checkbox">
+                    <label>cherry</label>
+                </div>
+    
+                <div class="boxCont">
+                    <input type="checkbox" value="126" class="checkbox">
+                    <label>fenugreek</label>
+                </div>
+    
+                <div class="boxCont">
+                    <input type="checkbox" value="302" class="checkbox">
+                    <label>sake</label>
+                </div>
+    
+                <div class="boxCont">
+                    <input type="checkbox" value="327" class="checkbox">
+                    <label>soy sauce</label>
+                </div>
+    
+                <div class="boxCont">
+                    <input type="checkbox" value="112" class="checkbox">
+                    <label>cumin</label>
+                </div>
+            </div>
+            <div style="padding-top:10px">
+                <button onClick="startInference()">What kind of cuisine can you make?</button>
+            </div> 
+    ```
+
+    Legg merke til at hver avkrysningsboks har en verdi. Dette reflekterer indeksen der ingrediensen finnes i henhold til datasettet. Eple, for eksempel, i denne alfabetiske listen, opptar den femte kolonnen, så verdien er '4' siden vi begynner å telle fra 0. Du kan konsultere [ingredients spreadsheet](../../../../4-Classification/data/ingredient_indexes.csv) for å finne en gitt ingrediens sin indeks.
+
+    Fortsett arbeidet ditt i index.html-filen, og legg til en script-blokk der modellen kalles etter den siste lukkende `</div>`.
+
+1. Først, importer [Onnx Runtime](https://www.onnxruntime.ai/):
+
+    ```html
+    <script src="https://cdn.jsdelivr.net/npm/onnxruntime-web@1.9.0/dist/ort.min.js"></script> 
+    ```
+
+    > Onnx Runtime brukes for å muliggjøre kjøring av Onnx-modeller på tvers av et bredt spekter av maskinvareplattformer, inkludert optimaliseringer og en API for bruk.
+
+1. Når Runtime er på plass, kan du kalle den:
+
+    ```html
+    <script>
+        const ingredients = Array(380).fill(0);
+        
+        const checks = [...document.querySelectorAll('.checkbox')];
+        
+        checks.forEach(check => {
+            check.addEventListener('change', function() {
+                // toggle the state of the ingredient
+                // based on the checkbox's value (1 or 0)
+                ingredients[check.value] = check.checked ? 1 : 0;
+            });
+        });
+
+        function testCheckboxes() {
+            // validate if at least one checkbox is checked
+            return checks.some(check => check.checked);
+        }
+
+        async function startInference() {
+
+            let atLeastOneChecked = testCheckboxes()
+
+            if (!atLeastOneChecked) {
+                alert('Please select at least one ingredient.');
+                return;
+            }
+            try {
+                // create a new session and load the model.
+                
+                const session = await ort.InferenceSession.create('./model.onnx');
+
+                const input = new ort.Tensor(new Float32Array(ingredients), [1, 380]);
+                const feeds = { float_input: input };
+
+                // feed inputs and run
+                const results = await session.run(feeds);
+
+                // read from results
+                alert('You can enjoy ' + results.label.data[0] + ' cuisine today!')
+
+            } catch (e) {
+                console.log(`failed to inference ONNX model`);
+                console.error(e);
+            }
+        }
+               
+    </script>
+    ```
+
+I denne koden skjer det flere ting:
+
+1. Du opprettet et array med 380 mulige verdier (1 eller 0) som skal settes og sendes til modellen for inferens, avhengig av om en ingrediens avkrysningsboks er krysset av.
+2. Du opprettet et array med avkrysningsbokser og en måte å avgjøre om de var krysset av i en `init`-funksjon som kalles når applikasjonen starter. Når en avkrysningsboks er krysset av, endres `ingredients`-arrayet for å reflektere den valgte ingrediensen.
+3. Du opprettet en `testCheckboxes`-funksjon som sjekker om noen avkrysningsboks er krysset av.
+4. Du bruker `startInference`-funksjonen når knappen trykkes, og hvis noen avkrysningsboks er krysset av, starter du inferens.
+5. Inferensrutinen inkluderer:
+   1. Oppsett av en asynkron last av modellen
+   2. Opprettelse av en Tensor-struktur som skal sendes til modellen
+   3. Opprettelse av 'feeds' som reflekterer `float_input`-input som du opprettet da du trente modellen din (du kan bruke Netron for å verifisere det navnet)
+   4. Sending av disse 'feeds' til modellen og venter på et svar
+
+## Test applikasjonen din
+
+Åpne en terminalsesjon i Visual Studio Code i mappen der index.html-filen din ligger. Sørg for at du har [http-server](https://www.npmjs.com/package/http-server) installert globalt, og skriv `http-server` ved ledeteksten. En localhost skal åpne seg, og du kan se webappen din. Sjekk hvilken matrett som anbefales basert på ulike ingredienser:
+
+![ingredient web app](../../../../4-Classification/4-Applied/images/web-app.png)
+
+Gratulerer, du har laget en 'anbefalings'-webapp med noen få felt. Ta deg tid til å bygge ut dette systemet!
+
+## 🚀Utfordring
+
+Webappen din er veldig enkel, så fortsett å bygge den ut ved hjelp av ingredienser og deres indekser fra [ingredient_indexes](../../../../4-Classification/data/ingredient_indexes.csv)-data. Hvilke smakskombinasjoner fungerer for å lage en gitt nasjonalrett?
+
+## [Quiz etter leksjonen](https://ff-quizzes.netlify.app/en/ml/)
+
+## Gjennomgang og selvstudium
+
+Selv om denne leksjonen bare berørte nytten av å lage et anbefalingssystem for matingredienser, er dette området innen ML-applikasjoner veldig rikt på eksempler. Les mer om hvordan disse systemene bygges:
+
+- https://www.sciencedirect.com/topics/computer-science/recommendation-engine
+- https://www.technologyreview.com/2014/08/25/171547/the-ultimate-challenge-for-recommendation-engines/
+- https://www.technologyreview.com/2015/03/23/168831/everything-is-a-recommendation/
+
+## Oppgave
+
+[Bygg en ny anbefaler](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/4-Classification/4-Applied/assignment.md

@@ -0,0 +1,25 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "799ed651e2af0a7cad17c6268db11578",
+  "translation_date": "2025-09-05T21:53:13+00:00",
+  "source_file": "4-Classification/4-Applied/assignment.md",
+  "language_code": "no"
+}
+-->
+# Bygg en anbefalingsmotor
+
+## Instruksjoner
+
+Basert på øvelsene i denne leksjonen, vet du nå hvordan du kan bygge en JavaScript-basert webapp ved hjelp av Onnx Runtime og en konvertert Onnx-modell. Eksperimenter med å lage en ny anbefalingsmotor ved å bruke data fra disse leksjonene eller hentet fra andre kilder (husk å gi kreditt). Du kan for eksempel lage en anbefalingsmotor for kjæledyr basert på ulike personlighetstrekk, eller en anbefalingsmotor for musikksjangre basert på en persons humør. Vær kreativ!
+
+## Vurderingskriterier
+
+| Kriterier | Eksemplarisk                                                           | Tilfredsstillende                     | Trenger forbedring                |
+| --------- | ---------------------------------------------------------------------- | ------------------------------------- | --------------------------------- |
+|           | En webapp og notatbok presenteres, begge godt dokumentert og fungerende | En av dem mangler eller har feil      | Begge mangler eller har feil      |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/4-Classification/README.md

@@ -0,0 +1,41 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "74e809ffd1e613a1058bbc3e9600859e",
+  "translation_date": "2025-09-05T21:49:12+00:00",
+  "source_file": "4-Classification/README.md",
+  "language_code": "no"
+}
+-->
+# Komme i gang med klassifisering
+
+## Regionalt tema: Deilige asiatiske og indiske retter 🍜
+
+I Asia og India er mattradisjonene svært mangfoldige og utrolig smakfulle! La oss se på data om regionale retter for å prøve å forstå ingrediensene deres.
+
+![Thai matselger](../../../4-Classification/images/thai-food.jpg)
+> Foto av <a href="https://unsplash.com/@changlisheng?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Lisheng Chang</a> på <a href="https://unsplash.com/s/photos/asian-food?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
+  
+## Hva du vil lære
+
+I denne delen vil du bygge videre på din tidligere studie av regresjon og lære om andre klassifikatorer som du kan bruke for å forstå dataene bedre.
+
+> Det finnes nyttige lavkodeverktøy som kan hjelpe deg med å lære om arbeid med klassifiseringsmodeller. Prøv [Azure ML for denne oppgaven](https://docs.microsoft.com/learn/modules/create-classification-model-azure-machine-learning-designer/?WT.mc_id=academic-77952-leestott)
+
+## Leksjoner
+
+1. [Introduksjon til klassifisering](1-Introduction/README.md)
+2. [Flere klassifikatorer](2-Classifiers-1/README.md)
+3. [Enda flere klassifikatorer](3-Classifiers-2/README.md)
+4. [Anvendt ML: bygg en webapplikasjon](4-Applied/README.md)
+
+## Krediteringer
+
+"Komme i gang med klassifisering" ble skrevet med ♥️ av [Cassie Breviu](https://www.twitter.com/cassiebreviu) og [Jen Looper](https://www.twitter.com/jenlooper)
+
+Datasettet for de deilige rettene ble hentet fra [Kaggle](https://www.kaggle.com/hoandan/asian-and-indian-cuisines).
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/5-Clustering/1-Visualize/README.md

@@ -0,0 +1,347 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "730225ea274c9174fe688b21d421539d",
+  "translation_date": "2025-09-05T21:27:24+00:00",
+  "source_file": "5-Clustering/1-Visualize/README.md",
+  "language_code": "no"
+}
+-->
+# Introduksjon til klynging
+
+Klynging er en type [Usupervisert læring](https://wikipedia.org/wiki/Unsupervised_learning) som forutsetter at et datasett er umerket eller at dets input ikke er koblet til forhåndsdefinerte output. Det bruker ulike algoritmer for å sortere gjennom umerket data og gi grupperinger basert på mønstre det oppdager i dataen.
+
+[![No One Like You av PSquare](https://img.youtube.com/vi/ty2advRiWJM/0.jpg)](https://youtu.be/ty2advRiWJM "No One Like You av PSquare")
+
+> 🎥 Klikk på bildet over for en video. Mens du studerer maskinlæring med klynging, nyt noen nigerianske Dance Hall-låter – dette er en høyt rangert sang fra 2014 av PSquare.
+
+## [Quiz før forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+### Introduksjon
+
+[Klynging](https://link.springer.com/referenceworkentry/10.1007%2F978-0-387-30164-8_124) er svært nyttig for datautforskning. La oss se om det kan hjelpe med å oppdage trender og mønstre i hvordan nigerianske publikum konsumerer musikk.
+
+✅ Ta et øyeblikk til å tenke på bruksområdene for klynging. I hverdagen skjer klynging når du har en haug med klesvask og må sortere familiemedlemmenes klær 🧦👕👖🩲. I dataanalyse skjer klynging når man prøver å analysere en brukers preferanser eller bestemme egenskapene til et umerket datasett. Klynging hjelper på en måte med å skape orden i kaos, som en sokkeskuff.
+
+[![Introduksjon til ML](https://img.youtube.com/vi/esmzYhuFnds/0.jpg)](https://youtu.be/esmzYhuFnds "Introduksjon til klynging")
+
+> 🎥 Klikk på bildet over for en video: MITs John Guttag introduserer klynging
+
+I en profesjonell setting kan klynging brukes til å bestemme ting som markedssegmentering, for eksempel å finne ut hvilke aldersgrupper som kjøper hvilke varer. Et annet bruksområde kan være å oppdage avvik, kanskje for å oppdage svindel i et datasett med kredittkorttransaksjoner. Eller du kan bruke klynging til å identifisere svulster i en samling medisinske skanninger.
+
+✅ Tenk et øyeblikk på hvordan du kan ha støtt på klynging 'i det virkelige liv', i en bank-, e-handels- eller forretningssetting.
+
+> 🎓 Interessant nok oppsto klyngeanalyse innenfor feltene antropologi og psykologi på 1930-tallet. Kan du forestille deg hvordan det kan ha blitt brukt?
+
+Alternativt kan du bruke det til å gruppere søkeresultater – for eksempel etter shoppinglenker, bilder eller anmeldelser. Klynging er nyttig når du har et stort datasett som du vil redusere og utføre mer detaljert analyse på, så teknikken kan brukes til å lære om data før andre modeller bygges.
+
+✅ Når dataen din er organisert i klynger, tildeler du den en klynge-ID, og denne teknikken kan være nyttig for å bevare et datasets personvern; du kan i stedet referere til et datapunkt med klynge-ID-en, i stedet for med mer avslørende identifiserbare data. Kan du tenke på andre grunner til hvorfor du ville referere til en klynge-ID i stedet for andre elementer i klyngen for å identifisere den?
+
+Fordyp deg i klyngingsteknikker i denne [Learn-modulen](https://docs.microsoft.com/learn/modules/train-evaluate-cluster-models?WT.mc_id=academic-77952-leestott)
+
+## Komme i gang med klynging
+
+[Scikit-learn tilbyr et stort utvalg](https://scikit-learn.org/stable/modules/clustering.html) av metoder for å utføre klynging. Typen du velger vil avhenge av bruksområdet ditt. Ifølge dokumentasjonen har hver metode ulike fordeler. Her er en forenklet tabell over metodene som støttes av Scikit-learn og deres passende bruksområder:
+
+| Metodenavn                  | Bruksområde                                                             |
+| :--------------------------- | :---------------------------------------------------------------------- |
+| K-Means                      | generell bruk, induktiv                                                 |
+| Affinity propagation         | mange, ujevne klynger, induktiv                                         |
+| Mean-shift                   | mange, ujevne klynger, induktiv                                         |
+| Spectral clustering          | få, jevne klynger, transduktiv                                          |
+| Ward hierarchical clustering | mange, begrensede klynger, transduktiv                                  |
+| Agglomerative clustering     | mange, begrensede, ikke-Euklidiske avstander, transduktiv               |
+| DBSCAN                       | ikke-flat geometri, ujevne klynger, transduktiv                         |
+| OPTICS                       | ikke-flat geometri, ujevne klynger med variabel tetthet, transduktiv    |
+| Gaussian mixtures            | flat geometri, induktiv                                                 |
+| BIRCH                        | stort datasett med uteliggere, induktiv                                 |
+
+> 🎓 Hvordan vi lager klynger har mye å gjøre med hvordan vi samler datapunktene i grupper. La oss pakke ut litt vokabular:
+>
+> 🎓 ['Transduktiv' vs. 'induktiv'](https://wikipedia.org/wiki/Transduction_(machine_learning))
+> 
+> Transduktiv inferens er avledet fra observerte treningscaser som kartlegges til spesifikke testcaser. Induktiv inferens er avledet fra treningscaser som kartlegges til generelle regler som deretter brukes på testcaser.
+> 
+> Et eksempel: Tenk deg at du har et datasett som bare delvis er merket. Noen ting er 'plater', noen 'CD-er', og noen er blanke. Din oppgave er å gi etiketter til de blanke. Hvis du velger en induktiv tilnærming, vil du trene en modell som ser etter 'plater' og 'CD-er', og bruke disse etikettene på din umerkede data. Denne tilnærmingen vil ha problemer med å klassifisere ting som faktisk er 'kassetter'. En transduktiv tilnærming, derimot, håndterer denne ukjente dataen mer effektivt ved å jobbe for å gruppere lignende elementer sammen og deretter bruke en etikett på en gruppe. I dette tilfellet kan klynger reflektere 'runde musikalske ting' og 'firkantede musikalske ting'.
+> 
+> 🎓 ['Ikke-flat' vs. 'flat' geometri](https://datascience.stackexchange.com/questions/52260/terminology-flat-geometry-in-the-context-of-clustering)
+> 
+> Avledet fra matematisk terminologi, refererer ikke-flat vs. flat geometri til målingen av avstander mellom punkter ved enten 'flat' ([Euklidisk](https://wikipedia.org/wiki/Euclidean_geometry)) eller 'ikke-flat' (ikke-Euklidisk) geometriske metoder.
+>
+>'Flat' i denne sammenhengen refererer til Euklidisk geometri (deler av dette læres som 'plan' geometri), og ikke-flat refererer til ikke-Euklidisk geometri. Hva har geometri med maskinlæring å gjøre? Vel, som to felt som er forankret i matematikk, må det være en felles måte å måle avstander mellom punkter i klynger, og det kan gjøres på en 'flat' eller 'ikke-flat' måte, avhengig av dataens natur. [Euklidiske avstander](https://wikipedia.org/wiki/Euclidean_distance) måles som lengden på en linjesegment mellom to punkter. [Ikke-Euklidiske avstander](https://wikipedia.org/wiki/Non-Euclidean_geometry) måles langs en kurve. Hvis dataen din, visualisert, ser ut til å ikke eksistere på et plan, kan det hende du må bruke en spesialisert algoritme for å håndtere det.
+>
+![Flat vs Ikke-flat Geometri Infografikk](../../../../5-Clustering/1-Visualize/images/flat-nonflat.png)
+> Infografikk av [Dasani Madipalli](https://twitter.com/dasani_decoded)
+> 
+> 🎓 ['Avstander'](https://web.stanford.edu/class/cs345a/slides/12-clustering.pdf)
+> 
+> Klynger defineres av deres avstandsmatrise, f.eks. avstandene mellom punkter. Denne avstanden kan måles på flere måter. Euklidiske klynger defineres av gjennomsnittet av punktverdiene, og inneholder et 'sentroid' eller midtpunkt. Avstander måles dermed ved avstanden til dette sentroidet. Ikke-Euklidiske avstander refererer til 'clustroids', punktet nærmest andre punkter. Clustroids kan på sin side defineres på ulike måter.
+> 
+> 🎓 ['Begrenset'](https://wikipedia.org/wiki/Constrained_clustering)
+> 
+> [Begrenset klynging](https://web.cs.ucdavis.edu/~davidson/Publications/ICDMTutorial.pdf) introduserer 'semi-supervisert' læring i denne usuperviserte metoden. Forholdene mellom punkter flagges som 'kan ikke kobles' eller 'må kobles', slik at noen regler tvinges på datasettet.
+>
+>Et eksempel: Hvis en algoritme slippes løs på en batch med umerket eller semi-merket data, kan klyngene den produserer være av dårlig kvalitet. I eksemplet ovenfor kan klyngene gruppere 'runde musikalske ting' og 'firkantede musikalske ting' og 'trekantede ting' og 'kjeks'. Hvis algoritmen får noen begrensninger, eller regler å følge ("elementet må være laget av plast", "elementet må kunne produsere musikk"), kan dette hjelpe med å 'begrense' algoritmen til å ta bedre valg.
+> 
+> 🎓 'Tetthet'
+> 
+> Data som er 'støyete' anses å være 'tett'. Avstandene mellom punkter i hver av klyngene kan vise seg, ved undersøkelse, å være mer eller mindre tette, eller 'trange', og dermed må denne dataen analyseres med den passende klyngemetoden. [Denne artikkelen](https://www.kdnuggets.com/2020/02/understanding-density-based-clustering.html) demonstrerer forskjellen mellom å bruke K-Means klynging vs. HDBSCAN-algoritmer for å utforske et støyete datasett med ujevn klyngetetthet.
+
+## Klyngealgoritmer
+
+Det finnes over 100 klyngealgoritmer, og deres bruk avhenger av naturen til dataen som skal analyseres. La oss diskutere noen av de viktigste:
+
+- **Hierarkisk klynging**. Hvis et objekt klassifiseres basert på dets nærhet til et nærliggende objekt, snarere enn til et som er lenger unna, dannes klynger basert på avstanden mellom medlemmene. Scikit-learns agglomerative klynging er hierarkisk.
+
+   ![Hierarkisk klynging Infografikk](../../../../5-Clustering/1-Visualize/images/hierarchical.png)
+   > Infografikk av [Dasani Madipalli](https://twitter.com/dasani_decoded)
+
+- **Sentroid klynging**. Denne populære algoritmen krever valg av 'k', eller antall klynger som skal dannes, hvoretter algoritmen bestemmer midtpunktet for en klynge og samler data rundt dette punktet. [K-means klynging](https://wikipedia.org/wiki/K-means_clustering) er en populær versjon av sentroid klynging. Midtpunktet bestemmes av nærmeste gjennomsnitt, derav navnet. Den kvadrerte avstanden fra klyngen minimeres.
+
+   ![Sentroid klynging Infografikk](../../../../5-Clustering/1-Visualize/images/centroid.png)
+   > Infografikk av [Dasani Madipalli](https://twitter.com/dasani_decoded)
+
+- **Distribusjonsbasert klynging**. Basert på statistisk modellering, fokuserer distribusjonsbasert klynging på å bestemme sannsynligheten for at et datapunkt tilhører en klynge, og tilordner det deretter. Gaussian mixture-metoder tilhører denne typen.
+
+- **Tetthetsbasert klynging**. Datapunkter tilordnes klynger basert på deres tetthet, eller deres gruppering rundt hverandre. Datapunkter langt fra gruppen anses som uteliggere eller støy. DBSCAN, Mean-shift og OPTICS tilhører denne typen klynging.
+
+- **Grid-basert klynging**. For multidimensjonale datasett opprettes et rutenett, og dataen deles mellom rutenettets celler, og skaper dermed klynger.
+
+## Øvelse – klyng dataen din
+
+Klynging som teknikk støttes sterkt av god visualisering, så la oss komme i gang med å visualisere musikkdataen vår. Denne øvelsen vil hjelpe oss med å avgjøre hvilken av klyngemetodene vi mest effektivt bør bruke for naturen til denne dataen.
+
+1. Åpne filen [_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/1-Visualize/notebook.ipynb) i denne mappen.
+
+1. Importer pakken `Seaborn` for god visualisering av data.
+
+    ```python
+    !pip install seaborn
+    ```
+
+1. Legg til musikkdataen fra [_nigerian-songs.csv_](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/data/nigerian-songs.csv). Last opp en dataframe med noen data om sangene. Gjør deg klar til å utforske denne dataen ved å importere bibliotekene og skrive ut dataen:
+
+    ```python
+    import matplotlib.pyplot as plt
+    import pandas as pd
+    
+    df = pd.read_csv("../data/nigerian-songs.csv")
+    df.head()
+    ```
+
+    Sjekk de første linjene med data:
+
+    |     | navn                     | album                        | artist              | artist_top_genre | release_date | lengde | popularitet | dansbarhet | akustisitet | energi | instrumentalisme | livlighet | lydstyrke | talbarhet | tempo   | taktart         |
+    | --- | ------------------------ | ---------------------------- | ------------------- | ---------------- | ------------ | ------ | ---------- | ---------- | ------------ | ------ | ---------------- | -------- | -------- | --------- | ------- | -------------- |
+    | 0   | Sparky                   | Mandy & The Jungle           | Cruel Santino       | alternativ r&b   | 2019         | 144000 | 48         | 0.666      | 0.851        | 0.42   | 0.534            | 0.11     | -6.699   | 0.0829    | 133.015 | 5              |
+    | 1   | shuga rush               | EVERYTHING YOU HEARD IS TRUE | Odunsi (The Engine) | afropop          | 2020         | 89488  | 30         | 0.71       | 0.0822       | 0.683  | 0.000169         | 0.101    | -5.64    | 0.36      | 129.993 | 3              |
+| 2   | LITT!                    | LITT!                        | AYLØ                | indie r&b        | 2018         | 207758 | 40         | 0.836        | 0.272        | 0.564  | 0.000537         | 0.11     | -7.127   | 0.0424      | 130.005 | 4              |
+| 3   | Confident / Feeling Cool | Enjoy Your Life              | Lady Donli          | nigerian pop     | 2019         | 175135 | 14         | 0.894        | 0.798        | 0.611  | 0.000187         | 0.0964   | -4.961   | 0.113       | 111.087 | 4              |
+| 4   | wanted you               | rare.                        | Odunsi (The Engine) | afropop          | 2018         | 152049 | 25         | 0.702        | 0.116        | 0.833  | 0.91             | 0.348    | -6.044   | 0.0447      | 105.115 | 4              |
+
+1. Få litt informasjon om dataframe, ved å kalle `info()`:
+
+    ```python
+    df.info()
+    ```
+
+   Utdata ser slik ut:
+
+    ```output
+    <class 'pandas.core.frame.DataFrame'>
+    RangeIndex: 530 entries, 0 to 529
+    Data columns (total 16 columns):
+     #   Column            Non-Null Count  Dtype  
+    ---  ------            --------------  -----  
+     0   name              530 non-null    object 
+     1   album             530 non-null    object 
+     2   artist            530 non-null    object 
+     3   artist_top_genre  530 non-null    object 
+     4   release_date      530 non-null    int64  
+     5   length            530 non-null    int64  
+     6   popularity        530 non-null    int64  
+     7   danceability      530 non-null    float64
+     8   acousticness      530 non-null    float64
+     9   energy            530 non-null    float64
+     10  instrumentalness  530 non-null    float64
+     11  liveness          530 non-null    float64
+     12  loudness          530 non-null    float64
+     13  speechiness       530 non-null    float64
+     14  tempo             530 non-null    float64
+     15  time_signature    530 non-null    int64  
+    dtypes: float64(8), int64(4), object(4)
+    memory usage: 66.4+ KB
+    ```
+
+1. Dobbeltsjekk for nullverdier, ved å kalle `isnull()` og verifisere at summen er 0:
+
+    ```python
+    df.isnull().sum()
+    ```
+
+    Ser bra ut:
+
+    ```output
+    name                0
+    album               0
+    artist              0
+    artist_top_genre    0
+    release_date        0
+    length              0
+    popularity          0
+    danceability        0
+    acousticness        0
+    energy              0
+    instrumentalness    0
+    liveness            0
+    loudness            0
+    speechiness         0
+    tempo               0
+    time_signature      0
+    dtype: int64
+    ```
+
+1. Beskriv dataen:
+
+    ```python
+    df.describe()
+    ```
+
+    |       | release_date | length      | popularity | danceability | acousticness | energy   | instrumentalness | liveness | loudness  | speechiness | tempo      | time_signature |
+    | ----- | ------------ | ----------- | ---------- | ------------ | ------------ | -------- | ---------------- | -------- | --------- | ----------- | ---------- | -------------- |
+    | count | 530          | 530         | 530        | 530          | 530          | 530      | 530              | 530      | 530       | 530         | 530        | 530            |
+    | mean  | 2015.390566  | 222298.1698 | 17.507547  | 0.741619     | 0.265412     | 0.760623 | 0.016305         | 0.147308 | -4.953011 | 0.130748    | 116.487864 | 3.986792       |
+    | std   | 3.131688     | 39696.82226 | 18.992212  | 0.117522     | 0.208342     | 0.148533 | 0.090321         | 0.123588 | 2.464186  | 0.092939    | 23.518601  | 0.333701       |
+    | min   | 1998         | 89488       | 0          | 0.255        | 0.000665     | 0.111    | 0                | 0.0283   | -19.362   | 0.0278      | 61.695     | 3              |
+    | 25%   | 2014         | 199305      | 0          | 0.681        | 0.089525     | 0.669    | 0                | 0.07565  | -6.29875  | 0.0591      | 102.96125  | 4              |
+    | 50%   | 2016         | 218509      | 13         | 0.761        | 0.2205       | 0.7845   | 0.000004         | 0.1035   | -4.5585   | 0.09795     | 112.7145   | 4              |
+    | 75%   | 2017         | 242098.5    | 31         | 0.8295       | 0.403        | 0.87575  | 0.000234         | 0.164    | -3.331    | 0.177       | 125.03925  | 4              |
+    | max   | 2020         | 511738      | 73         | 0.966        | 0.954        | 0.995    | 0.91             | 0.811    | 0.582     | 0.514       | 206.007    | 5              |
+
+> 🤔 Hvis vi jobber med clustering, en usupervisert metode som ikke krever merket data, hvorfor viser vi denne dataen med etiketter? I utforskningsfasen av dataen er de nyttige, men de er ikke nødvendige for at clustering-algoritmer skal fungere. Du kan like gjerne fjerne kolonneoverskriftene og referere til dataen med kolonnenummer.
+
+Se på de generelle verdiene i dataen. Merk at popularitet kan være '0', som viser sanger som ikke har noen rangering. La oss fjerne disse snart.
+
+1. Bruk et stolpediagram for å finne de mest populære sjangrene:
+
+    ```python
+    import seaborn as sns
+    
+    top = df['artist_top_genre'].value_counts()
+    plt.figure(figsize=(10,7))
+    sns.barplot(x=top[:5].index,y=top[:5].values)
+    plt.xticks(rotation=45)
+    plt.title('Top genres',color = 'blue')
+    ```
+
+    ![mest populære](../../../../5-Clustering/1-Visualize/images/popular.png)
+
+✅ Hvis du vil se flere toppverdier, endre toppen `[:5]` til en større verdi, eller fjern den for å se alt.
+
+Merk, når toppsjangeren er beskrevet som 'Missing', betyr det at Spotify ikke klassifiserte den, så la oss fjerne den.
+
+1. Fjern manglende data ved å filtrere det ut
+
+    ```python
+    df = df[df['artist_top_genre'] != 'Missing']
+    top = df['artist_top_genre'].value_counts()
+    plt.figure(figsize=(10,7))
+    sns.barplot(x=top.index,y=top.values)
+    plt.xticks(rotation=45)
+    plt.title('Top genres',color = 'blue')
+    ```
+
+    Nå sjekk sjangrene på nytt:
+
+    ![mest populære](../../../../5-Clustering/1-Visualize/images/all-genres.png)
+
+1. De tre toppsjangrene dominerer datasetet. La oss konsentrere oss om `afro dancehall`, `afropop` og `nigerian pop`, og i tillegg filtrere datasetet for å fjerne alt med en popularitetsverdi på 0 (som betyr at det ikke ble klassifisert med en popularitet i datasetet og kan betraktes som støy for våre formål):
+
+    ```python
+    df = df[(df['artist_top_genre'] == 'afro dancehall') | (df['artist_top_genre'] == 'afropop') | (df['artist_top_genre'] == 'nigerian pop')]
+    df = df[(df['popularity'] > 0)]
+    top = df['artist_top_genre'].value_counts()
+    plt.figure(figsize=(10,7))
+    sns.barplot(x=top.index,y=top.values)
+    plt.xticks(rotation=45)
+    plt.title('Top genres',color = 'blue')
+    ```
+
+1. Gjør en rask test for å se om dataen korrelerer på noen spesielt sterk måte:
+
+    ```python
+    corrmat = df.corr(numeric_only=True)
+    f, ax = plt.subplots(figsize=(12, 9))
+    sns.heatmap(corrmat, vmax=.8, square=True)
+    ```
+
+    ![korrelasjoner](../../../../5-Clustering/1-Visualize/images/correlation.png)
+
+    Den eneste sterke korrelasjonen er mellom `energy` og `loudness`, noe som ikke er så overraskende, gitt at høy musikk vanligvis er ganske energisk. Ellers er korrelasjonene relativt svake. Det vil være interessant å se hva en clustering-algoritme kan gjøre med denne dataen.
+
+    > 🎓 Merk at korrelasjon ikke innebærer årsakssammenheng! Vi har bevis på korrelasjon, men ingen bevis på årsakssammenheng. En [morsom nettside](https://tylervigen.com/spurious-correlations) har noen visuelle eksempler som understreker dette poenget.
+
+Er det noen konvergens i dette datasetet rundt en sangs opplevde popularitet og dansbarhet? En FacetGrid viser at det er konsentriske sirkler som stemmer overens, uavhengig av sjanger. Kan det være at nigerianske smaker konvergerer på et visst nivå av dansbarhet for denne sjangeren?  
+
+✅ Prøv forskjellige datapunkter (energy, loudness, speechiness) og flere eller forskjellige musikksjangre. Hva kan du oppdage? Ta en titt på `df.describe()`-tabellen for å se den generelle spredningen av datapunktene.
+
+### Øvelse - datafordeling
+
+Er disse tre sjangrene betydelig forskjellige i oppfatningen av deres dansbarhet, basert på deres popularitet?
+
+1. Undersøk datafordelingen for våre tre toppsjangre for popularitet og dansbarhet langs en gitt x- og y-akse.
+
+    ```python
+    sns.set_theme(style="ticks")
+    
+    g = sns.jointplot(
+        data=df,
+        x="popularity", y="danceability", hue="artist_top_genre",
+        kind="kde",
+    )
+    ```
+
+    Du kan oppdage konsentriske sirkler rundt et generelt konvergenspunkt, som viser fordelingen av punkter.
+
+    > 🎓 Merk at dette eksemplet bruker en KDE (Kernel Density Estimate)-graf som representerer dataen ved hjelp av en kontinuerlig sannsynlighetstetthetskurve. Dette lar oss tolke data når vi jobber med flere fordelinger.
+
+    Generelt sett er de tre sjangrene løst tilpasset når det gjelder deres popularitet og dansbarhet. Å bestemme klynger i denne løst tilpassede dataen vil være en utfordring:
+
+    ![fordeling](../../../../5-Clustering/1-Visualize/images/distribution.png)
+
+1. Lag et spredningsdiagram:
+
+    ```python
+    sns.FacetGrid(df, hue="artist_top_genre", height=5) \
+       .map(plt.scatter, "popularity", "danceability") \
+       .add_legend()
+    ```
+
+    Et spredningsdiagram av de samme aksene viser et lignende mønster av konvergens
+
+    ![Facetgrid](../../../../5-Clustering/1-Visualize/images/facetgrid.png)
+
+Generelt, for clustering, kan du bruke spredningsdiagrammer for å vise klynger av data, så det å mestre denne typen visualisering er veldig nyttig. I neste leksjon vil vi ta denne filtrerte dataen og bruke k-means clustering for å oppdage grupper i denne dataen som ser ut til å overlappe på interessante måter.
+
+---
+
+## 🚀Utfordring
+
+Som forberedelse til neste leksjon, lag et diagram over de forskjellige clustering-algoritmene du kan oppdage og bruke i et produksjonsmiljø. Hvilke typer problemer prøver clustering å adressere?
+
+## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+## Gjennomgang & Selvstudium
+
+Før du bruker clustering-algoritmer, som vi har lært, er det en god idé å forstå naturen til datasetet ditt. Les mer om dette emnet [her](https://www.kdnuggets.com/2019/10/right-clustering-algorithm.html)
+
+[Denne nyttige artikkelen](https://www.freecodecamp.org/news/8-clustering-algorithms-in-machine-learning-that-all-data-scientists-should-know/) gir deg en oversikt over hvordan forskjellige clustering-algoritmer oppfører seg, gitt forskjellige dataformer.
+
+## Oppgave
+
+[Undersøk andre visualiseringer for clustering](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/5-Clustering/1-Visualize/assignment.md

@@ -0,0 +1,25 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "589fa015a5e7d9e67bd629f7d47b53de",
+  "translation_date": "2025-09-05T21:28:34+00:00",
+  "source_file": "5-Clustering/1-Visualize/assignment.md",
+  "language_code": "no"
+}
+-->
+# Utforsk andre visualiseringer for klynging
+
+## Instruksjoner
+
+I denne leksjonen har du jobbet med noen visualiseringsteknikker for å få en forståelse av hvordan du kan plotte dataene dine som forberedelse til klynging. Spesielt er spredningsdiagrammer nyttige for å finne grupper av objekter. Undersøk forskjellige måter og ulike biblioteker for å lage spredningsdiagrammer, og dokumenter arbeidet ditt i en notatbok. Du kan bruke data fra denne leksjonen, andre leksjoner, eller data du selv finner (husk å kreditere kilden i notatboken din). Plot noen data ved hjelp av spredningsdiagrammer og forklar hva du oppdager.
+
+## Vurderingskriterier
+
+| Kriterier | Fremragende                                                   | Tilfredsstillende                                                                        | Trenger forbedring                  |
+| --------- | ------------------------------------------------------------- | --------------------------------------------------------------------------------------- | ----------------------------------- |
+|           | En notatbok presenteres med fem godt dokumenterte spredningsdiagrammer | En notatbok presenteres med færre enn fem spredningsdiagrammer og er mindre godt dokumentert | En ufullstendig notatbok presenteres |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/5-Clustering/1-Visualize/solution/Julia/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+  "translation_date": "2025-09-05T21:28:47+00:00",
+  "source_file": "5-Clustering/1-Visualize/solution/Julia/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/5-Clustering/2-K-Means/README.md

@@ -0,0 +1,261 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "7cdd17338d9bbd7e2171c2cd462eb081",
+  "translation_date": "2025-09-05T21:29:46+00:00",
+  "source_file": "5-Clustering/2-K-Means/README.md",
+  "language_code": "no"
+}
+-->
+# K-Means klynging
+
+## [Pre-forelesningsquiz](https://ff-quizzes.netlify.app/en/ml/)
+
+I denne leksjonen vil du lære hvordan du lager klynger ved hjelp av Scikit-learn og det nigerianske musikkdatasettet du importerte tidligere. Vi skal dekke det grunnleggende om K-Means for klynging. Husk at, som du lærte i den forrige leksjonen, finnes det mange måter å jobbe med klynger på, og metoden du bruker avhenger av dataene dine. Vi skal prøve K-Means siden det er den mest vanlige klyngemetoden. La oss komme i gang!
+
+Begreper du vil lære om:
+
+- Silhuett-score
+- Albuemetoden
+- Inertia
+- Varians
+
+## Introduksjon
+
+[K-Means klynging](https://wikipedia.org/wiki/K-means_clustering) er en metode som stammer fra signalbehandling. Den brukes til å dele og gruppere datasett i 'k' klynger basert på en serie observasjoner. Hver observasjon jobber for å gruppere et gitt datapunkt nærmest sin 'gjennomsnittlige verdi', eller midtpunktet i en klynge.
+
+Klyngene kan visualiseres som [Voronoi-diagrammer](https://wikipedia.org/wiki/Voronoi_diagram), som inkluderer et punkt (eller 'frø') og dets tilhørende område.
+
+![voronoi diagram](../../../../5-Clustering/2-K-Means/images/voronoi.png)
+
+> Infografikk av [Jen Looper](https://twitter.com/jenlooper)
+
+K-Means klyngingsprosessen [utføres i tre trinn](https://scikit-learn.org/stable/modules/clustering.html#k-means):
+
+1. Algoritmen velger et k-antall midtpunkter ved å ta prøver fra datasettet. Deretter gjentas følgende:
+    1. Den tilordner hver prøve til det nærmeste midtpunktet.
+    2. Den lager nye midtpunkter ved å ta gjennomsnittsverdien av alle prøvene som er tilordnet de tidligere midtpunktene.
+    3. Deretter beregner den forskjellen mellom de nye og gamle midtpunktene og gjentar til midtpunktene stabiliseres.
+
+En ulempe med å bruke K-Means er at du må bestemme 'k', altså antallet midtpunkter. Heldigvis kan 'albuemetoden' hjelpe med å estimere en god startverdi for 'k'. Du skal prøve det om et øyeblikk.
+
+## Forutsetninger
+
+Du vil jobbe i denne leksjonens [_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/2-K-Means/notebook.ipynb)-fil, som inkluderer dataimporten og den innledende rengjøringen du gjorde i forrige leksjon.
+
+## Øvelse - forberedelse
+
+Start med å ta en ny titt på sangdataene.
+
+1. Lag et boksplott ved å kalle `boxplot()` for hver kolonne:
+
+    ```python
+    plt.figure(figsize=(20,20), dpi=200)
+    
+    plt.subplot(4,3,1)
+    sns.boxplot(x = 'popularity', data = df)
+    
+    plt.subplot(4,3,2)
+    sns.boxplot(x = 'acousticness', data = df)
+    
+    plt.subplot(4,3,3)
+    sns.boxplot(x = 'energy', data = df)
+    
+    plt.subplot(4,3,4)
+    sns.boxplot(x = 'instrumentalness', data = df)
+    
+    plt.subplot(4,3,5)
+    sns.boxplot(x = 'liveness', data = df)
+    
+    plt.subplot(4,3,6)
+    sns.boxplot(x = 'loudness', data = df)
+    
+    plt.subplot(4,3,7)
+    sns.boxplot(x = 'speechiness', data = df)
+    
+    plt.subplot(4,3,8)
+    sns.boxplot(x = 'tempo', data = df)
+    
+    plt.subplot(4,3,9)
+    sns.boxplot(x = 'time_signature', data = df)
+    
+    plt.subplot(4,3,10)
+    sns.boxplot(x = 'danceability', data = df)
+    
+    plt.subplot(4,3,11)
+    sns.boxplot(x = 'length', data = df)
+    
+    plt.subplot(4,3,12)
+    sns.boxplot(x = 'release_date', data = df)
+    ```
+
+    Disse dataene er litt støyete: ved å observere hver kolonne som et boksplott kan du se uteliggere.
+
+    ![uteliggere](../../../../5-Clustering/2-K-Means/images/boxplots.png)
+
+Du kunne gått gjennom datasettet og fjernet disse uteliggerne, men det ville gjort dataene ganske minimale.
+
+1. For nå, velg hvilke kolonner du vil bruke til klyngingsøvelsen. Velg kolonner med lignende verdier og kod `artist_top_genre`-kolonnen som numeriske data:
+
+    ```python
+    from sklearn.preprocessing import LabelEncoder
+    le = LabelEncoder()
+    
+    X = df.loc[:, ('artist_top_genre','popularity','danceability','acousticness','loudness','energy')]
+    
+    y = df['artist_top_genre']
+    
+    X['artist_top_genre'] = le.fit_transform(X['artist_top_genre'])
+    
+    y = le.transform(y)
+    ```
+
+1. Nå må du velge hvor mange klynger du vil målrette. Du vet at det er 3 sangsjangre som vi har skilt ut fra datasettet, så la oss prøve med 3:
+
+    ```python
+    from sklearn.cluster import KMeans
+    
+    nclusters = 3 
+    seed = 0
+    
+    km = KMeans(n_clusters=nclusters, random_state=seed)
+    km.fit(X)
+    
+    # Predict the cluster for each data point
+    
+    y_cluster_kmeans = km.predict(X)
+    y_cluster_kmeans
+    ```
+
+Du ser en matrise som skrives ut med forutsagte klynger (0, 1 eller 2) for hver rad i dataframen.
+
+1. Bruk denne matrisen til å beregne en 'silhuett-score':
+
+    ```python
+    from sklearn import metrics
+    score = metrics.silhouette_score(X, y_cluster_kmeans)
+    score
+    ```
+
+## Silhuett-score
+
+Se etter en silhuett-score nærmere 1. Denne scoren varierer fra -1 til 1, og hvis scoren er 1, er klyngen tett og godt adskilt fra andre klynger. En verdi nær 0 representerer overlappende klynger med prøver som er veldig nær beslutningsgrensen til naboklyngene. [(Kilde)](https://dzone.com/articles/kmeans-silhouette-score-explained-with-python-exam)
+
+Vår score er **0,53**, altså midt på treet. Dette indikerer at dataene våre ikke er spesielt godt egnet for denne typen klynging, men la oss fortsette.
+
+### Øvelse - bygg en modell
+
+1. Importer `KMeans` og start klyngingsprosessen.
+
+    ```python
+    from sklearn.cluster import KMeans
+    wcss = []
+    
+    for i in range(1, 11):
+        kmeans = KMeans(n_clusters = i, init = 'k-means++', random_state = 42)
+        kmeans.fit(X)
+        wcss.append(kmeans.inertia_)
+    
+    ```
+
+    Det er noen deler her som fortjener en forklaring.
+
+    > 🎓 range: Dette er iterasjonene av klyngingsprosessen.
+
+    > 🎓 random_state: "Bestemmer tilfeldig tallgenerering for initialisering av midtpunkter." [Kilde](https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html#sklearn.cluster.KMeans)
+
+    > 🎓 WCSS: "Summen av kvadrerte avstander innenfor klyngen" måler den kvadrerte gjennomsnittsavstanden for alle punktene innenfor en klynge til klyngens midtpunkt. [Kilde](https://medium.com/@ODSC/unsupervised-learning-evaluating-clusters-bd47eed175ce).
+
+    > 🎓 Inertia: K-Means-algoritmer forsøker å velge midtpunkter for å minimere 'inertia', "et mål på hvor internt sammenhengende klynger er." [Kilde](https://scikit-learn.org/stable/modules/clustering.html). Verdien legges til variabelen wcss ved hver iterasjon.
+
+    > 🎓 k-means++: I [Scikit-learn](https://scikit-learn.org/stable/modules/clustering.html#k-means) kan du bruke 'k-means++'-optimalisering, som "initialiserer midtpunktene til å være (generelt) langt fra hverandre, noe som gir sannsynligvis bedre resultater enn tilfeldig initialisering."
+
+### Albuemetoden
+
+Tidligere antok du at, siden du har målrettet 3 sangsjangre, bør du velge 3 klynger. Men er det tilfelle?
+
+1. Bruk 'albuemetoden' for å være sikker.
+
+    ```python
+    plt.figure(figsize=(10,5))
+    sns.lineplot(x=range(1, 11), y=wcss, marker='o', color='red')
+    plt.title('Elbow')
+    plt.xlabel('Number of clusters')
+    plt.ylabel('WCSS')
+    plt.show()
+    ```
+
+    Bruk variabelen `wcss` som du bygde i forrige steg til å lage et diagram som viser hvor 'knekkpunktet' i albuen er, som indikerer det optimale antallet klynger. Kanskje det **er** 3!
+
+    ![albuemetoden](../../../../5-Clustering/2-K-Means/images/elbow.png)
+
+## Øvelse - vis klyngene
+
+1. Prøv prosessen igjen, denne gangen med tre klynger, og vis klyngene som et spredningsdiagram:
+
+    ```python
+    from sklearn.cluster import KMeans
+    kmeans = KMeans(n_clusters = 3)
+    kmeans.fit(X)
+    labels = kmeans.predict(X)
+    plt.scatter(df['popularity'],df['danceability'],c = labels)
+    plt.xlabel('popularity')
+    plt.ylabel('danceability')
+    plt.show()
+    ```
+
+1. Sjekk modellens nøyaktighet:
+
+    ```python
+    labels = kmeans.labels_
+    
+    correct_labels = sum(y == labels)
+    
+    print("Result: %d out of %d samples were correctly labeled." % (correct_labels, y.size))
+    
+    print('Accuracy score: {0:0.2f}'. format(correct_labels/float(y.size)))
+    ```
+
+    Denne modellens nøyaktighet er ikke særlig god, og formen på klyngene gir deg et hint om hvorfor.
+
+    ![klynger](../../../../5-Clustering/2-K-Means/images/clusters.png)
+
+    Disse dataene er for ubalanserte, for lite korrelerte, og det er for mye varians mellom kolonneverdiene til å klynge godt. Faktisk er klyngene som dannes sannsynligvis sterkt påvirket eller skjevfordelt av de tre sjangerkategoriene vi definerte ovenfor. Det var en læringsprosess!
+
+    I Scikit-learns dokumentasjon kan du se at en modell som denne, med klynger som ikke er særlig godt avgrenset, har et 'varians'-problem:
+
+    ![problematiske modeller](../../../../5-Clustering/2-K-Means/images/problems.png)
+    > Infografikk fra Scikit-learn
+
+## Varians
+
+Varians er definert som "gjennomsnittet av de kvadrerte forskjellene fra gjennomsnittet" [(Kilde)](https://www.mathsisfun.com/data/standard-deviation.html). I konteksten av dette klyngeproblemet refererer det til data der tallene i datasettet har en tendens til å avvike litt for mye fra gjennomsnittet.
+
+✅ Dette er et godt tidspunkt å tenke på alle måtene du kan rette opp dette problemet. Justere dataene litt mer? Bruke andre kolonner? Bruke en annen algoritme? Hint: Prøv [å skalere dataene dine](https://www.mygreatlearning.com/blog/learning-data-science-with-k-means-clustering/) for å normalisere dem og teste andre kolonner.
+
+> Prøv denne '[varianskalkulatoren](https://www.calculatorsoup.com/calculators/statistics/variance-calculator.php)' for å forstå konseptet litt bedre.
+
+---
+
+## 🚀Utfordring
+
+Bruk litt tid på denne notebooken og juster parametere. Kan du forbedre modellens nøyaktighet ved å rense dataene mer (for eksempel fjerne uteliggere)? Du kan bruke vekter for å gi mer vekt til visse datapunkter. Hva annet kan du gjøre for å lage bedre klynger?
+
+Hint: Prøv å skalere dataene dine. Det er kommentert kode i notebooken som legger til standard skalering for å få datakolonnene til å ligne hverandre mer når det gjelder verdier. Du vil oppdage at selv om silhuett-scoren går ned, jevner 'knekkpunktet' i albuegrafen seg ut. Dette skyldes at å la dataene være uskalert gjør at data med mindre varians får mer vekt. Les mer om dette problemet [her](https://stats.stackexchange.com/questions/21222/are-mean-normalization-and-feature-scaling-needed-for-k-means-clustering/21226#21226).
+
+## [Etter-forelesningsquiz](https://ff-quizzes.netlify.app/en/ml/)
+
+## Gjennomgang & Selvstudium
+
+Ta en titt på en K-Means-simulator [som denne](https://user.ceng.metu.edu.tr/~akifakkus/courses/ceng574/k-means/). Du kan bruke dette verktøyet til å visualisere prøvedatapunkter og bestemme midtpunktene deres. Du kan redigere dataens tilfeldighet, antall klynger og antall midtpunkter. Hjelper dette deg med å få en idé om hvordan dataene kan grupperes?
+
+Ta også en titt på [dette handoutet om K-Means](https://stanford.edu/~cpiech/cs221/handouts/kmeans.html) fra Stanford.
+
+## Oppgave
+
+[Prøv forskjellige klyngemetoder](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/5-Clustering/2-K-Means/assignment.md

@@ -0,0 +1,25 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "b8e17eff34ad1680eba2a5d3cf9ffc41",
+  "translation_date": "2025-09-05T21:30:25+00:00",
+  "source_file": "5-Clustering/2-K-Means/assignment.md",
+  "language_code": "no"
+}
+-->
+# Prøv forskjellige klyngemetoder
+
+## Instruksjoner
+
+I denne leksjonen lærte du om K-Means klynging. Noen ganger er K-Means ikke passende for dine data. Lag en notatbok ved å bruke data enten fra disse leksjonene eller fra et annet sted (krediter kilden din) og vis en annen klyngemetode som IKKE bruker K-Means. Hva lærte du? 
+
+## Vurderingskriterier
+
+| Kriterier | Eksemplarisk                                                    | Tilfredsstillende                                                    | Trenger forbedring           |
+| --------- | --------------------------------------------------------------- | -------------------------------------------------------------------- | ---------------------------- |
+|           | En notatbok presenteres med en godt dokumentert klyngemodell    | En notatbok presenteres uten god dokumentasjon og/eller ufullstendig | Ufullstendig arbeid leveres  |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/5-Clustering/2-K-Means/solution/Julia/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+  "translation_date": "2025-09-05T21:30:37+00:00",
+  "source_file": "5-Clustering/2-K-Means/solution/Julia/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/5-Clustering/README.md

@@ -0,0 +1,42 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "b28a3a4911584062772c537b653ebbc7",
+  "translation_date": "2025-09-05T21:25:20+00:00",
+  "source_file": "5-Clustering/README.md",
+  "language_code": "no"
+}
+-->
+# Klusteringsmodeller for maskinlæring
+
+Klustering er en oppgave innen maskinlæring hvor man forsøker å finne objekter som ligner på hverandre og gruppere disse i grupper kalt klynger. Det som skiller klustering fra andre tilnærminger i maskinlæring, er at ting skjer automatisk. Faktisk kan man si at det er det motsatte av veiledet læring.
+
+## Regionalt tema: klusteringsmodeller for en nigeriansk publikums musikksmak 🎧
+
+Nigerias mangfoldige publikum har varierte musikksmaker. Ved å bruke data hentet fra Spotify (inspirert av [denne artikkelen](https://towardsdatascience.com/country-wise-visual-analysis-of-music-taste-using-spotify-api-seaborn-in-python-77f5b749b421)), la oss se på noe av musikken som er populær i Nigeria. Dette datasettet inkluderer informasjon om ulike sangers 'dansbarhet'-score, 'akustisitet', lydstyrke, 'taleinnhold', popularitet og energi. Det vil være interessant å oppdage mønstre i disse dataene!
+
+![En platespiller](../../../5-Clustering/images/turntable.jpg)
+
+> Foto av <a href="https://unsplash.com/@marcelalaskoski?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Marcela Laskoski</a> på <a href="https://unsplash.com/s/photos/nigerian-music?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
+  
+I denne serien med leksjoner vil du oppdage nye måter å analysere data på ved hjelp av klusteringsteknikker. Klustering er spesielt nyttig når datasettet ditt mangler etiketter. Hvis det har etiketter, kan klassifiseringsteknikker som de du lærte i tidligere leksjoner være mer nyttige. Men i tilfeller der du ønsker å gruppere umerkede data, er klustering en flott måte å oppdage mønstre på.
+
+> Det finnes nyttige lavkodeverktøy som kan hjelpe deg med å lære å arbeide med klusteringsmodeller. Prøv [Azure ML for denne oppgaven](https://docs.microsoft.com/learn/modules/create-clustering-model-azure-machine-learning-designer/?WT.mc_id=academic-77952-leestott)
+
+## Leksjoner
+
+1. [Introduksjon til klustering](1-Visualize/README.md)
+2. [K-Means klustering](2-K-Means/README.md)
+
+## Krediteringer
+
+Disse leksjonene ble skrevet med 🎶 av [Jen Looper](https://www.twitter.com/jenlooper) med nyttige vurderinger fra [Rishit Dagli](https://rishit_dagli) og [Muhammad Sakib Khan Inan](https://twitter.com/Sakibinan).
+
+Datasettet [Nigerian Songs](https://www.kaggle.com/sootersaalu/nigerian-songs-spotify) ble hentet fra Kaggle som data fra Spotify.
+
+Nyttige K-Means-eksempler som bidro til å lage denne leksjonen inkluderer denne [iris-utforskningen](https://www.kaggle.com/bburns/iris-exploration-pca-k-means-and-gmm-clustering), denne [introduksjonsnotatboken](https://www.kaggle.com/prashant111/k-means-clustering-with-python), og dette [hypotetiske NGO-eksempelet](https://www.kaggle.com/ankandash/pca-k-means-clustering-hierarchical-clustering).
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/6-NLP/1-Introduction-to-NLP/README.md

@@ -0,0 +1,179 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "1c2ec40cf55c98a028a359c27ef7e45a",
+  "translation_date": "2025-09-05T22:22:25+00:00",
+  "source_file": "6-NLP/1-Introduction-to-NLP/README.md",
+  "language_code": "no"
+}
+-->
+# Introduksjon til naturlig språkbehandling
+
+Denne leksjonen dekker en kort historie og viktige konsepter innen *naturlig språkbehandling*, et underfelt av *datamaskinlingvistikk*.
+
+## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
+
+## Introduksjon
+
+NLP, som det ofte kalles, er et av de mest kjente områdene hvor maskinlæring har blitt anvendt og brukt i produksjonsprogramvare.
+
+✅ Kan du tenke på programvare du bruker hver dag som sannsynligvis har noe NLP innebygd? Hva med tekstbehandlingsprogrammer eller mobilapper du bruker regelmessig?
+
+Du vil lære om:
+
+- **Ideen om språk**. Hvordan språk utviklet seg og hva de viktigste studieområdene har vært.
+- **Definisjon og konsepter**. Du vil også lære definisjoner og konsepter om hvordan datamaskiner behandler tekst, inkludert parsing, grammatikk og identifisering av substantiver og verb. Det er noen kodingsoppgaver i denne leksjonen, og flere viktige konsepter introduseres som du vil lære å kode senere i de neste leksjonene.
+
+## Datamaskinlingvistikk
+
+Datamaskinlingvistikk er et forsknings- og utviklingsområde gjennom mange tiår som studerer hvordan datamaskiner kan arbeide med, og til og med forstå, oversette og kommunisere med språk. Naturlig språkbehandling (NLP) er et relatert felt som fokuserer på hvordan datamaskiner kan behandle 'naturlige', eller menneskelige, språk.
+
+### Eksempel - diktering på telefon
+
+Hvis du noen gang har diktert til telefonen din i stedet for å skrive eller spurt en virtuell assistent et spørsmål, ble talen din konvertert til tekstform og deretter behandlet eller *parset* fra språket du snakket. De oppdagede nøkkelordene ble deretter behandlet til et format som telefonen eller assistenten kunne forstå og handle på.
+
+![forståelse](../../../../6-NLP/1-Introduction-to-NLP/images/comprehension.png)
+> Ekte språklig forståelse er vanskelig! Bilde av [Jen Looper](https://twitter.com/jenlooper)
+
+### Hvordan er denne teknologien mulig?
+
+Dette er mulig fordi noen har skrevet et dataprogram for å gjøre dette. For noen tiår siden forutså noen science fiction-forfattere at folk stort sett ville snakke med datamaskinene sine, og at datamaskinene alltid ville forstå nøyaktig hva de mente. Dessverre viste det seg å være et vanskeligere problem enn mange forestilte seg, og selv om det er et mye bedre forstått problem i dag, er det betydelige utfordringer med å oppnå 'perfekt' naturlig språkbehandling når det gjelder å forstå meningen med en setning. Dette er spesielt vanskelig når det gjelder å forstå humor eller oppdage følelser som sarkasme i en setning.
+
+På dette tidspunktet husker du kanskje skoletimer der læreren dekket grammatiske deler av en setning. I noen land blir elever undervist i grammatikk og lingvistikk som et eget fag, men i mange land er disse temaene inkludert som en del av språkopplæringen: enten ditt førstespråk i barneskolen (lære å lese og skrive) og kanskje et andrespråk i ungdomsskolen eller videregående. Ikke bekymre deg hvis du ikke er ekspert på å skille substantiver fra verb eller adverb fra adjektiver!
+
+Hvis du sliter med forskjellen mellom *presens* og *presens progressiv*, er du ikke alene. Dette er utfordrende for mange mennesker, selv de som har språket som morsmål. Den gode nyheten er at datamaskiner er veldig gode til å anvende formelle regler, og du vil lære å skrive kode som kan *parse* en setning like godt som et menneske. Den større utfordringen du vil undersøke senere er å forstå *meningen* og *følelsen* av en setning.
+
+## Forutsetninger
+
+For denne leksjonen er den viktigste forutsetningen at du kan lese og forstå språket i denne leksjonen. Det er ingen matematiske problemer eller ligninger å løse. Selv om den opprinnelige forfatteren skrev denne leksjonen på engelsk, er den også oversatt til andre språk, så du kan lese en oversettelse. Det er eksempler der flere forskjellige språk brukes (for å sammenligne de forskjellige grammatikkreglene for ulike språk). Disse er *ikke* oversatt, men den forklarende teksten er det, så meningen bør være klar.
+
+For kodingsoppgavene vil du bruke Python, og eksemplene bruker Python 3.8.
+
+I denne delen vil du trenge og bruke:
+
+- **Python 3 forståelse**. Forståelse av programmeringsspråket Python 3, denne leksjonen bruker input, løkker, fillesing, arrays.
+- **Visual Studio Code + utvidelse**. Vi vil bruke Visual Studio Code og dens Python-utvidelse. Du kan også bruke en Python IDE etter eget valg.
+- **TextBlob**. [TextBlob](https://github.com/sloria/TextBlob) er et forenklet tekstbehandlingsbibliotek for Python. Følg instruksjonene på TextBlob-nettstedet for å installere det på systemet ditt (installer også corpora, som vist nedenfor):
+
+   ```bash
+   pip install -U textblob
+   python -m textblob.download_corpora
+   ```
+
+> 💡 Tips: Du kan kjøre Python direkte i VS Code-miljøer. Sjekk [dokumentasjonen](https://code.visualstudio.com/docs/languages/python?WT.mc_id=academic-77952-leestott) for mer informasjon.
+
+## Å snakke med maskiner
+
+Historien om å prøve å få datamaskiner til å forstå menneskelig språk går flere tiår tilbake, og en av de tidligste forskerne som vurderte naturlig språkbehandling var *Alan Turing*.
+
+### 'Turing-testen'
+
+Da Turing forsket på *kunstig intelligens* på 1950-tallet, vurderte han om en samtaletest kunne gis til et menneske og en datamaskin (via skriftlig korrespondanse) der mennesket i samtalen ikke var sikker på om de kommuniserte med et annet menneske eller en datamaskin.
+
+Hvis, etter en viss lengde på samtalen, mennesket ikke kunne avgjøre om svarene kom fra en datamaskin eller ikke, kunne datamaskinen da sies å *tenke*?
+
+### Inspirasjonen - 'imitasjonsspillet'
+
+Ideen til dette kom fra et selskapslek kalt *Imitasjonsspillet* der en utspørrer er alene i et rom og har som oppgave å avgjøre hvem av to personer (i et annet rom) som er henholdsvis mann og kvinne. Utspørreren kan sende notater og må prøve å tenke på spørsmål der de skriftlige svarene avslører kjønnet til den mystiske personen. Selvfølgelig prøver spillerne i det andre rommet å lure utspørreren ved å svare på spørsmål på en måte som villeder eller forvirrer utspørreren, samtidig som de gir inntrykk av å svare ærlig.
+
+### Utviklingen av Eliza
+
+På 1960-tallet utviklet en MIT-forsker ved navn *Joseph Weizenbaum* [*Eliza*](https://wikipedia.org/wiki/ELIZA), en datamaskin-'terapeut' som ville stille mennesket spørsmål og gi inntrykk av å forstå svarene deres. Men selv om Eliza kunne parse en setning og identifisere visse grammatiske konstruksjoner og nøkkelord for å gi et rimelig svar, kunne det ikke sies å *forstå* setningen. Hvis Eliza ble presentert med en setning som følger formatet "**Jeg er** <u>trist</u>", kunne den omorganisere og erstatte ord i setningen for å danne svaret "Hvor lenge har **du vært** <u>trist</u>". 
+
+Dette ga inntrykk av at Eliza forsto utsagnet og stilte et oppfølgingsspørsmål, mens den i virkeligheten endret tid og la til noen ord. Hvis Eliza ikke kunne identifisere et nøkkelord som den hadde et svar for, ville den i stedet gi et tilfeldig svar som kunne være anvendelig for mange forskjellige utsagn. Eliza kunne lett bli lurt, for eksempel hvis en bruker skrev "**Du er** en <u>sykkel</u>", kunne den svare med "Hvor lenge har **jeg vært** en <u>sykkel</u>?", i stedet for et mer fornuftig svar.
+
+[![Chatte med Eliza](https://img.youtube.com/vi/RMK9AphfLco/0.jpg)](https://youtu.be/RMK9AphfLco "Chatte med Eliza")
+
+> 🎥 Klikk på bildet over for en video om det originale ELIZA-programmet
+
+> Merk: Du kan lese den originale beskrivelsen av [Eliza](https://cacm.acm.org/magazines/1966/1/13317-elizaa-computer-program-for-the-study-of-natural-language-communication-between-man-and-machine/abstract) publisert i 1966 hvis du har en ACM-konto. Alternativt kan du lese om Eliza på [wikipedia](https://wikipedia.org/wiki/ELIZA)
+
+## Øvelse - kode en enkel samtalebot
+
+En samtalebot, som Eliza, er et program som henter brukerinput og ser ut til å forstå og svare intelligent. I motsetning til Eliza vil vår bot ikke ha flere regler som gir den inntrykk av å ha en intelligent samtale. I stedet vil vår bot ha én eneste evne, nemlig å holde samtalen i gang med tilfeldige svar som kan fungere i nesten enhver triviell samtale.
+
+### Planen
+
+Dine steg når du bygger en samtalebot:
+
+1. Skriv ut instruksjoner som informerer brukeren om hvordan de skal interagere med boten
+2. Start en løkke
+   1. Aksepter brukerinput
+   2. Hvis brukeren har bedt om å avslutte, avslutt
+   3. Behandle brukerinput og bestem svar (i dette tilfellet er svaret et tilfeldig valg fra en liste over mulige generiske svar)
+   4. Skriv ut svar
+3. Gå tilbake til steg 2
+
+### Bygge boten
+
+La oss lage boten nå. Vi starter med å definere noen fraser.
+
+1. Lag denne boten selv i Python med følgende tilfeldige svar:
+
+    ```python
+    random_responses = ["That is quite interesting, please tell me more.",
+                        "I see. Do go on.",
+                        "Why do you say that?",
+                        "Funny weather we've been having, isn't it?",
+                        "Let's change the subject.",
+                        "Did you catch the game last night?"]
+    ```
+
+    Her er noen eksempler på output for å veilede deg (brukerinput er på linjene som starter med `>`):
+
+    ```output
+    Hello, I am Marvin, the simple robot.
+    You can end this conversation at any time by typing 'bye'
+    After typing each answer, press 'enter'
+    How are you today?
+    > I am good thanks
+    That is quite interesting, please tell me more.
+    > today I went for a walk     
+    Did you catch the game last night?
+    > I did, but my team lost
+    Funny weather we've been having, isn't it?
+    > yes but I hope next week is better
+    Let's change the subject.
+    > ok, lets talk about music
+    Why do you say that?
+    > because I like music!
+    Why do you say that?
+    > bye
+    It was nice talking to you, goodbye!
+    ```
+
+    En mulig løsning på oppgaven er [her](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/1-Introduction-to-NLP/solution/bot.py)
+
+    ✅ Stopp og vurder
+
+    1. Tror du de tilfeldige svarene ville 'lure' noen til å tro at boten faktisk forsto dem?
+    2. Hvilke funksjoner ville boten trenge for å være mer effektiv?
+    3. Hvis en bot virkelig kunne 'forstå' meningen med en setning, ville den trenge å 'huske' meningen med tidligere setninger i en samtale også?
+
+---
+
+## 🚀Utfordring
+
+Velg ett av "stopp og vurder"-elementene ovenfor og prøv enten å implementere dem i kode eller skriv en løsning på papir ved hjelp av pseudokode.
+
+I neste leksjon vil du lære om en rekke andre tilnærminger til parsing av naturlig språk og maskinlæring.
+
+## [Quiz etter leksjonen](https://ff-quizzes.netlify.app/en/ml/)
+
+## Gjennomgang & Selvstudium
+
+Ta en titt på referansene nedenfor som videre lesemuligheter.
+
+### Referanser
+
+1. Schubert, Lenhart, "Computational Linguistics", *The Stanford Encyclopedia of Philosophy* (Spring 2020 Edition), Edward N. Zalta (ed.), URL = <https://plato.stanford.edu/archives/spr2020/entries/computational-linguistics/>.
+2. Princeton University "About WordNet." [WordNet](https://wordnet.princeton.edu/). Princeton University. 2010. 
+
+## Oppgave 
+
+[Søk etter en bot](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/6-NLP/1-Introduction-to-NLP/assignment.md

@@ -0,0 +1,25 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "1d7583e8046dacbb0c056d5ba0a71b16",
+  "translation_date": "2025-09-05T22:23:09+00:00",
+  "source_file": "6-NLP/1-Introduction-to-NLP/assignment.md",
+  "language_code": "no"
+}
+-->
+# Finn en bot
+
+## Instruksjoner
+
+Boter finnes overalt. Din oppgave: finn en og adopter den! Du kan finne dem på nettsider, i bankapplikasjoner og på telefonen, for eksempel når du ringer finansielle tjenester for råd eller kontoinformasjon. Analyser boten og se om du klarer å forvirre den. Hvis du klarer å forvirre boten, hvorfor tror du det skjedde? Skriv en kort rapport om din opplevelse.
+
+## Vurderingskriterier
+
+| Kriterier | Eksemplarisk                                                                                                 | Tilfredsstillende                            | Trenger forbedring    |
+| --------- | ----------------------------------------------------------------------------------------------------------- | -------------------------------------------- | --------------------- |
+|           | En fullstendig side er skrevet, som forklarer den antatte bot-arkitekturen og beskriver din opplevelse med den | En rapport er ufullstendig eller ikke godt undersøkt | Ingen rapport er levert |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/6-NLP/2-Tasks/README.md

@@ -0,0 +1,228 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "5f3cb462e3122e1afe7ab0050ccf2bd3",
+  "translation_date": "2025-09-05T22:13:58+00:00",
+  "source_file": "6-NLP/2-Tasks/README.md",
+  "language_code": "no"
+}
+-->
+# Vanlige oppgaver og teknikker innen naturlig språkprosessering
+
+For de fleste oppgaver innen *naturlig språkprosessering* må teksten som skal behandles brytes ned, analyseres, og resultatene lagres eller kryssrefereres med regler og datasett. Disse oppgavene lar programmereren utlede _meningen_, _intensjonen_ eller bare _frekvensen_ av termer og ord i en tekst.
+
+## [Quiz før forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+La oss utforske vanlige teknikker som brukes i tekstbehandling. Kombinert med maskinlæring hjelper disse teknikkene deg med å analysere store mengder tekst effektivt. Før du bruker ML på disse oppgavene, la oss forstå problemene en NLP-spesialist møter.
+
+## Vanlige oppgaver innen NLP
+
+Det finnes ulike måter å analysere en tekst på. Det er oppgaver du kan utføre, og gjennom disse oppgavene kan du få en forståelse av teksten og trekke konklusjoner. Disse oppgavene utføres vanligvis i en sekvens.
+
+### Tokenisering
+
+Det første de fleste NLP-algoritmer må gjøre, er sannsynligvis å dele opp teksten i tokens, eller ord. Selv om dette høres enkelt ut, kan det være utfordrende å ta hensyn til tegnsetting og ulike språks ord- og setningsavgrensninger. Du må kanskje bruke ulike metoder for å bestemme hvor grensene går.
+
+![tokenisering](../../../../6-NLP/2-Tasks/images/tokenization.png)
+> Tokenisering av en setning fra **Pride and Prejudice**. Infografikk av [Jen Looper](https://twitter.com/jenlooper)
+
+### Embeddings
+
+[Ord-embeddings](https://wikipedia.org/wiki/Word_embedding) er en måte å konvertere tekstdata til numeriske verdier. Embeddings gjøres slik at ord med lignende betydning eller ord som ofte brukes sammen, grupperes sammen.
+
+![ord-embeddings](../../../../6-NLP/2-Tasks/images/embedding.png)
+> "I have the highest respect for your nerves, they are my old friends." - Ord-embeddings for en setning i **Pride and Prejudice**. Infografikk av [Jen Looper](https://twitter.com/jenlooper)
+
+✅ Prøv [dette interessante verktøyet](https://projector.tensorflow.org/) for å eksperimentere med ord-embeddings. Ved å klikke på ett ord vises klynger av lignende ord: 'toy' grupperes med 'disney', 'lego', 'playstation' og 'console'.
+
+### Parsing og ordklassemerking
+
+Hvert ord som er tokenisert, kan merkes som en ordklasse – et substantiv, verb eller adjektiv. Setningen `the quick red fox jumped over the lazy brown dog` kan for eksempel merkes som fox = substantiv, jumped = verb.
+
+![parsing](../../../../6-NLP/2-Tasks/images/parse.png)
+
+> Parsing av en setning fra **Pride and Prejudice**. Infografikk av [Jen Looper](https://twitter.com/jenlooper)
+
+Parsing innebærer å gjenkjenne hvilke ord som er relatert til hverandre i en setning – for eksempel `the quick red fox jumped` er en adjektiv-substantiv-verb-sekvens som er separat fra sekvensen `lazy brown dog`.
+
+### Ord- og frasefrekvenser
+
+En nyttig prosedyre når man analyserer en stor tekstmengde, er å bygge en ordbok over hvert ord eller hver frase av interesse og hvor ofte de forekommer. Frasen `the quick red fox jumped over the lazy brown dog` har en ord-frekvens på 2 for "the".
+
+La oss se på et eksempel der vi teller frekvensen av ord. Rudyard Kiplings dikt "The Winners" inneholder følgende vers:
+
+```output
+What the moral? Who rides may read.
+When the night is thick and the tracks are blind
+A friend at a pinch is a friend, indeed,
+But a fool to wait for the laggard behind.
+Down to Gehenna or up to the Throne,
+He travels the fastest who travels alone.
+```
+
+Siden frasefrekvenser kan være enten store- og småbokstavsfølsomme eller ikke, har frasen `a friend` en frekvens på 2, `the` har en frekvens på 6, og `travels` har en frekvens på 2.
+
+### N-grammer
+
+En tekst kan deles opp i sekvenser av ord med en bestemt lengde: ett ord (unigram), to ord (bigram), tre ord (trigram) eller et hvilket som helst antall ord (n-grammer).
+
+For eksempel gir `the quick red fox jumped over the lazy brown dog` med en n-gram-verdi på 2 følgende n-grammer:
+
+1. the quick  
+2. quick red  
+3. red fox  
+4. fox jumped  
+5. jumped over  
+6. over the  
+7. the lazy  
+8. lazy brown  
+9. brown dog  
+
+Det kan være lettere å visualisere det som en glidende boks over setningen. Her er det for n-grammer med 3 ord, der n-grammet er uthevet i hver setning:
+
+1.   <u>**the quick red**</u> fox jumped over the lazy brown dog  
+2.   the **<u>quick red fox</u>** jumped over the lazy brown dog  
+3.   the quick **<u>red fox jumped</u>** over the lazy brown dog  
+4.   the quick red **<u>fox jumped over</u>** the lazy brown dog  
+5.   the quick red fox **<u>jumped over the</u>** lazy brown dog  
+6.   the quick red fox jumped **<u>over the lazy</u>** brown dog  
+7.   the quick red fox jumped over <u>**the lazy brown**</u> dog  
+8.   the quick red fox jumped over the **<u>lazy brown dog</u>**  
+
+![n-grammer glidende vindu](../../../../6-NLP/2-Tasks/images/n-grams.gif)
+
+> N-gram-verdi på 3: Infografikk av [Jen Looper](https://twitter.com/jenlooper)
+
+### Substantivfrase-ekstraksjon
+
+I de fleste setninger finnes det et substantiv som er subjektet eller objektet i setningen. På engelsk kan det ofte identifiseres ved at det har 'a', 'an' eller 'the' foran seg. Å identifisere subjektet eller objektet i en setning ved å 'ekstrahere substantivfrasen' er en vanlig oppgave i NLP når man forsøker å forstå meningen med en setning.
+
+✅ I setningen "I cannot fix on the hour, or the spot, or the look or the words, which laid the foundation. It is too long ago. I was in the middle before I knew that I had begun.", kan du identifisere substantivfrasene?
+
+I setningen `the quick red fox jumped over the lazy brown dog` er det 2 substantivfraser: **quick red fox** og **lazy brown dog**.
+
+### Sentimentanalyse
+
+En setning eller tekst kan analyseres for sentiment, eller hvor *positiv* eller *negativ* den er. Sentiment måles i *polarisering* og *objektivitet/subjektivitet*. Polarisering måles fra -1,0 til 1,0 (negativ til positiv) og 0,0 til 1,0 (mest objektiv til mest subjektiv).
+
+✅ Senere vil du lære at det finnes ulike måter å bestemme sentiment på ved hjelp av maskinlæring, men én måte er å ha en liste over ord og fraser som er kategorisert som positive eller negative av en menneskelig ekspert, og bruke den modellen på tekst for å beregne en polarisering. Kan du se hvordan dette kan fungere i noen tilfeller og mindre godt i andre?
+
+### Bøyning
+
+Bøyning lar deg ta et ord og finne entalls- eller flertallsformen av ordet.
+
+### Lemmatization
+
+En *lemma* er roten eller grunnordet for en gruppe ord, for eksempel har *flew*, *flies*, *flying* en lemma av verbet *fly*.
+
+Det finnes også nyttige databaser tilgjengelige for NLP-forskere, spesielt:
+
+### WordNet
+
+[WordNet](https://wordnet.princeton.edu/) er en database over ord, synonymer, antonymer og mange andre detaljer for hvert ord på mange forskjellige språk. Den er utrolig nyttig når man forsøker å bygge oversettelser, stavekontroller eller språklige verktøy av alle slag.
+
+## NLP-biblioteker
+
+Heldigvis trenger du ikke bygge alle disse teknikkene selv, da det finnes utmerkede Python-biblioteker som gjør det mye mer tilgjengelig for utviklere som ikke er spesialister på naturlig språkprosessering eller maskinlæring. De neste leksjonene inkluderer flere eksempler på disse, men her vil du lære noen nyttige eksempler som hjelper deg med neste oppgave.
+
+### Øvelse – bruk av `TextBlob`-biblioteket
+
+La oss bruke et bibliotek kalt TextBlob, da det inneholder nyttige API-er for å håndtere denne typen oppgaver. TextBlob "står på skuldrene til giganter som [NLTK](https://nltk.org) og [pattern](https://github.com/clips/pattern), og fungerer godt med begge." Det har en betydelig mengde ML innebygd i sitt API.
+
+> Merk: En nyttig [Quick Start](https://textblob.readthedocs.io/en/dev/quickstart.html#quickstart)-guide er tilgjengelig for TextBlob og anbefales for erfarne Python-utviklere.
+
+Når du forsøker å identifisere *substantivfraser*, tilbyr TextBlob flere alternativer for å finne substantivfraser.
+
+1. Ta en titt på `ConllExtractor`.
+
+    ```python
+    from textblob import TextBlob
+    from textblob.np_extractors import ConllExtractor
+    # import and create a Conll extractor to use later 
+    extractor = ConllExtractor()
+    
+    # later when you need a noun phrase extractor:
+    user_input = input("> ")
+    user_input_blob = TextBlob(user_input, np_extractor=extractor)  # note non-default extractor specified
+    np = user_input_blob.noun_phrases                                    
+    ```
+
+    > Hva skjer her? [ConllExtractor](https://textblob.readthedocs.io/en/dev/api_reference.html?highlight=Conll#textblob.en.np_extractors.ConllExtractor) er "En substantivfrase-ekstraktor som bruker chunk parsing trent med ConLL-2000 treningskorpus." ConLL-2000 refererer til 2000-konferansen om Computational Natural Language Learning. Hvert år arrangerte konferansen en workshop for å takle et vanskelig NLP-problem, og i 2000 var det substantivchunking. En modell ble trent på Wall Street Journal, med "seksjoner 15-18 som treningsdata (211727 tokens) og seksjon 20 som testdata (47377 tokens)". Du kan se prosedyrene som ble brukt [her](https://www.clips.uantwerpen.be/conll2000/chunking/) og [resultatene](https://ifarm.nl/erikt/research/np-chunking.html).
+
+### Utfordring – forbedre boten din med NLP
+
+I forrige leksjon bygde du en veldig enkel Q&A-bot. Nå skal du gjøre Marvin litt mer sympatisk ved å analysere innspillene dine for sentiment og skrive ut et svar som matcher sentimentet. Du må også identifisere en `noun_phrase` og spørre om den.
+
+Stegene dine når du bygger en bedre samtalebot:
+
+1. Skriv ut instruksjoner som forklarer brukeren hvordan de kan samhandle med boten.  
+2. Start en løkke:  
+   1. Godta brukerens input.  
+   2. Hvis brukeren har bedt om å avslutte, avslutt.  
+   3. Behandle brukerens input og bestem passende sentimentrespons.  
+   4. Hvis en substantivfrase oppdages i sentimentet, gjør den til flertall og spør om mer input om det emnet.  
+   5. Skriv ut respons.  
+3. Gå tilbake til steg 2.  
+
+Her er kodeeksempelet for å bestemme sentiment ved hjelp av TextBlob. Merk at det kun er fire *graderinger* av sentimentrespons (du kan ha flere hvis du ønsker):
+
+```python
+if user_input_blob.polarity <= -0.5:
+  response = "Oh dear, that sounds bad. "
+elif user_input_blob.polarity <= 0:
+  response = "Hmm, that's not great. "
+elif user_input_blob.polarity <= 0.5:
+  response = "Well, that sounds positive. "
+elif user_input_blob.polarity <= 1:
+  response = "Wow, that sounds great. "
+```
+
+Her er et eksempel på utdata for å veilede deg (brukerinput er på linjer som starter med >):
+
+```output
+Hello, I am Marvin, the friendly robot.
+You can end this conversation at any time by typing 'bye'
+After typing each answer, press 'enter'
+How are you today?
+> I am ok
+Well, that sounds positive. Can you tell me more?
+> I went for a walk and saw a lovely cat
+Well, that sounds positive. Can you tell me more about lovely cats?
+> cats are the best. But I also have a cool dog
+Wow, that sounds great. Can you tell me more about cool dogs?
+> I have an old hounddog but he is sick
+Hmm, that's not great. Can you tell me more about old hounddogs?
+> bye
+It was nice talking to you, goodbye!
+```
+
+En mulig løsning på oppgaven finner du [her](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/2-Tasks/solution/bot.py).
+
+✅ Kunnskapssjekk
+
+1. Tror du de sympatiske responsene ville 'lure' noen til å tro at boten faktisk forsto dem?  
+2. Gjør identifiseringen av substantivfrasen boten mer 'troverdig'?  
+3. Hvorfor kan det være nyttig å trekke ut en 'substantivfrase' fra en setning?  
+
+---
+
+Implementer boten i kunnskapssjekken ovenfor og test den på en venn. Kan den lure dem? Kan du gjøre boten din mer 'troverdig'?
+
+## 🚀Utfordring
+
+Ta en oppgave fra kunnskapssjekken ovenfor og prøv å implementere den. Test boten på en venn. Kan den lure dem? Kan du gjøre boten din mer 'troverdig'?
+
+## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+## Gjennomgang og selvstudium
+
+I de neste leksjonene vil du lære mer om sentimentanalyse. Undersøk denne interessante teknikken i artikler som disse på [KDNuggets](https://www.kdnuggets.com/tag/nlp).
+
+## Oppgave
+
+[Få en bot til å svare](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/6-NLP/2-Tasks/assignment.md

@@ -0,0 +1,25 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "2efc4c2aba5ed06c780c05539c492ae3",
+  "translation_date": "2025-09-05T22:15:09+00:00",
+  "source_file": "6-NLP/2-Tasks/assignment.md",
+  "language_code": "no"
+}
+-->
+# Få en bot til å svare tilbake
+
+## Instruksjoner
+
+I de siste leksjonene har du programmert en enkel bot som du kan chatte med. Denne boten gir tilfeldige svar helt til du sier 'bye'. Kan du gjøre svarene litt mindre tilfeldige, og få boten til å gi spesifikke svar når du sier bestemte ting, som 'hvorfor' eller 'hvordan'? Tenk litt på hvordan maskinlæring kan gjøre denne typen arbeid mindre manuell når du utvider boten din. Du kan bruke bibliotekene NLTK eller TextBlob for å gjøre oppgavene enklere.
+
+## Vurderingskriterier
+
+| Kriterier | Eksemplarisk                                  | Tilfredsstillende                                | Trenger forbedring      |
+| --------- | --------------------------------------------- | ------------------------------------------------ | ----------------------- |
+|           | En ny bot.py-fil er presentert og dokumentert | En ny bot-fil er presentert, men inneholder feil | En fil er ikke presentert |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/6-NLP/3-Translation-Sentiment/README.md

@@ -0,0 +1,200 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "be03c8182982b87ced155e4e9d1438e8",
+  "translation_date": "2025-09-05T22:24:54+00:00",
+  "source_file": "6-NLP/3-Translation-Sentiment/README.md",
+  "language_code": "no"
+}
+-->
+# Oversettelse og sentimentanalyse med maskinlæring
+
+I de forrige leksjonene lærte du hvordan du bygger en enkel bot ved hjelp av `TextBlob`, et bibliotek som bruker maskinlæring i bakgrunnen for å utføre grunnleggende NLP-oppgaver som å trekke ut substantivfraser. En annen viktig utfordring innen datalingvistikk er nøyaktig _oversettelse_ av en setning fra ett muntlig eller skriftlig språk til et annet.
+
+## [Quiz før forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+Oversettelse er et svært vanskelig problem, forsterket av det faktum at det finnes tusenvis av språk, hver med svært forskjellige grammatikkregler. En tilnærming er å konvertere de formelle grammatikkreglene for ett språk, som engelsk, til en struktur som ikke er språkavhengig, og deretter oversette det ved å konvertere tilbake til et annet språk. Denne tilnærmingen innebærer følgende trinn:
+
+1. **Identifikasjon**. Identifiser eller merk ordene i inngangsspråket som substantiv, verb osv.
+2. **Lag oversettelse**. Produser en direkte oversettelse av hvert ord i målspråkets format.
+
+### Eksempelsentence, engelsk til irsk
+
+På 'engelsk' er setningen _I feel happy_ tre ord i rekkefølgen:
+
+- **subjekt** (I)
+- **verb** (feel)
+- **adjektiv** (happy)
+
+Men på 'irsk' har den samme setningen en helt annen grammatisk struktur – følelser som "*happy*" eller "*sad*" uttrykkes som å være *på* deg.
+
+Den engelske frasen `I feel happy` på irsk ville være `Tá athas orm`. En *bokstavelig* oversettelse ville være `Happy is upon me`.
+
+En irsktalende som oversetter til engelsk ville si `I feel happy`, ikke `Happy is upon me`, fordi de forstår meningen med setningen, selv om ordene og setningsstrukturen er forskjellige.
+
+Den formelle rekkefølgen for setningen på irsk er:
+
+- **verb** (Tá eller is)
+- **adjektiv** (athas, eller happy)
+- **subjekt** (orm, eller upon me)
+
+## Oversettelse
+
+Et naivt oversettelsesprogram kan oversette ord kun, uten å ta hensyn til setningsstrukturen.
+
+✅ Hvis du har lært et andre (eller tredje eller flere) språk som voksen, har du kanskje startet med å tenke på ditt morsmål, oversette et konsept ord for ord i hodet til det andre språket, og deretter si oversettelsen høyt. Dette ligner på hva naive oversettelsesprogrammer for datamaskiner gjør. Det er viktig å komme forbi denne fasen for å oppnå flyt!
+
+Naiv oversettelse fører til dårlige (og noen ganger morsomme) feiltolkninger: `I feel happy` oversettes bokstavelig til `Mise bhraitheann athas` på irsk. Det betyr (bokstavelig talt) `me feel happy` og er ikke en gyldig irsk setning. Selv om engelsk og irsk er språk som snakkes på to nærliggende øyer, er de svært forskjellige språk med ulike grammatikkstrukturer.
+
+> Du kan se noen videoer om irske språktradisjoner, som [denne](https://www.youtube.com/watch?v=mRIaLSdRMMs)
+
+### Tilnærminger med maskinlæring
+
+Så langt har du lært om tilnærmingen med formelle regler for naturlig språkbehandling. En annen tilnærming er å ignorere betydningen av ordene og _i stedet bruke maskinlæring til å oppdage mønstre_. Dette kan fungere i oversettelse hvis du har mye tekst (et *korpus*) eller tekster (*korpora*) på både kilde- og målspråket.
+
+For eksempel, vurder tilfellet med *Pride and Prejudice*, en kjent engelsk roman skrevet av Jane Austen i 1813. Hvis du konsulterer boken på engelsk og en menneskelig oversettelse av boken til *fransk*, kan du oppdage fraser i den ene som er _idiomatisk_ oversatt til den andre. Det skal du gjøre om et øyeblikk.
+
+For eksempel, når en engelsk frase som `I have no money` oversettes bokstavelig til fransk, kan det bli `Je n'ai pas de monnaie`. "Monnaie" er et vanskelig fransk 'falskt kognat', ettersom 'money' og 'monnaie' ikke er synonyme. En bedre oversettelse som et menneske kan gjøre, ville være `Je n'ai pas d'argent`, fordi det bedre formidler betydningen av at du ikke har penger (i stedet for 'småpenger', som er betydningen av 'monnaie').
+
+![monnaie](../../../../6-NLP/3-Translation-Sentiment/images/monnaie.png)
+
+> Bilde av [Jen Looper](https://twitter.com/jenlooper)
+
+Hvis en ML-modell har nok menneskelige oversettelser å bygge en modell på, kan den forbedre nøyaktigheten av oversettelser ved å identifisere vanlige mønstre i tekster som tidligere har blitt oversatt av eksperter som snakker begge språk.
+
+### Øvelse - oversettelse
+
+Du kan bruke `TextBlob` til å oversette setninger. Prøv den berømte første linjen i **Pride and Prejudice**:
+
+```python
+from textblob import TextBlob
+
+blob = TextBlob(
+    "It is a truth universally acknowledged, that a single man in possession of a good fortune, must be in want of a wife!"
+)
+print(blob.translate(to="fr"))
+
+```
+
+`TextBlob` gjør en ganske god jobb med oversettelsen: "C'est une vérité universellement reconnue, qu'un homme célibataire en possession d'une bonne fortune doit avoir besoin d'une femme!". 
+
+Det kan argumenteres for at TextBlobs oversettelse faktisk er langt mer presis enn den franske oversettelsen fra 1932 av boken av V. Leconte og Ch. Pressoir:
+
+"C'est une vérité universelle qu'un célibataire pourvu d'une belle fortune doit avoir envie de se marier, et, si peu que l'on sache de son sentiment à cet egard, lorsqu'il arrive dans une nouvelle résidence, cette idée est si bien fixée dans l'esprit de ses voisins qu'ils le considèrent sur-le-champ comme la propriété légitime de l'une ou l'autre de leurs filles."
+
+I dette tilfellet gjør oversettelsen informert av ML en bedre jobb enn den menneskelige oversetteren som unødvendig legger ord i den opprinnelige forfatterens munn for 'klarhet'.
+
+> Hva skjer her? Og hvorfor er TextBlob så god på oversettelse? Vel, i bakgrunnen bruker den Google Translate, en sofistikert AI som kan analysere millioner av fraser for å forutsi de beste strengene for oppgaven. Det er ingenting manuelt som skjer her, og du trenger en internettforbindelse for å bruke `blob.translate`.
+
+✅ Prøv noen flere setninger. Hva er bedre, ML eller menneskelig oversettelse? I hvilke tilfeller?
+
+## Sentimentanalyse
+
+Et annet område hvor maskinlæring kan fungere svært godt, er sentimentanalyse. En ikke-ML-tilnærming til sentiment er å identifisere ord og fraser som er 'positive' og 'negative'. Deretter, gitt en ny tekst, beregne den totale verdien av de positive, negative og nøytrale ordene for å identifisere den overordnede stemningen. 
+
+Denne tilnærmingen kan lett lures, som du kanskje har sett i Marvin-oppgaven – setningen `Great, that was a wonderful waste of time, I'm glad we are lost on this dark road` er en sarkastisk, negativ setning, men den enkle algoritmen oppdager 'great', 'wonderful', 'glad' som positive og 'waste', 'lost' og 'dark' som negative. Den overordnede stemningen påvirkes av disse motstridende ordene.
+
+✅ Stopp et øyeblikk og tenk på hvordan vi formidler sarkasme som mennesker. Tonefall spiller en stor rolle. Prøv å si frasen "Well, that film was awesome" på forskjellige måter for å oppdage hvordan stemmen din formidler mening.
+
+### ML-tilnærminger
+
+ML-tilnærmingen ville være å manuelt samle negative og positive tekstkropper – tweets, eller filmomtaler, eller hva som helst hvor mennesket har gitt en score *og* en skriftlig mening. Deretter kan NLP-teknikker brukes på meninger og scorer, slik at mønstre dukker opp (f.eks. positive filmomtaler har en tendens til å inneholde frasen 'Oscar worthy' mer enn negative filmomtaler, eller positive restaurantomtaler sier 'gourmet' mye mer enn 'disgusting').
+
+> ⚖️ **Eksempel**: Hvis du jobbet på kontoret til en politiker og det var en ny lov som ble diskutert, kunne velgere skrive til kontoret med e-poster som støtter eller er imot den aktuelle nye loven. La oss si at du fikk i oppgave å lese e-postene og sortere dem i 2 bunker, *for* og *imot*. Hvis det var mange e-poster, kunne du bli overveldet av å forsøke å lese dem alle. Ville det ikke vært fint om en bot kunne lese dem alle for deg, forstå dem og fortelle deg i hvilken bunke hver e-post hørte hjemme? 
+> 
+> En måte å oppnå dette på er å bruke maskinlæring. Du ville trene modellen med en del av *imot*-e-postene og en del av *for*-e-postene. Modellen ville ha en tendens til å assosiere fraser og ord med imot-siden og for-siden, *men den ville ikke forstå noe av innholdet*, bare at visse ord og mønstre var mer sannsynlige å dukke opp i en *imot*- eller en *for*-e-post. Du kunne teste den med noen e-poster som du ikke hadde brukt til å trene modellen, og se om den kom til samme konklusjon som deg. Deretter, når du var fornøyd med modellens nøyaktighet, kunne du behandle fremtidige e-poster uten å måtte lese hver enkelt.
+
+✅ Høres denne prosessen ut som prosesser du har brukt i tidligere leksjoner?
+
+## Øvelse - sentimentale setninger
+
+Sentiment måles med en *polarity* fra -1 til 1, der -1 er den mest negative stemningen, og 1 er den mest positive. Sentiment måles også med en score fra 0 til 1 for objektivitet (0) og subjektivitet (1).
+
+Ta en ny titt på Jane Austens *Pride and Prejudice*. Teksten er tilgjengelig her på [Project Gutenberg](https://www.gutenberg.org/files/1342/1342-h/1342-h.htm). Eksemplet nedenfor viser et kort program som analyserer sentimentet i første og siste setning fra boken og viser dens sentimentpolarity og subjektivitets-/objektivitets-score.
+
+Du bør bruke `TextBlob`-biblioteket (beskrevet ovenfor) for å bestemme `sentiment` (du trenger ikke skrive din egen sentimentkalkulator) i følgende oppgave.
+
+```python
+from textblob import TextBlob
+
+quote1 = """It is a truth universally acknowledged, that a single man in possession of a good fortune, must be in want of a wife."""
+
+quote2 = """Darcy, as well as Elizabeth, really loved them; and they were both ever sensible of the warmest gratitude towards the persons who, by bringing her into Derbyshire, had been the means of uniting them."""
+
+sentiment1 = TextBlob(quote1).sentiment
+sentiment2 = TextBlob(quote2).sentiment
+
+print(quote1 + " has a sentiment of " + str(sentiment1))
+print(quote2 + " has a sentiment of " + str(sentiment2))
+```
+
+Du ser følgende utdata:
+
+```output
+It is a truth universally acknowledged, that a single man in possession of a good fortune, must be in want # of a wife. has a sentiment of Sentiment(polarity=0.20952380952380953, subjectivity=0.27142857142857146)
+
+Darcy, as well as Elizabeth, really loved them; and they were
+     both ever sensible of the warmest gratitude towards the persons
+      who, by bringing her into Derbyshire, had been the means of
+      uniting them. has a sentiment of Sentiment(polarity=0.7, subjectivity=0.8)
+```
+
+## Utfordring - sjekk sentimentpolarity
+
+Din oppgave er å avgjøre, ved hjelp av sentimentpolarity, om *Pride and Prejudice* har flere absolutt positive setninger enn absolutt negative. For denne oppgaven kan du anta at en polarity-score på 1 eller -1 er henholdsvis absolutt positiv eller negativ.
+
+**Trinn:**
+
+1. Last ned en [kopi av Pride and Prejudice](https://www.gutenberg.org/files/1342/1342-h/1342-h.htm) fra Project Gutenberg som en .txt-fil. Fjern metadataene i starten og slutten av filen, slik at bare originalteksten gjenstår.
+2. Åpne filen i Python og trekk ut innholdet som en streng.
+3. Lag en TextBlob ved hjelp av bokstrengen.
+4. Analyser hver setning i boken i en løkke.
+   1. Hvis polariteten er 1 eller -1, lagre setningen i en liste over positive eller negative meldinger.
+5. Til slutt, skriv ut alle de positive og negative setningene (separat) og antallet av hver.
+
+Her er en [eksempelløsning](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/3-Translation-Sentiment/solution/notebook.ipynb).
+
+✅ Kunnskapssjekk
+
+1. Sentimentet er basert på ordene som brukes i setningen, men forstår koden *ordene*?
+2. Synes du sentimentpolarityen er nøyaktig, eller med andre ord, er du *enig* i scorene?
+   1. Spesielt, er du enig eller uenig i den absolutte **positive** polariteten til følgende setninger?
+      * “What an excellent father you have, girls!” said she, when the door was shut.
+      * “Your examination of Mr. Darcy is over, I presume,” said Miss Bingley; “and pray what is the result?” “I am perfectly convinced by it that Mr. Darcy has no defect.
+      * How wonderfully these sort of things occur!
+      * I have the greatest dislike in the world to that sort of thing.
+      * Charlotte is an excellent manager, I dare say.
+      * “This is delightful indeed!
+      * I am so happy!
+      * Your idea of the ponies is delightful.
+   2. De neste 3 setningene ble vurdert med en absolutt positiv sentiment, men ved nærmere lesing er de ikke positive setninger. Hvorfor trodde sentimentanalysen at de var positive setninger?
+      * Happy shall I be, when his stay at Netherfield is over!” “I wish I could say anything to comfort you,” replied Elizabeth; “but it is wholly out of my power.
+      * If I could but see you as happy!
+      * Our distress, my dear Lizzy, is very great.
+   3. Er du enig eller uenig i den absolutte **negative** polariteten til følgende setninger?
+      - Everybody is disgusted with his pride.
+      - “I should like to know how he behaves among strangers.” “You shall hear then—but prepare yourself for something very dreadful.
+      - The pause was to Elizabeth’s feelings dreadful.
+      - It would be dreadful!
+
+✅ Enhver kjenner av Jane Austen vil forstå at hun ofte bruker bøkene sine til å kritisere de mer latterlige aspektene ved det engelske regentsamfunnet. Elizabeth Bennett, hovedpersonen i *Pride and Prejudice*, er en skarp sosial observatør (som forfatteren), og språket hennes er ofte sterkt nyansert. Selv Mr. Darcy (kjærlighetsinteressen i historien) bemerker Elizabeths lekne og ertende bruk av språk: "I have had the pleasure of your acquaintance long enough to know that you find great enjoyment in occasionally professing opinions which in fact are not your own."
+
+---
+
+## 🚀Utfordring
+
+Kan du gjøre Marvin enda bedre ved å trekke ut andre funksjoner fra brukerens input?
+
+## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+## Gjennomgang og selvstudium
+Det finnes mange måter å trekke ut sentiment fra tekst på. Tenk på forretningsapplikasjoner som kan dra nytte av denne teknikken. Tenk også på hvordan det kan gå galt. Les mer om sofistikerte, bedriftsklare systemer som analyserer sentiment, som for eksempel [Azure Text Analysis](https://docs.microsoft.com/azure/cognitive-services/Text-Analytics/how-tos/text-analytics-how-to-sentiment-analysis?tabs=version-3-1?WT.mc_id=academic-77952-leestott). Test noen av setningene fra Stolthet og fordom ovenfor, og se om det kan oppdage nyanser.
+
+## Oppgave
+
+[Poetisk frihet](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/6-NLP/3-Translation-Sentiment/assignment.md

@@ -0,0 +1,25 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "9d2a734deb904caff310d1a999c6bd7a",
+  "translation_date": "2025-09-05T22:25:55+00:00",
+  "source_file": "6-NLP/3-Translation-Sentiment/assignment.md",
+  "language_code": "no"
+}
+-->
+# Poetisk frihet
+
+## Instruksjoner
+
+I [denne notatboken](https://www.kaggle.com/jenlooper/emily-dickinson-word-frequency) finner du over 500 dikt av Emily Dickinson som tidligere er analysert for sentiment ved hjelp av Azure tekstanalyse. Bruk dette datasettet til å analysere det ved hjelp av teknikkene som er beskrevet i leksjonen. Stemmer det foreslåtte sentimentet i et dikt overens med avgjørelsen til den mer avanserte Azure-tjenesten? Hvorfor eller hvorfor ikke, etter din mening? Er det noe som overrasker deg?
+
+## Vurderingskriterier
+
+| Kriterier | Eksemplarisk                                                              | Tilfredsstillende                                       | Trenger forbedring       |
+| --------- | ------------------------------------------------------------------------- | ------------------------------------------------------ | ------------------------ |
+|           | En notatbok presenteres med en grundig analyse av et utvalg fra forfatteren | Notatboken er ufullstendig eller utfører ikke analysen | Ingen notatbok presenteres |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/6-NLP/3-Translation-Sentiment/solution/Julia/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+  "translation_date": "2025-09-05T22:26:29+00:00",
+  "source_file": "6-NLP/3-Translation-Sentiment/solution/Julia/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/6-NLP/3-Translation-Sentiment/solution/R/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
+  "translation_date": "2025-09-05T22:26:16+00:00",
+  "source_file": "6-NLP/3-Translation-Sentiment/solution/R/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/6-NLP/4-Hotel-Reviews-1/README.md

@@ -0,0 +1,417 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "8d32dadeda93c6fb5c43619854882ab1",
+  "translation_date": "2025-09-05T22:18:22+00:00",
+  "source_file": "6-NLP/4-Hotel-Reviews-1/README.md",
+  "language_code": "no"
+}
+-->
+# Sentimentanalyse med hotellanmeldelser - bearbeiding av data
+
+I denne delen vil du bruke teknikkene fra de tidligere leksjonene til å utføre en utforskende dataanalyse av et stort datasett. Når du har fått en god forståelse av nytten av de ulike kolonnene, vil du lære:
+
+- hvordan du fjerner unødvendige kolonner
+- hvordan du beregner ny data basert på eksisterende kolonner
+- hvordan du lagrer det resulterende datasettet for bruk i den endelige utfordringen
+
+## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
+
+### Introduksjon
+
+Så langt har du lært hvordan tekstdata er ganske annerledes enn numeriske datatyper. Hvis det er tekst skrevet eller sagt av et menneske, kan det analyseres for å finne mønstre, frekvenser, sentiment og mening. Denne leksjonen tar deg inn i et ekte datasett med en ekte utfordring: **[515K Hotel Reviews Data in Europe](https://www.kaggle.com/jiashenliu/515k-hotel-reviews-data-in-europe)** som inkluderer en [CC0: Public Domain-lisens](https://creativecommons.org/publicdomain/zero/1.0/). Det ble hentet fra Booking.com fra offentlige kilder. Skaperen av datasettet er Jiashen Liu.
+
+### Forberedelse
+
+Du vil trenge:
+
+* Muligheten til å kjøre .ipynb-notatbøker med Python 3
+* pandas
+* NLTK, [som du bør installere lokalt](https://www.nltk.org/install.html)
+* Datasettet som er tilgjengelig på Kaggle [515K Hotel Reviews Data in Europe](https://www.kaggle.com/jiashenliu/515k-hotel-reviews-data-in-europe). Det er rundt 230 MB ukomprimert. Last det ned til rotmappen `/data` knyttet til disse NLP-leksjonene.
+
+## Utforskende dataanalyse
+
+Denne utfordringen antar at du bygger en hotellanbefalingsbot ved hjelp av sentimentanalyse og gjesteanmeldelsesscorer. Datasettet du vil bruke inkluderer anmeldelser av 1493 forskjellige hoteller i 6 byer.
+
+Ved å bruke Python, et datasett med hotellanmeldelser, og NLTKs sentimentanalyse kan du finne ut:
+
+* Hva er de mest brukte ordene og frasene i anmeldelsene?
+* Korresponderer de offisielle *taggene* som beskriver et hotell med anmeldelsesscorer (f.eks. er det flere negative anmeldelser for et bestemt hotell fra *Familie med små barn* enn fra *Alenereisende*, noe som kanskje indikerer at det er bedre for *Alenereisende*)?
+* Stemmer NLTKs sentimentanalyseresultater overens med den numeriske scoren fra hotellanmelderen?
+
+#### Datasett
+
+La oss utforske datasettet du har lastet ned og lagret lokalt. Åpne filen i en editor som VS Code eller til og med Excel.
+
+Overskriftene i datasettet er som følger:
+
+*Hotel_Address, Additional_Number_of_Scoring, Review_Date, Average_Score, Hotel_Name, Reviewer_Nationality, Negative_Review, Review_Total_Negative_Word_Counts, Total_Number_of_Reviews, Positive_Review, Review_Total_Positive_Word_Counts, Total_Number_of_Reviews_Reviewer_Has_Given, Reviewer_Score, Tags, days_since_review, lat, lng*
+
+Her er de gruppert på en måte som kan være lettere å undersøke: 
+##### Hotellkolonner
+
+* `Hotel_Name`, `Hotel_Address`, `lat` (breddegrad), `lng` (lengdegrad)
+  * Ved å bruke *lat* og *lng* kan du lage et kart med Python som viser hotellplasseringer (kanskje fargekodet for negative og positive anmeldelser)
+  * Hotel_Address er ikke åpenbart nyttig for oss, og vi vil sannsynligvis erstatte det med et land for enklere sortering og søking
+
+**Hotell meta-anmeldelseskolonner**
+
+* `Average_Score`
+  * Ifølge datasettets skaper er denne kolonnen *Gjennomsnittsscore for hotellet, beregnet basert på den nyeste kommentaren det siste året*. Dette virker som en uvanlig måte å beregne scoren på, men det er data som er hentet, så vi kan ta det for god fisk for nå. 
+  
+  ✅ Basert på de andre kolonnene i dette datasettet, kan du tenke på en annen måte å beregne gjennomsnittsscoren på?
+
+* `Total_Number_of_Reviews`
+  * Det totale antallet anmeldelser dette hotellet har mottatt - det er ikke klart (uten å skrive litt kode) om dette refererer til anmeldelsene i datasettet.
+* `Additional_Number_of_Scoring`
+  * Dette betyr at en anmeldelsesscore ble gitt, men ingen positiv eller negativ anmeldelse ble skrevet av anmelderen
+
+**Anmeldelseskolonner**
+
+- `Reviewer_Score`
+  - Dette er en numerisk verdi med maksimalt én desimal mellom minimums- og maksimumsverdiene 2.5 og 10
+  - Det er ikke forklart hvorfor 2.5 er den laveste mulige scoren
+- `Negative_Review`
+  - Hvis en anmelder ikke skrev noe, vil dette feltet ha "**No Negative**"
+  - Merk at en anmelder kan skrive en positiv anmeldelse i kolonnen for Negative Review (f.eks. "det er ingenting dårlig med dette hotellet")
+- `Review_Total_Negative_Word_Counts`
+  - Høyere negative ordtellinger indikerer en lavere score (uten å sjekke sentimentet)
+- `Positive_Review`
+  - Hvis en anmelder ikke skrev noe, vil dette feltet ha "**No Positive**"
+  - Merk at en anmelder kan skrive en negativ anmeldelse i kolonnen for Positive Review (f.eks. "det er ingenting bra med dette hotellet i det hele tatt")
+- `Review_Total_Positive_Word_Counts`
+  - Høyere positive ordtellinger indikerer en høyere score (uten å sjekke sentimentet)
+- `Review_Date` og `days_since_review`
+  - En ferskhets- eller foreldelsesmåling kan brukes på en anmeldelse (eldre anmeldelser er kanskje ikke like nøyaktige som nyere fordi hotellledelsen har endret seg, renoveringer er gjort, eller et basseng er lagt til osv.)
+- `Tags`
+  - Dette er korte beskrivelser som en anmelder kan velge for å beskrive typen gjest de var (f.eks. alene eller familie), typen rom de hadde, lengden på oppholdet og hvordan anmeldelsen ble sendt inn. 
+  - Dessverre er bruken av disse taggene problematisk, se avsnittet nedenfor som diskuterer deres nytteverdi
+
+**Anmelderkolonner**
+
+- `Total_Number_of_Reviews_Reviewer_Has_Given`
+  - Dette kan være en faktor i en anbefalingsmodell, for eksempel hvis du kan fastslå at mer produktive anmeldere med hundrevis av anmeldelser er mer tilbøyelige til å være negative enn positive. Imidlertid er anmelderen av en bestemt anmeldelse ikke identifisert med en unik kode, og kan derfor ikke kobles til et sett med anmeldelser. Det er 30 anmeldere med 100 eller flere anmeldelser, men det er vanskelig å se hvordan dette kan hjelpe anbefalingsmodellen.
+- `Reviewer_Nationality`
+  - Noen kan tro at visse nasjonaliteter er mer tilbøyelige til å gi en positiv eller negativ anmeldelse på grunn av en nasjonal tilbøyelighet. Vær forsiktig med å bygge slike anekdotiske synspunkter inn i modellene dine. Dette er nasjonale (og noen ganger rasemessige) stereotyper, og hver anmelder var en individuell person som skrev en anmeldelse basert på sin opplevelse. Den kan ha blitt filtrert gjennom mange linser som deres tidligere hotellopphold, avstanden de reiste, og deres personlige temperament. Å tro at deres nasjonalitet var årsaken til en anmeldelsesscore er vanskelig å rettferdiggjøre.
+
+##### Eksempler
+
+| Gjennomsnittlig  Score | Totalt Antall   Anmeldelser | Anmelder   Score | Negativ <br />Anmeldelse                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | Positiv   Anmeldelse                 | Tags                                                                                      |
+| ---------------------- | -------------------------- | ---------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------ | ----------------------------------------------------------------------------------------- |
+| 7.8                    | 1945                       | 2.5              | Dette er  for øyeblikket ikke et hotell, men en byggeplass Jeg ble terrorisert fra tidlig morgen og hele dagen med uakseptabel byggestøy mens jeg hvilte etter en lang reise og jobbet på rommet Folk jobbet hele dagen med f.eks. trykkluftbor i de tilstøtende rommene Jeg ba om å bytte rom, men ingen stille rom var tilgjengelig For å gjøre ting verre ble jeg overbelastet Jeg sjekket ut på kvelden siden jeg måtte dra veldig tidlig fly og mottok en passende regning En dag senere gjorde hotellet en annen belastning uten mitt samtykke som oversteg den bookede prisen Det er et forferdelig sted Ikke straff deg selv ved å booke her | Ingenting  Forferdelig sted Hold deg unna | Forretningsreise                                Par Standard Dobbeltrom Bodde 2 netter |
+
+Som du kan se, hadde denne gjesten ikke et hyggelig opphold på dette hotellet. Hotellet har en god gjennomsnittsscore på 7.8 og 1945 anmeldelser, men denne anmelderen ga det 2.5 og skrev 115 ord om hvor negativt oppholdet var. Hvis de ikke skrev noe i Positive_Review-kolonnen, kan du anta at det ikke var noe positivt, men de skrev faktisk 7 ord som advarsel. Hvis vi bare teller ord i stedet for betydningen eller sentimentet av ordene, kan vi få et skjevt bilde av anmelderens intensjon. Merkelig nok er deres score på 2.5 forvirrende, fordi hvis hotelloppholdet var så dårlig, hvorfor gi det noen poeng i det hele tatt? Ved å undersøke datasettet nøye, vil du se at den laveste mulige scoren er 2.5, ikke 0. Den høyeste mulige scoren er 10.
+
+##### Tags
+
+Som nevnt ovenfor, ved første øyekast virker ideen om å bruke `Tags` til å kategorisere data fornuftig. Dessverre er disse taggene ikke standardiserte, noe som betyr at i et gitt hotell kan alternativene være *Enkeltrom*, *Tomannsrom* og *Dobbeltrom*, men i neste hotell er de *Deluxe Enkeltrom*, *Klassisk Queen-rom* og *Executive King-rom*. Disse kan være de samme tingene, men det er så mange variasjoner at valget blir:
+
+1. Forsøke å endre alle begrepene til en enkelt standard, noe som er veldig vanskelig, fordi det ikke er klart hva konverteringsbanen vil være i hvert tilfelle (f.eks. *Klassisk enkeltrom* kartlegges til *Enkeltrom*, men *Superior Queen-rom med hage eller byutsikt* er mye vanskeligere å kartlegge)
+
+1. Vi kan ta en NLP-tilnærming og måle frekvensen av visse begreper som *Alene*, *Forretningsreisende* eller *Familie med små barn* slik de gjelder for hvert hotell, og ta dette med i anbefalingen  
+
+Tags er vanligvis (men ikke alltid) et enkelt felt som inneholder en liste med 5 til 6 kommaseparerte verdier som samsvarer med *Type reise*, *Type gjester*, *Type rom*, *Antall netter* og *Type enhet anmeldelsen ble sendt inn fra*. Imidlertid, fordi noen anmeldere ikke fyller ut hvert felt (de kan la ett være tomt), er verdiene ikke alltid i samme rekkefølge.
+
+Som et eksempel, ta *Type gruppe*. Det er 1025 unike muligheter i dette feltet i `Tags`-kolonnen, og dessverre refererer bare noen av dem til en gruppe (noen er typen rom osv.). Hvis du filtrerer bare de som nevner familie, inneholder resultatene mange *Familierom*-type resultater. Hvis du inkluderer begrepet *med*, dvs. teller *Familie med*-verdier, er resultatene bedre, med over 80,000 av de 515,000 resultatene som inneholder frasen "Familie med små barn" eller "Familie med eldre barn".
+
+Dette betyr at tags-kolonnen ikke er helt ubrukelig for oss, men det vil kreve litt arbeid for å gjøre den nyttig.
+
+##### Gjennomsnittlig hotellscore
+
+Det er en rekke rariteter eller avvik med datasettet som jeg ikke kan finne ut av, men som er illustrert her slik at du er klar over dem når du bygger modellene dine. Hvis du finner ut av det, gi oss beskjed i diskusjonsseksjonen!
+
+Datasettet har følgende kolonner relatert til gjennomsnittsscore og antall anmeldelser: 
+
+1. Hotel_Name
+2. Additional_Number_of_Scoring
+3. Average_Score
+4. Total_Number_of_Reviews
+5. Reviewer_Score  
+
+Hotellet med flest anmeldelser i dette datasettet er *Britannia International Hotel Canary Wharf* med 4789 anmeldelser av 515,000. Men hvis vi ser på verdien `Total_Number_of_Reviews` for dette hotellet, er det 9086. Du kan anta at det er mange flere scorer uten anmeldelser, så kanskje vi bør legge til verdien i kolonnen `Additional_Number_of_Scoring`. Den verdien er 2682, og å legge den til 4789 gir oss 7471, som fortsatt er 1615 mindre enn `Total_Number_of_Reviews`. 
+
+Hvis du tar kolonnen `Average_Score`, kan du anta at det er gjennomsnittet av anmeldelsene i datasettet, men beskrivelsen fra Kaggle er "*Gjennomsnittsscore for hotellet, beregnet basert på den nyeste kommentaren det siste året*". Det virker ikke så nyttig, men vi kan beregne vårt eget gjennomsnitt basert på anmeldelsesscorene i datasettet. Ved å bruke det samme hotellet som et eksempel, er den gjennomsnittlige hotellscoren gitt som 7.1, men den beregnede scoren (gjennomsnittlig anmelder-score *i* datasettet) er 6.8. Dette er nært, men ikke den samme verdien, og vi kan bare gjette at scorene gitt i `Additional_Number_of_Scoring`-anmeldelsene økte gjennomsnittet til 7.1. Dessverre, uten noen måte å teste eller bevise den påstanden, er det vanskelig å bruke eller stole på `Average_Score`, `Additional_Number_of_Scoring` og `Total_Number_of_Reviews` når de er basert på, eller refererer til, data vi ikke har.
+
+For å komplisere ting ytterligere, har hotellet med det nest høyeste antallet anmeldelser en beregnet gjennomsnittsscore på 8.12, og datasettets `Average_Score` er 8.1. Er denne korrekte scoren en tilfeldighet, eller er det første hotellet et avvik? 
+
+På muligheten for at disse hotellene kan være uteliggere, og at kanskje de fleste verdiene stemmer (men noen gjør det ikke av en eller annen grunn), vil vi skrive et kort program neste gang for å utforske verdiene i datasettet og bestemme korrekt bruk (eller ikke-bruk) av verdiene.
+> 🚨 En advarsel
+
+> Når du arbeider med dette datasettet, vil du skrive kode som beregner noe ut fra teksten uten å måtte lese eller analysere teksten selv. Dette er essensen av NLP, å tolke mening eller sentiment uten at en menneskelig person trenger å gjøre det. Det er imidlertid mulig at du vil lese noen av de negative anmeldelsene. Jeg vil sterkt oppfordre deg til å la være, fordi du ikke trenger det. Noen av dem er tullete eller irrelevante negative hotellanmeldelser, som for eksempel "Været var ikke bra", noe som er utenfor hotellets, eller noens, kontroll. Men det finnes også en mørk side ved noen anmeldelser. Noen ganger er de negative anmeldelsene rasistiske, sexistiske eller aldersdiskriminerende. Dette er uheldig, men forventet i et datasett hentet fra en offentlig nettside. Noen anmeldere legger igjen anmeldelser som du kan finne smakløse, ubehagelige eller opprørende. Det er bedre å la koden måle sentimentet enn å lese dem selv og bli opprørt. Når det er sagt, er det en minoritet som skriver slike ting, men de finnes likevel.
+## Øvelse - Datautforskning
+### Last inn dataene
+
+Det er nok å undersøke dataene visuelt, nå skal du skrive litt kode og få noen svar! Denne delen bruker pandas-biblioteket. Din aller første oppgave er å sørge for at du kan laste inn og lese CSV-dataene. Pandas-biblioteket har en rask CSV-laster, og resultatet plasseres i en dataframe, som i tidligere leksjoner. CSV-filen vi laster inn har over en halv million rader, men bare 17 kolonner. Pandas gir deg mange kraftige måter å samhandle med en dataframe på, inkludert muligheten til å utføre operasjoner på hver rad.
+
+Fra nå av i denne leksjonen vil det være kodeeksempler, noen forklaringer av koden og diskusjoner om hva resultatene betyr. Bruk den inkluderte _notebook.ipynb_ for koden din.
+
+La oss starte med å laste inn datafilen du skal bruke:
+
+```python
+# Load the hotel reviews from CSV
+import pandas as pd
+import time
+# importing time so the start and end time can be used to calculate file loading time
+print("Loading data file now, this could take a while depending on file size")
+start = time.time()
+# df is 'DataFrame' - make sure you downloaded the file to the data folder
+df = pd.read_csv('../../data/Hotel_Reviews.csv')
+end = time.time()
+print("Loading took " + str(round(end - start, 2)) + " seconds")
+```
+
+Nå som dataene er lastet inn, kan vi utføre noen operasjoner på dem. Hold denne koden øverst i programmet ditt for neste del.
+
+## Utforsk dataene
+
+I dette tilfellet er dataene allerede *rene*, det betyr at de er klare til å jobbe med og ikke inneholder tegn fra andre språk som kan skape problemer for algoritmer som forventer kun engelske tegn.
+
+✅ Du kan komme til å jobbe med data som krever en viss forhåndsbehandling for å formatere dem før du bruker NLP-teknikker, men ikke denne gangen. Hvis du måtte, hvordan ville du håndtert ikke-engelske tegn?
+
+Ta et øyeblikk for å forsikre deg om at når dataene er lastet inn, kan du utforske dem med kode. Det er veldig lett å ville fokusere på kolonnene `Negative_Review` og `Positive_Review`. De er fylt med naturlig tekst som NLP-algoritmene dine kan prosessere. Men vent! Før du hopper inn i NLP og sentimentanalyse, bør du følge koden nedenfor for å fastslå om verdiene som er gitt i datasettet samsvarer med verdiene du beregner med pandas.
+
+## Dataframe-operasjoner
+
+Den første oppgaven i denne leksjonen er å sjekke om følgende påstander er korrekte ved å skrive litt kode som undersøker dataframen (uten å endre den).
+
+> Som med mange programmeringsoppgaver, finnes det flere måter å løse dette på, men et godt råd er å gjøre det på den enkleste og letteste måten, spesielt hvis det vil være lettere å forstå når du kommer tilbake til denne koden i fremtiden. Med dataframes finnes det et omfattende API som ofte vil ha en effektiv måte å gjøre det du ønsker.
+
+Behandle følgende spørsmål som kodingsoppgaver og prøv å svare på dem uten å se på løsningen.
+
+1. Skriv ut *formen* til dataframen du nettopp har lastet inn (formen er antall rader og kolonner).
+2. Beregn frekvensen for anmeldernasjonaliteter:
+   1. Hvor mange distinkte verdier finnes det i kolonnen `Reviewer_Nationality`, og hva er de?
+   2. Hvilken anmeldernasjonalitet er den vanligste i datasettet (skriv ut land og antall anmeldelser)?
+   3. Hva er de neste 10 mest vanlige nasjonalitetene, og deres frekvens?
+3. Hvilket hotell ble anmeldt oftest for hver av de 10 mest vanlige anmeldernasjonalitetene?
+4. Hvor mange anmeldelser er det per hotell (frekvensen av anmeldelser per hotell) i datasettet?
+5. Selv om det finnes en kolonne `Average_Score` for hvert hotell i datasettet, kan du også beregne en gjennomsnittsscore (ved å ta gjennomsnittet av alle anmelderscorer i datasettet for hvert hotell). Legg til en ny kolonne i dataframen med kolonneoverskriften `Calc_Average_Score` som inneholder den beregnede gjennomsnittsscoren.
+6. Har noen hoteller samme (avrundet til én desimal) `Average_Score` og `Calc_Average_Score`?
+   1. Prøv å skrive en Python-funksjon som tar en Series (rad) som et argument og sammenligner verdiene, og skriver ut en melding når verdiene ikke er like. Bruk deretter `.apply()`-metoden for å prosessere hver rad med funksjonen.
+7. Beregn og skriv ut hvor mange rader som har verdien "No Negative" i kolonnen `Negative_Review`.
+8. Beregn og skriv ut hvor mange rader som har verdien "No Positive" i kolonnen `Positive_Review`.
+9. Beregn og skriv ut hvor mange rader som har verdien "No Positive" i kolonnen `Positive_Review` **og** verdien "No Negative" i kolonnen `Negative_Review`.
+
+### Kodesvar
+
+1. Skriv ut *formen* til dataframen du nettopp har lastet inn (formen er antall rader og kolonner).
+
+   ```python
+   print("The shape of the data (rows, cols) is " + str(df.shape))
+   > The shape of the data (rows, cols) is (515738, 17)
+   ```
+
+2. Beregn frekvensen for anmeldernasjonaliteter:
+
+   1. Hvor mange distinkte verdier finnes det i kolonnen `Reviewer_Nationality`, og hva er de?
+   2. Hvilken anmeldernasjonalitet er den vanligste i datasettet (skriv ut land og antall anmeldelser)?
+
+   ```python
+   # value_counts() creates a Series object that has index and values in this case, the country and the frequency they occur in reviewer nationality
+   nationality_freq = df["Reviewer_Nationality"].value_counts()
+   print("There are " + str(nationality_freq.size) + " different nationalities")
+   # print first and last rows of the Series. Change to nationality_freq.to_string() to print all of the data
+   print(nationality_freq) 
+   
+   There are 227 different nationalities
+    United Kingdom               245246
+    United States of America      35437
+    Australia                     21686
+    Ireland                       14827
+    United Arab Emirates          10235
+                                  ...  
+    Comoros                           1
+    Palau                             1
+    Northern Mariana Islands          1
+    Cape Verde                        1
+    Guinea                            1
+   Name: Reviewer_Nationality, Length: 227, dtype: int64
+   ```
+
+   3. Hva er de neste 10 mest vanlige nasjonalitetene, og deres frekvens?
+
+      ```python
+      print("The highest frequency reviewer nationality is " + str(nationality_freq.index[0]).strip() + " with " + str(nationality_freq[0]) + " reviews.")
+      # Notice there is a leading space on the values, strip() removes that for printing
+      # What is the top 10 most common nationalities and their frequencies?
+      print("The next 10 highest frequency reviewer nationalities are:")
+      print(nationality_freq[1:11].to_string())
+      
+      The highest frequency reviewer nationality is United Kingdom with 245246 reviews.
+      The next 10 highest frequency reviewer nationalities are:
+       United States of America     35437
+       Australia                    21686
+       Ireland                      14827
+       United Arab Emirates         10235
+       Saudi Arabia                  8951
+       Netherlands                   8772
+       Switzerland                   8678
+       Germany                       7941
+       Canada                        7894
+       France                        7296
+      ```
+
+3. Hvilket hotell ble anmeldt oftest for hver av de 10 mest vanlige anmeldernasjonalitetene?
+
+   ```python
+   # What was the most frequently reviewed hotel for the top 10 nationalities
+   # Normally with pandas you will avoid an explicit loop, but wanted to show creating a new dataframe using criteria (don't do this with large amounts of data because it could be very slow)
+   for nat in nationality_freq[:10].index:
+      # First, extract all the rows that match the criteria into a new dataframe
+      nat_df = df[df["Reviewer_Nationality"] == nat]   
+      # Now get the hotel freq
+      freq = nat_df["Hotel_Name"].value_counts()
+      print("The most reviewed hotel for " + str(nat).strip() + " was " + str(freq.index[0]) + " with " + str(freq[0]) + " reviews.") 
+      
+   The most reviewed hotel for United Kingdom was Britannia International Hotel Canary Wharf with 3833 reviews.
+   The most reviewed hotel for United States of America was Hotel Esther a with 423 reviews.
+   The most reviewed hotel for Australia was Park Plaza Westminster Bridge London with 167 reviews.
+   The most reviewed hotel for Ireland was Copthorne Tara Hotel London Kensington with 239 reviews.
+   The most reviewed hotel for United Arab Emirates was Millennium Hotel London Knightsbridge with 129 reviews.
+   The most reviewed hotel for Saudi Arabia was The Cumberland A Guoman Hotel with 142 reviews.
+   The most reviewed hotel for Netherlands was Jaz Amsterdam with 97 reviews.
+   The most reviewed hotel for Switzerland was Hotel Da Vinci with 97 reviews.
+   The most reviewed hotel for Germany was Hotel Da Vinci with 86 reviews.
+   The most reviewed hotel for Canada was St James Court A Taj Hotel London with 61 reviews.
+   ```
+
+4. Hvor mange anmeldelser er det per hotell (frekvensen av anmeldelser per hotell) i datasettet?
+
+   ```python
+   # First create a new dataframe based on the old one, removing the uneeded columns
+   hotel_freq_df = df.drop(["Hotel_Address", "Additional_Number_of_Scoring", "Review_Date", "Average_Score", "Reviewer_Nationality", "Negative_Review", "Review_Total_Negative_Word_Counts", "Positive_Review", "Review_Total_Positive_Word_Counts", "Total_Number_of_Reviews_Reviewer_Has_Given", "Reviewer_Score", "Tags", "days_since_review", "lat", "lng"], axis = 1)
+   
+   # Group the rows by Hotel_Name, count them and put the result in a new column Total_Reviews_Found
+   hotel_freq_df['Total_Reviews_Found'] = hotel_freq_df.groupby('Hotel_Name').transform('count')
+   
+   # Get rid of all the duplicated rows
+   hotel_freq_df = hotel_freq_df.drop_duplicates(subset = ["Hotel_Name"])
+   display(hotel_freq_df) 
+   ```
+   |                 Hotel_Name                 | Total_Number_of_Reviews | Total_Reviews_Found |
+   | :----------------------------------------: | :---------------------: | :-----------------: |
+   | Britannia International Hotel Canary Wharf |          9086           |        4789         |
+   |    Park Plaza Westminster Bridge London    |          12158          |        4169         |
+   |   Copthorne Tara Hotel London Kensington   |          7105           |        3578         |
+   |                    ...                     |           ...           |         ...         |
+   |       Mercure Paris Porte d Orleans        |           110           |         10          |
+   |                Hotel Wagner                |           135           |         10          |
+   |            Hotel Gallitzinberg             |           173           |          8          |
+   
+   Du vil kanskje legge merke til at resultatene *telt i datasettet* ikke samsvarer med verdien i `Total_Number_of_Reviews`. Det er uklart om denne verdien i datasettet representerer det totale antallet anmeldelser hotellet hadde, men ikke alle ble skrapet, eller om det er en annen beregning. `Total_Number_of_Reviews` brukes ikke i modellen på grunn av denne uklarheten.
+
+5. Selv om det finnes en kolonne `Average_Score` for hvert hotell i datasettet, kan du også beregne en gjennomsnittsscore (ved å ta gjennomsnittet av alle anmelderscorer i datasettet for hvert hotell). Legg til en ny kolonne i dataframen med kolonneoverskriften `Calc_Average_Score` som inneholder den beregnede gjennomsnittsscoren. Skriv ut kolonnene `Hotel_Name`, `Average_Score` og `Calc_Average_Score`.
+
+   ```python
+   # define a function that takes a row and performs some calculation with it
+   def get_difference_review_avg(row):
+     return row["Average_Score"] - row["Calc_Average_Score"]
+   
+   # 'mean' is mathematical word for 'average'
+   df['Calc_Average_Score'] = round(df.groupby('Hotel_Name').Reviewer_Score.transform('mean'), 1)
+   
+   # Add a new column with the difference between the two average scores
+   df["Average_Score_Difference"] = df.apply(get_difference_review_avg, axis = 1)
+   
+   # Create a df without all the duplicates of Hotel_Name (so only 1 row per hotel)
+   review_scores_df = df.drop_duplicates(subset = ["Hotel_Name"])
+   
+   # Sort the dataframe to find the lowest and highest average score difference
+   review_scores_df = review_scores_df.sort_values(by=["Average_Score_Difference"])
+   
+   display(review_scores_df[["Average_Score_Difference", "Average_Score", "Calc_Average_Score", "Hotel_Name"]])
+   ```
+
+   Du lurer kanskje også på verdien `Average_Score` og hvorfor den noen ganger er forskjellig fra den beregnede gjennomsnittsscoren. Siden vi ikke kan vite hvorfor noen av verdiene samsvarer, men andre har en forskjell, er det tryggest i dette tilfellet å bruke anmelderscorene vi har for å beregne gjennomsnittet selv. Når det er sagt, er forskjellene vanligvis veldig små. Her er hotellene med størst avvik mellom gjennomsnittet i datasettet og det beregnede gjennomsnittet:
+
+   | Average_Score_Difference | Average_Score | Calc_Average_Score |                                  Hotel_Name |
+   | :----------------------: | :-----------: | :----------------: | ------------------------------------------: |
+   |           -0.8           |      7.7      |        8.5         |                  Best Western Hotel Astoria |
+   |           -0.7           |      8.8      |        9.5         | Hotel Stendhal Place Vend me Paris MGallery |
+   |           -0.7           |      7.5      |        8.2         |               Mercure Paris Porte d Orleans |
+   |           -0.7           |      7.9      |        8.6         |             Renaissance Paris Vendome Hotel |
+   |           -0.5           |      7.0      |        7.5         |                         Hotel Royal Elys es |
+   |           ...            |      ...      |        ...         |                                         ... |
+   |           0.7            |      7.5      |        6.8         |     Mercure Paris Op ra Faubourg Montmartre |
+   |           0.8            |      7.1      |        6.3         |      Holiday Inn Paris Montparnasse Pasteur |
+   |           0.9            |      6.8      |        5.9         |                               Villa Eugenie |
+   |           0.9            |      8.6      |        7.7         |   MARQUIS Faubourg St Honor Relais Ch teaux |
+   |           1.3            |      7.2      |        5.9         |                          Kube Hotel Ice Bar |
+
+   Med bare 1 hotell som har en forskjell i score større enn 1, betyr det at vi sannsynligvis kan ignorere forskjellen og bruke den beregnede gjennomsnittsscoren.
+
+6. Beregn og skriv ut hvor mange rader som har verdien "No Negative" i kolonnen `Negative_Review`.
+
+7. Beregn og skriv ut hvor mange rader som har verdien "No Positive" i kolonnen `Positive_Review`.
+
+8. Beregn og skriv ut hvor mange rader som har verdien "No Positive" i kolonnen `Positive_Review` **og** verdien "No Negative" i kolonnen `Negative_Review`.
+
+   ```python
+   # with lambdas:
+   start = time.time()
+   no_negative_reviews = df.apply(lambda x: True if x['Negative_Review'] == "No Negative" else False , axis=1)
+   print("Number of No Negative reviews: " + str(len(no_negative_reviews[no_negative_reviews == True].index)))
+   
+   no_positive_reviews = df.apply(lambda x: True if x['Positive_Review'] == "No Positive" else False , axis=1)
+   print("Number of No Positive reviews: " + str(len(no_positive_reviews[no_positive_reviews == True].index)))
+   
+   both_no_reviews = df.apply(lambda x: True if x['Negative_Review'] == "No Negative" and x['Positive_Review'] == "No Positive" else False , axis=1)
+   print("Number of both No Negative and No Positive reviews: " + str(len(both_no_reviews[both_no_reviews == True].index)))
+   end = time.time()
+   print("Lambdas took " + str(round(end - start, 2)) + " seconds")
+   
+   Number of No Negative reviews: 127890
+   Number of No Positive reviews: 35946
+   Number of both No Negative and No Positive reviews: 127
+   Lambdas took 9.64 seconds
+   ```
+
+## En annen måte
+
+En annen måte å telle elementer uten Lambdas, og bruke sum for å telle radene:
+
+   ```python
+   # without lambdas (using a mixture of notations to show you can use both)
+   start = time.time()
+   no_negative_reviews = sum(df.Negative_Review == "No Negative")
+   print("Number of No Negative reviews: " + str(no_negative_reviews))
+   
+   no_positive_reviews = sum(df["Positive_Review"] == "No Positive")
+   print("Number of No Positive reviews: " + str(no_positive_reviews))
+   
+   both_no_reviews = sum((df.Negative_Review == "No Negative") & (df.Positive_Review == "No Positive"))
+   print("Number of both No Negative and No Positive reviews: " + str(both_no_reviews))
+   
+   end = time.time()
+   print("Sum took " + str(round(end - start, 2)) + " seconds")
+   
+   Number of No Negative reviews: 127890
+   Number of No Positive reviews: 35946
+   Number of both No Negative and No Positive reviews: 127
+   Sum took 0.19 seconds
+   ```
+
+   Du har kanskje lagt merke til at det er 127 rader som har både "No Negative" og "No Positive" verdier i kolonnene `Negative_Review` og `Positive_Review` henholdsvis. Det betyr at anmelderen ga hotellet en numerisk score, men unnlot å skrive enten en positiv eller negativ anmeldelse. Heldigvis er dette en liten mengde rader (127 av 515738, eller 0,02 %), så det vil sannsynligvis ikke skjevfordele modellen vår eller resultatene i noen bestemt retning, men du hadde kanskje ikke forventet at et datasett med anmeldelser skulle ha rader uten anmeldelser, så det er verdt å utforske dataene for å oppdage slike rader.
+
+Nå som du har utforsket datasettet, vil du i neste leksjon filtrere dataene og legge til litt sentimentanalyse.
+
+---
+## 🚀Utfordring
+
+Denne leksjonen viser, som vi så i tidligere leksjoner, hvor kritisk viktig det er å forstå dataene dine og deres særegenheter før du utfører operasjoner på dem. Tekstbaserte data krever spesielt nøye gransking. Grav gjennom ulike teksttunge datasett og se om du kan oppdage områder som kan introdusere skjevhet eller skjev sentimentanalyse i en modell.
+
+## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+## Gjennomgang og selvstudium
+
+Ta [denne læringsstien om NLP](https://docs.microsoft.com/learn/paths/explore-natural-language-processing/?WT.mc_id=academic-77952-leestott) for å oppdage verktøy du kan prøve når du bygger tale- og teksttunge modeller.
+
+## Oppgave
+
+[NLTK](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/6-NLP/4-Hotel-Reviews-1/assignment.md

@@ -0,0 +1,19 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "bf39bceb833cd628f224941dca8041df",
+  "translation_date": "2025-09-05T22:20:12+00:00",
+  "source_file": "6-NLP/4-Hotel-Reviews-1/assignment.md",
+  "language_code": "no"
+}
+-->
+# NLTK
+
+## Instruksjoner
+
+NLTK er et velkjent bibliotek for bruk innenfor datalingvistikk og NLP. Benytt denne anledningen til å lese gjennom '[NLTK-boken](https://www.nltk.org/book/)' og prøv ut øvelsene der. I denne ikke-vurderte oppgaven vil du bli bedre kjent med dette biblioteket.
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/6-NLP/4-Hotel-Reviews-1/solution/Julia/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+  "translation_date": "2025-09-05T22:20:34+00:00",
+  "source_file": "6-NLP/4-Hotel-Reviews-1/solution/Julia/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/6-NLP/4-Hotel-Reviews-1/solution/R/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
+  "translation_date": "2025-09-05T22:20:25+00:00",
+  "source_file": "6-NLP/4-Hotel-Reviews-1/solution/R/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/6-NLP/5-Hotel-Reviews-2/README.md

@@ -0,0 +1,389 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "2c742993fe95d5bcbb2846eda3d442a1",
+  "translation_date": "2025-09-05T22:28:31+00:00",
+  "source_file": "6-NLP/5-Hotel-Reviews-2/README.md",
+  "language_code": "no"
+}
+-->
+# Sentimentanalyse med hotellanmeldelser
+
+Nå som du har utforsket datasettet i detalj, er det på tide å filtrere kolonnene og deretter bruke NLP-teknikker på datasettet for å få nye innsikter om hotellene.
+
+## [Pre-lecture quiz](https://ff-quizzes.netlify.app/en/ml/)
+
+### Filtrering og sentimentanalyse-operasjoner
+
+Som du sikkert har lagt merke til, har datasettet noen problemer. Noen kolonner er fylt med unyttig informasjon, andre virker feil. Selv om de er korrekte, er det uklart hvordan de ble beregnet, og svarene kan ikke uavhengig verifiseres med dine egne beregninger.
+
+## Oppgave: litt mer databehandling
+
+Rens dataene litt mer. Legg til kolonner som vil være nyttige senere, endre verdiene i andre kolonner, og fjern visse kolonner helt.
+
+1. Innledende kolonnebehandling
+
+   1. Fjern `lat` og `lng`
+
+   2. Erstatt verdiene i `Hotel_Address` med følgende verdier (hvis adressen inneholder navnet på byen og landet, endre det til bare byen og landet).
+
+      Dette er de eneste byene og landene i datasettet:
+
+      Amsterdam, Nederland
+
+      Barcelona, Spania
+
+      London, Storbritannia
+
+      Milano, Italia
+
+      Paris, Frankrike
+
+      Wien, Østerrike 
+
+      ```python
+      def replace_address(row):
+          if "Netherlands" in row["Hotel_Address"]:
+              return "Amsterdam, Netherlands"
+          elif "Barcelona" in row["Hotel_Address"]:
+              return "Barcelona, Spain"
+          elif "United Kingdom" in row["Hotel_Address"]:
+              return "London, United Kingdom"
+          elif "Milan" in row["Hotel_Address"]:        
+              return "Milan, Italy"
+          elif "France" in row["Hotel_Address"]:
+              return "Paris, France"
+          elif "Vienna" in row["Hotel_Address"]:
+              return "Vienna, Austria" 
+      
+      # Replace all the addresses with a shortened, more useful form
+      df["Hotel_Address"] = df.apply(replace_address, axis = 1)
+      # The sum of the value_counts() should add up to the total number of reviews
+      print(df["Hotel_Address"].value_counts())
+      ```
+
+      Nå kan du hente data på landsnivå:
+
+      ```python
+      display(df.groupby("Hotel_Address").agg({"Hotel_Name": "nunique"}))
+      ```
+
+      | Hotel_Address          | Hotel_Name |
+      | :--------------------- | :--------: |
+      | Amsterdam, Nederland   |    105     |
+      | Barcelona, Spania      |    211     |
+      | London, Storbritannia  |    400     |
+      | Milano, Italia         |    162     |
+      | Paris, Frankrike       |    458     |
+      | Wien, Østerrike        |    158     |
+
+2. Behandle hotell-meta-anmeldelseskolonner
+
+   1. Fjern `Additional_Number_of_Scoring`
+
+   2. Erstatt `Total_Number_of_Reviews` med det totale antallet anmeldelser for det hotellet som faktisk er i datasettet 
+
+   3. Erstatt `Average_Score` med vår egen beregnede score
+
+   ```python
+  # Drop `Additional_Number_of_Scoring`
+  df.drop(["Additional_Number_of_Scoring"], axis = 1, inplace=True)
+  # Replace `Total_Number_of_Reviews` and `Average_Score` with our own calculated values
+  df.Total_Number_of_Reviews = df.groupby('Hotel_Name').transform('count')
+  df.Average_Score = round(df.groupby('Hotel_Name').Reviewer_Score.transform('mean'), 1)
+  ```
+
+3. Behandle anmeldelseskolonner
+
+   1. Fjern `Review_Total_Negative_Word_Counts`, `Review_Total_Positive_Word_Counts`, `Review_Date` og `days_since_review`
+
+   2. Behold `Reviewer_Score`, `Negative_Review` og `Positive_Review` som de er
+     
+   3. Behold `Tags` for nå
+
+     - Vi skal gjøre noen ekstra filtreringsoperasjoner på taggene i neste seksjon, og deretter vil taggene bli fjernet
+
+4. Behandle anmelderkolonner
+
+   1. Fjern `Total_Number_of_Reviews_Reviewer_Has_Given`
+  
+   2. Behold `Reviewer_Nationality`
+
+### Tag-kolonner
+
+`Tag`-kolonnen er problematisk siden den er en liste (i tekstform) lagret i kolonnen. Dessverre er rekkefølgen og antallet underseksjoner i denne kolonnen ikke alltid det samme. Det er vanskelig for et menneske å identifisere de riktige frasene som er interessante, fordi det er 515 000 rader og 1427 hoteller, og hver har litt forskjellige alternativer en anmelder kunne velge. Her kommer NLP til nytte. Du kan skanne teksten og finne de vanligste frasene og telle dem.
+
+Dessverre er vi ikke interessert i enkeltord, men flervordsfraser (f.eks. *Forretningsreise*). Å kjøre en flervordsfrekvensfordelingsalgoritme på så mye data (6762646 ord) kan ta ekstremt lang tid, men uten å se på dataene, virker det som om det er en nødvendig utgift. Her kommer utforskende dataanalyse til nytte, fordi du har sett et utvalg av taggene som `[' Forretningsreise  ', ' Alenereisende ', ' Enkeltrom ', ' Bodde 5 netter ', ' Sendt fra en mobil enhet ']`, kan du begynne å spørre om det er mulig å redusere prosesseringen betydelig. Heldigvis er det det - men først må du følge noen få trinn for å fastslå hvilke tagger som er interessante.
+
+### Filtrering av tagger
+
+Husk at målet med datasettet er å legge til sentiment og kolonner som vil hjelpe deg med å velge det beste hotellet (for deg selv eller kanskje en klient som ber deg lage en hotellanbefalingsbot). Du må spørre deg selv om taggene er nyttige eller ikke i det endelige datasettet. Her er en tolkning (hvis du trengte datasettet av andre grunner, kan forskjellige tagger bli inkludert/utelatt):
+
+1. Typen reise er relevant, og det bør beholdes
+2. Typen gjestegruppe er viktig, og det bør beholdes
+3. Typen rom, suite eller studio som gjesten bodde i er irrelevant (alle hoteller har stort sett de samme rommene)
+4. Enheten anmeldelsen ble sendt fra er irrelevant
+5. Antall netter anmelderen bodde *kan* være relevant hvis du tilskriver lengre opphold til at de likte hotellet mer, men det er en svak sammenheng og sannsynligvis irrelevant
+
+Oppsummert, **behold 2 typer tagger og fjern de andre**.
+
+Først vil du ikke telle taggene før de er i et bedre format, så det betyr å fjerne firkantede parenteser og anførselstegn. Du kan gjøre dette på flere måter, men du vil ha den raskeste siden det kan ta lang tid å behandle mye data. Heldigvis har pandas en enkel måte å gjøre hvert av disse trinnene på.
+
+```Python
+# Remove opening and closing brackets
+df.Tags = df.Tags.str.strip("[']")
+# remove all quotes too
+df.Tags = df.Tags.str.replace(" ', '", ",", regex = False)
+```
+
+Hver tag blir noe som: `Forretningsreise, Alenereisende, Enkeltrom, Bodde 5 netter, Sendt fra en mobil enhet`. 
+
+Neste finner vi et problem. Noen anmeldelser, eller rader, har 5 kolonner, noen 3, noen 6. Dette er et resultat av hvordan datasettet ble opprettet, og vanskelig å fikse. Du vil få en frekvenstelling av hver frase, men de er i forskjellig rekkefølge i hver anmeldelse, så tellingen kan være feil, og et hotell kan ikke få en tag tilordnet som det fortjente.
+
+I stedet vil du bruke den forskjellige rekkefølgen til vår fordel, fordi hver tag er flervords, men også separert med komma! Den enkleste måten å gjøre dette på er å opprette 6 midlertidige kolonner med hver tag satt inn i kolonnen som tilsvarer dens rekkefølge i taggen. Du kan deretter slå sammen de 6 kolonnene til én stor kolonne og kjøre `value_counts()`-metoden på den resulterende kolonnen. Ved å skrive ut dette, vil du se at det var 2428 unike tagger. Her er et lite utvalg:
+
+| Tag                            | Count  |
+| ------------------------------ | ------ |
+| Fritidsreise                   | 417778 |
+| Sendt fra en mobil enhet       | 307640 |
+| Par                            | 252294 |
+| Bodde 1 natt                   | 193645 |
+| Bodde 2 netter                 | 133937 |
+| Alenereisende                  | 108545 |
+| Bodde 3 netter                 | 95821  |
+| Forretningsreise               | 82939  |
+| Gruppe                         | 65392  |
+| Familie med små barn           | 61015  |
+| Bodde 4 netter                 | 47817  |
+| Dobbeltrom                     | 35207  |
+| Standard dobbeltrom            | 32248  |
+| Superior dobbeltrom            | 31393  |
+| Familie med eldre barn         | 26349  |
+| Deluxe dobbeltrom              | 24823  |
+| Dobbelt- eller tomannsrom      | 22393  |
+| Bodde 5 netter                 | 20845  |
+| Standard dobbelt- eller tomannsrom | 17483  |
+| Klassisk dobbeltrom            | 16989  |
+| Superior dobbelt- eller tomannsrom | 13570 |
+| 2 rom                          | 12393  |
+
+Noen av de vanlige taggene som `Sendt fra en mobil enhet` er ikke nyttige for oss, så det kan være smart å fjerne dem før du teller fraseforekomst, men det er en så rask operasjon at du kan la dem være og ignorere dem.
+
+### Fjerne tagger for lengden på oppholdet
+
+Å fjerne disse taggene er trinn 1, det reduserer det totale antallet tagger som skal vurderes litt. Merk at du ikke fjerner dem fra datasettet, bare velger å fjerne dem fra vurdering som verdier å telle/beholde i anmeldelsesdatasettet.
+
+| Lengde på opphold | Count  |
+| ------------------ | ------ |
+| Bodde 1 natt      | 193645 |
+| Bodde 2 netter    | 133937 |
+| Bodde 3 netter    | 95821  |
+| Bodde 4 netter    | 47817  |
+| Bodde 5 netter    | 20845  |
+| Bodde 6 netter    | 9776   |
+| Bodde 7 netter    | 7399   |
+| Bodde 8 netter    | 2502   |
+| Bodde 9 netter    | 1293   |
+| ...               | ...    |
+
+Det finnes et stort utvalg av rom, suiter, studioer, leiligheter og så videre. De betyr stort sett det samme og er ikke relevante for deg, så fjern dem fra vurdering.
+
+| Type rom                     | Count |
+| ----------------------------- | ----- |
+| Dobbeltrom                   | 35207 |
+| Standard dobbeltrom          | 32248 |
+| Superior dobbeltrom          | 31393 |
+| Deluxe dobbeltrom            | 24823 |
+| Dobbelt- eller tomannsrom    | 22393 |
+| Standard dobbelt- eller tomannsrom | 17483 |
+| Klassisk dobbeltrom          | 16989 |
+| Superior dobbelt- eller tomannsrom | 13570 |
+
+Til slutt, og dette er gledelig (fordi det ikke tok mye prosessering i det hele tatt), vil du bli igjen med følgende *nyttige* tagger:
+
+| Tag                                           | Count  |
+| --------------------------------------------- | ------ |
+| Fritidsreise                                  | 417778 |
+| Par                                           | 252294 |
+| Alenereisende                                 | 108545 |
+| Forretningsreise                              | 82939  |
+| Gruppe (kombinert med Reisende med venner)    | 67535  |
+| Familie med små barn                          | 61015  |
+| Familie med eldre barn                        | 26349  |
+| Med et kjæledyr                               | 1405   |
+
+Du kan argumentere for at `Reisende med venner` er det samme som `Gruppe` mer eller mindre, og det ville være rimelig å kombinere de to som ovenfor. Koden for å identifisere de riktige taggene finnes i [Tags-notatboken](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/1-notebook.ipynb).
+
+Det siste trinnet er å opprette nye kolonner for hver av disse taggene. Deretter, for hver anmeldelsesrad, hvis `Tag`-kolonnen samsvarer med en av de nye kolonnene, legg til en 1, hvis ikke, legg til en 0. Sluttresultatet vil være en telling av hvor mange anmeldere som valgte dette hotellet (i aggregat) for, for eksempel, forretning vs fritid, eller for å ta med et kjæledyr, og dette er nyttig informasjon når du skal anbefale et hotell.
+
+```python
+# Process the Tags into new columns
+# The file Hotel_Reviews_Tags.py, identifies the most important tags
+# Leisure trip, Couple, Solo traveler, Business trip, Group combined with Travelers with friends, 
+# Family with young children, Family with older children, With a pet
+df["Leisure_trip"] = df.Tags.apply(lambda tag: 1 if "Leisure trip" in tag else 0)
+df["Couple"] = df.Tags.apply(lambda tag: 1 if "Couple" in tag else 0)
+df["Solo_traveler"] = df.Tags.apply(lambda tag: 1 if "Solo traveler" in tag else 0)
+df["Business_trip"] = df.Tags.apply(lambda tag: 1 if "Business trip" in tag else 0)
+df["Group"] = df.Tags.apply(lambda tag: 1 if "Group" in tag or "Travelers with friends" in tag else 0)
+df["Family_with_young_children"] = df.Tags.apply(lambda tag: 1 if "Family with young children" in tag else 0)
+df["Family_with_older_children"] = df.Tags.apply(lambda tag: 1 if "Family with older children" in tag else 0)
+df["With_a_pet"] = df.Tags.apply(lambda tag: 1 if "With a pet" in tag else 0)
+
+```
+
+### Lagre filen
+
+Til slutt, lagre datasettet slik det er nå med et nytt navn.
+
+```python
+df.drop(["Review_Total_Negative_Word_Counts", "Review_Total_Positive_Word_Counts", "days_since_review", "Total_Number_of_Reviews_Reviewer_Has_Given"], axis = 1, inplace=True)
+
+# Saving new data file with calculated columns
+print("Saving results to Hotel_Reviews_Filtered.csv")
+df.to_csv(r'../data/Hotel_Reviews_Filtered.csv', index = False)
+```
+
+## Sentimentanalyse-operasjoner
+
+I denne siste seksjonen skal du bruke sentimentanalyse på anmeldelseskolonnene og lagre resultatene i et datasett.
+
+## Oppgave: last inn og lagre de filtrerte dataene
+
+Merk at du nå laster inn det filtrerte datasettet som ble lagret i forrige seksjon, **ikke** det originale datasettet.
+
+```python
+import time
+import pandas as pd
+import nltk as nltk
+from nltk.corpus import stopwords
+from nltk.sentiment.vader import SentimentIntensityAnalyzer
+nltk.download('vader_lexicon')
+
+# Load the filtered hotel reviews from CSV
+df = pd.read_csv('../../data/Hotel_Reviews_Filtered.csv')
+
+# You code will be added here
+
+
+# Finally remember to save the hotel reviews with new NLP data added
+print("Saving results to Hotel_Reviews_NLP.csv")
+df.to_csv(r'../data/Hotel_Reviews_NLP.csv', index = False)
+```
+
+### Fjerne stoppord
+
+Hvis du skulle kjøre sentimentanalyse på de negative og positive anmeldelseskolonnene, kan det ta lang tid. Testet på en kraftig test-laptop med rask CPU, tok det 12–14 minutter avhengig av hvilken sentimentbibliotek som ble brukt. Det er en (relativt) lang tid, så det er verdt å undersøke om det kan gjøres raskere. 
+
+Å fjerne stoppord, eller vanlige engelske ord som ikke endrer sentimentet i en setning, er det første trinnet. Ved å fjerne dem, bør sentimentanalysen kjøre raskere, men ikke være mindre nøyaktig (siden stoppordene ikke påvirker sentimentet, men de bremser analysen). 
+
+Den lengste negative anmeldelsen var 395 ord, men etter å ha fjernet stoppordene, er den 195 ord.
+
+Å fjerne stoppordene er også en rask operasjon, å fjerne stoppordene fra 2 anmeldelseskolonner over 515 000 rader tok 3,3 sekunder på test-enheten. Det kan ta litt mer eller mindre tid for deg avhengig av enhetens CPU-hastighet, RAM, om du har SSD eller ikke, og noen andre faktorer. Den relativt korte tiden for operasjonen betyr at hvis det forbedrer sentimentanalysen, er det verdt å gjøre.
+
+```python
+from nltk.corpus import stopwords
+
+# Load the hotel reviews from CSV
+df = pd.read_csv("../../data/Hotel_Reviews_Filtered.csv")
+
+# Remove stop words - can be slow for a lot of text!
+# Ryan Han (ryanxjhan on Kaggle) has a great post measuring performance of different stop words removal approaches
+# https://www.kaggle.com/ryanxjhan/fast-stop-words-removal # using the approach that Ryan recommends
+start = time.time()
+cache = set(stopwords.words("english"))
+def remove_stopwords(review):
+    text = " ".join([word for word in review.split() if word not in cache])
+    return text
+
+# Remove the stop words from both columns
+df.Negative_Review = df.Negative_Review.apply(remove_stopwords)   
+df.Positive_Review = df.Positive_Review.apply(remove_stopwords)
+```
+
+### Utføre sentimentanalyse
+
+Nå bør du beregne sentimentanalysen for både negative og positive anmeldelseskolonner, og lagre resultatet i 2 nye kolonner. Testen av sentimentet vil være å sammenligne det med anmelderens score for samme anmeldelse. For eksempel, hvis sentimentet mener den negative anmeldelsen hadde et sentiment på 1 (ekstremt positivt sentiment) og et positivt anmeldelsessentiment på 1, men anmelderen ga hotellet den laveste scoren mulig, så stemmer enten ikke anmeldelsesteksten med scoren, eller sentimentanalysatoren kunne ikke gjenkjenne sentimentet korrekt. Du bør forvente at noen sentimentresultater er helt feil, og ofte vil det være forklarbart, f.eks. anmeldelsen kan være ekstremt sarkastisk "Selvfølgelig ELSKET jeg å sove i et rom uten oppvarming" og sentimentanalysatoren tror det er positivt sentiment, selv om et menneske som leser det ville vite at det var sarkasme.
+NLTK tilbyr forskjellige sentimentanalysatorer som du kan lære med, og du kan bytte dem ut og se om sentimentet blir mer eller mindre nøyaktig. VADER sentimentanalyse brukes her.
+
+> Hutto, C.J. & Gilbert, E.E. (2014). VADER: A Parsimonious Rule-based Model for Sentiment Analysis of Social Media Text. Eighth International Conference on Weblogs and Social Media (ICWSM-14). Ann Arbor, MI, juni 2014.
+
+```python
+from nltk.sentiment.vader import SentimentIntensityAnalyzer
+
+# Create the vader sentiment analyser (there are others in NLTK you can try too)
+vader_sentiment = SentimentIntensityAnalyzer()
+# Hutto, C.J. & Gilbert, E.E. (2014). VADER: A Parsimonious Rule-based Model for Sentiment Analysis of Social Media Text. Eighth International Conference on Weblogs and Social Media (ICWSM-14). Ann Arbor, MI, June 2014.
+
+# There are 3 possibilities of input for a review:
+# It could be "No Negative", in which case, return 0
+# It could be "No Positive", in which case, return 0
+# It could be a review, in which case calculate the sentiment
+def calc_sentiment(review):    
+    if review == "No Negative" or review == "No Positive":
+        return 0
+    return vader_sentiment.polarity_scores(review)["compound"]    
+```
+
+Senere i programmet, når du er klar til å beregne sentiment, kan du bruke det på hver anmeldelse som følger:
+
+```python
+# Add a negative sentiment and positive sentiment column
+print("Calculating sentiment columns for both positive and negative reviews")
+start = time.time()
+df["Negative_Sentiment"] = df.Negative_Review.apply(calc_sentiment)
+df["Positive_Sentiment"] = df.Positive_Review.apply(calc_sentiment)
+end = time.time()
+print("Calculating sentiment took " + str(round(end - start, 2)) + " seconds")
+```
+
+Dette tar omtrent 120 sekunder på min datamaskin, men det vil variere fra datamaskin til datamaskin. Hvis du vil skrive ut resultatene og se om sentimentet samsvarer med anmeldelsen:
+
+```python
+df = df.sort_values(by=["Negative_Sentiment"], ascending=True)
+print(df[["Negative_Review", "Negative_Sentiment"]])
+df = df.sort_values(by=["Positive_Sentiment"], ascending=True)
+print(df[["Positive_Review", "Positive_Sentiment"]])
+```
+
+Det aller siste du må gjøre med filen før du bruker den i utfordringen, er å lagre den! Du bør også vurdere å omorganisere alle de nye kolonnene dine slik at de er enkle å jobbe med (for et menneske er dette en kosmetisk endring).
+
+```python
+# Reorder the columns (This is cosmetic, but to make it easier to explore the data later)
+df = df.reindex(["Hotel_Name", "Hotel_Address", "Total_Number_of_Reviews", "Average_Score", "Reviewer_Score", "Negative_Sentiment", "Positive_Sentiment", "Reviewer_Nationality", "Leisure_trip", "Couple", "Solo_traveler", "Business_trip", "Group", "Family_with_young_children", "Family_with_older_children", "With_a_pet", "Negative_Review", "Positive_Review"], axis=1)
+
+print("Saving results to Hotel_Reviews_NLP.csv")
+df.to_csv(r"../data/Hotel_Reviews_NLP.csv", index = False)
+```
+
+Du bør kjøre hele koden for [analyse-notatboken](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/3-notebook.ipynb) (etter at du har kjørt [filtrerings-notatboken](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/1-notebook.ipynb) for å generere Hotel_Reviews_Filtered.csv-filen).
+
+For å oppsummere, trinnene er:
+
+1. Den originale datasettfilen **Hotel_Reviews.csv** utforskes i forrige leksjon med [utforsker-notatboken](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/4-Hotel-Reviews-1/solution/notebook.ipynb)
+2. Hotel_Reviews.csv filtreres av [filtrerings-notatboken](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/1-notebook.ipynb) og resulterer i **Hotel_Reviews_Filtered.csv**
+3. Hotel_Reviews_Filtered.csv behandles av [sentimentanalyse-notatboken](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/3-notebook.ipynb) og resulterer i **Hotel_Reviews_NLP.csv**
+4. Bruk Hotel_Reviews_NLP.csv i NLP-utfordringen nedenfor
+
+### Konklusjon
+
+Da du startet, hadde du et datasett med kolonner og data, men ikke alt kunne verifiseres eller brukes. Du har utforsket dataene, filtrert ut det du ikke trenger, konvertert tagger til noe nyttig, beregnet dine egne gjennomsnitt, lagt til noen sentimentkolonner og forhåpentligvis lært noen interessante ting om behandling av naturlig tekst.
+
+## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+## Utfordring
+
+Nå som du har analysert datasettet for sentiment, se om du kan bruke strategier du har lært i dette kurset (klustering, kanskje?) for å finne mønstre rundt sentiment.
+
+## Gjennomgang & Selvstudium
+
+Ta [denne Learn-modulen](https://docs.microsoft.com/en-us/learn/modules/classify-user-feedback-with-the-text-analytics-api/?WT.mc_id=academic-77952-leestott) for å lære mer og bruke forskjellige verktøy for å utforske sentiment i tekst.
+
+## Oppgave
+
+[Prøv et annet datasett](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/6-NLP/5-Hotel-Reviews-2/assignment.md

@@ -0,0 +1,25 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "daf144daa552da6a7d442aff6f3e77d8",
+  "translation_date": "2025-09-05T22:29:33+00:00",
+  "source_file": "6-NLP/5-Hotel-Reviews-2/assignment.md",
+  "language_code": "no"
+}
+-->
+# Prøv et annet datasett
+
+## Instruksjoner
+
+Nå som du har lært å bruke NLTK for å tildele sentiment til tekst, prøv et annet datasett. Du vil sannsynligvis måtte gjøre noe databehandling rundt det, så opprett en notatbok og dokumenter tankeprosessen din. Hva oppdager du?
+
+## Vurderingskriterier
+
+| Kriterier | Eksemplarisk                                                                                                   | Tilfredsstillende                         | Trenger forbedring     |
+| --------- | ------------------------------------------------------------------------------------------------------------- | ----------------------------------------- | ---------------------- |
+|           | En komplett notatbok og datasett presenteres med godt dokumenterte celler som forklarer hvordan sentiment tildeles | Notatboken mangler gode forklaringer      | Notatboken har mangler |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/6-NLP/5-Hotel-Reviews-2/solution/Julia/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+  "translation_date": "2025-09-05T22:30:03+00:00",
+  "source_file": "6-NLP/5-Hotel-Reviews-2/solution/Julia/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, ber vi deg være oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/6-NLP/5-Hotel-Reviews-2/solution/R/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
+  "translation_date": "2025-09-05T22:29:48+00:00",
+  "source_file": "6-NLP/5-Hotel-Reviews-2/solution/R/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/6-NLP/README.md

@@ -0,0 +1,38 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "1eb379dc2d0c9940b320732d16083778",
+  "translation_date": "2025-09-05T22:12:17+00:00",
+  "source_file": "6-NLP/README.md",
+  "language_code": "no"
+}
+-->
+# Komme i gang med naturlig språkbehandling
+
+Naturlig språkbehandling (NLP) er evnen til et dataprogram til å forstå menneskelig språk slik det blir snakket og skrevet – referert til som naturlig språk. Det er en komponent av kunstig intelligens (AI). NLP har eksistert i mer enn 50 år og har røtter i lingvistikkens felt. Hele feltet er rettet mot å hjelpe maskiner med å forstå og behandle menneskelig språk. Dette kan deretter brukes til å utføre oppgaver som stavekontroll eller maskinoversettelse. Det har en rekke virkelige anvendelser innen flere felt, inkludert medisinsk forskning, søkemotorer og forretningsanalyse.
+
+## Regionalt tema: Europeiske språk og litteratur og romantiske hoteller i Europa ❤️
+
+I denne delen av læreplanen vil du bli introdusert til en av de mest utbredte bruksområdene for maskinlæring: naturlig språkbehandling (NLP). Avledet fra datalingvistikk, er denne kategorien av kunstig intelligens broen mellom mennesker og maskiner via stemme- eller tekstkommunikasjon.
+
+I disse leksjonene skal vi lære det grunnleggende om NLP ved å bygge små samtaleboter for å forstå hvordan maskinlæring hjelper til med å gjøre disse samtalene mer og mer 'smarte'. Du vil reise tilbake i tid og chatte med Elizabeth Bennett og Mr. Darcy fra Jane Austens klassiske roman, **Stolthet og fordom**, utgitt i 1813. Deretter vil du utvide kunnskapen din ved å lære om sentimentanalyse via hotellanmeldelser i Europa.
+
+![Stolthet og fordom bok og te](../../../6-NLP/images/p&p.jpg)
+> Foto av <a href="https://unsplash.com/@elaineh?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Elaine Howlin</a> på <a href="https://unsplash.com/s/photos/pride-and-prejudice?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
+  
+## Leksjoner
+
+1. [Introduksjon til naturlig språkbehandling](1-Introduction-to-NLP/README.md)
+2. [Vanlige NLP-oppgaver og teknikker](2-Tasks/README.md)
+3. [Oversettelse og sentimentanalyse med maskinlæring](3-Translation-Sentiment/README.md)
+4. [Forberedelse av dataene dine](4-Hotel-Reviews-1/README.md)
+5. [NLTK for sentimentanalyse](5-Hotel-Reviews-2/README.md)
+
+## Krediteringer 
+
+Disse leksjonene om naturlig språkbehandling ble skrevet med ☕ av [Stephen Howell](https://twitter.com/Howell_MSFT)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/6-NLP/data/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "ee0670655c89e4719319764afb113624",
+  "translation_date": "2025-09-05T22:20:47+00:00",
+  "source_file": "6-NLP/data/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/7-TimeSeries/1-Introduction/README.md

@@ -0,0 +1,199 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "662b509c39eee205687726636d0a8455",
+  "translation_date": "2025-09-05T21:21:53+00:00",
+  "source_file": "7-TimeSeries/1-Introduction/README.md",
+  "language_code": "no"
+}
+-->
+# Introduksjon til tidsserieprognoser
+
+![Oppsummering av tidsserier i en sketchnote](../../../../sketchnotes/ml-timeseries.png)
+
+> Sketchnote av [Tomomi Imura](https://www.twitter.com/girlie_mac)
+
+I denne leksjonen og den neste vil du lære litt om tidsserieprognoser, en interessant og verdifull del av en ML-forskers verktøykasse som er litt mindre kjent enn andre emner. Tidsserieprognoser er som en slags "krystallkule": basert på tidligere ytelse av en variabel, som pris, kan du forutsi dens fremtidige potensielle verdi.
+
+[![Introduksjon til tidsserieprognoser](https://img.youtube.com/vi/cBojo1hsHiI/0.jpg)](https://youtu.be/cBojo1hsHiI "Introduksjon til tidsserieprognoser")
+
+> 🎥 Klikk på bildet over for en video om tidsserieprognoser
+
+## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
+
+Det er et nyttig og interessant felt med reell verdi for næringslivet, gitt dets direkte anvendelse på problemer som prissetting, lagerstyring og forsyningskjedeutfordringer. Selv om dype læringsteknikker har begynt å bli brukt for å få mer innsikt og bedre forutsi fremtidig ytelse, forblir tidsserieprognoser et felt som i stor grad er informert av klassiske ML-teknikker.
+
+> Penn States nyttige tidsseriepensum finner du [her](https://online.stat.psu.edu/stat510/lesson/1)
+
+## Introduksjon
+
+Anta at du administrerer en rekke smarte parkeringsmålere som gir data om hvor ofte de brukes og hvor lenge over tid.
+
+> Hva om du kunne forutsi, basert på målerens tidligere ytelse, dens fremtidige verdi i henhold til lovene om tilbud og etterspørsel?
+
+Å forutsi nøyaktig når man skal handle for å oppnå sitt mål er en utfordring som kan takles med tidsserieprognoser. Det ville ikke gjøre folk glade å bli belastet mer i travle tider når de leter etter en parkeringsplass, men det ville være en sikker måte å generere inntekter for å rengjøre gatene!
+
+La oss utforske noen av typene tidsseriealgoritmer og starte en notebook for å rense og forberede noen data. Dataene du vil analysere er hentet fra GEFCom2014 prognosekonkurransen. Det består av 3 år med timebaserte verdier for elektrisitetsforbruk og temperatur mellom 2012 og 2014. Gitt de historiske mønstrene for elektrisitetsforbruk og temperatur, kan du forutsi fremtidige verdier for elektrisitetsforbruk.
+
+I dette eksemplet vil du lære hvordan du forutsier ett tidssteg fremover, ved å bruke kun historiske forbruksdata. Før du starter, er det imidlertid nyttig å forstå hva som skjer bak kulissene.
+
+## Noen definisjoner
+
+Når du møter begrepet "tidsserie", må du forstå dets bruk i flere forskjellige sammenhenger.
+
+🎓 **Tidsserie**
+
+I matematikk er "en tidsserie en serie med datapunkter indeksert (eller listet eller grafet) i tidsrekkefølge. Oftest er en tidsserie en sekvens tatt ved suksessive, jevnt fordelte punkter i tid." Et eksempel på en tidsserie er den daglige sluttverdien av [Dow Jones Industrial Average](https://wikipedia.org/wiki/Time_series). Bruken av tidsserieplott og statistisk modellering er ofte sett i signalbehandling, værprognoser, jordskjelvforutsigelser og andre felt der hendelser oppstår og datapunkter kan plottes over tid.
+
+🎓 **Tidsserieanalyse**
+
+Tidsserieanalyse er analysen av den ovennevnte tidsseriedataen. Tidsseriedata kan ta forskjellige former, inkludert "avbrutte tidsserier" som oppdager mønstre i en tidsseries utvikling før og etter en avbrytende hendelse. Typen analyse som trengs for tidsserien, avhenger av naturen til dataene. Tidsseriedata i seg selv kan ta form av serier med tall eller tegn.
+
+Analysen som skal utføres, bruker en rekke metoder, inkludert frekvensdomene og tidsdomene, lineære og ikke-lineære, og mer. [Lær mer](https://www.itl.nist.gov/div898/handbook/pmc/section4/pmc4.htm) om de mange måtene å analysere denne typen data.
+
+🎓 **Tidsserieprognoser**
+
+Tidsserieprognoser er bruken av en modell for å forutsi fremtidige verdier basert på mønstre vist av tidligere innsamlede data slik de oppstod i fortiden. Selv om det er mulig å bruke regresjonsmodeller for å utforske tidsseriedata, med tidsindekser som x-variabler på et plott, analyseres slike data best ved hjelp av spesielle typer modeller.
+
+Tidsseriedata er en liste med ordnede observasjoner, i motsetning til data som kan analyseres ved lineær regresjon. Den vanligste modellen er ARIMA, et akronym som står for "Autoregressive Integrated Moving Average".
+
+[ARIMA-modeller](https://online.stat.psu.edu/stat510/lesson/1/1.1) "relaterer den nåværende verdien av en serie til tidligere verdier og tidligere prediksjonsfeil." De er mest passende for å analysere tidsdomenedata, der data er ordnet over tid.
+
+> Det finnes flere typer ARIMA-modeller, som du kan lære om [her](https://people.duke.edu/~rnau/411arim.htm) og som du vil berøre i neste leksjon.
+
+I neste leksjon vil du bygge en ARIMA-modell ved hjelp av [Univariate Time Series](https://itl.nist.gov/div898/handbook/pmc/section4/pmc44.htm), som fokuserer på én variabel som endrer sin verdi over tid. Et eksempel på denne typen data er [dette datasettet](https://itl.nist.gov/div898/handbook/pmc/section4/pmc4411.htm) som registrerer den månedlige CO2-konsentrasjonen ved Mauna Loa-observatoriet:
+
+|  CO2   | YearMonth | Year  | Month |
+| :----: | :-------: | :---: | :---: |
+| 330.62 |  1975.04  | 1975  |   1   |
+| 331.40 |  1975.13  | 1975  |   2   |
+| 331.87 |  1975.21  | 1975  |   3   |
+| 333.18 |  1975.29  | 1975  |   4   |
+| 333.92 |  1975.38  | 1975  |   5   |
+| 333.43 |  1975.46  | 1975  |   6   |
+| 331.85 |  1975.54  | 1975  |   7   |
+| 330.01 |  1975.63  | 1975  |   8   |
+| 328.51 |  1975.71  | 1975  |   9   |
+| 328.41 |  1975.79  | 1975  |  10   |
+| 329.25 |  1975.88  | 1975  |  11   |
+| 330.97 |  1975.96  | 1975  |  12   |
+
+✅ Identifiser variabelen som endrer seg over tid i dette datasettet
+
+## Tidsseriedataegenskaper å vurdere
+
+Når du ser på tidsseriedata, kan du legge merke til at det har [visse egenskaper](https://online.stat.psu.edu/stat510/lesson/1/1.1) som du må ta hensyn til og redusere for bedre å forstå mønstrene. Hvis du ser på tidsseriedata som potensielt gir et "signal" du vil analysere, kan disse egenskapene betraktes som "støy". Du må ofte redusere denne "støyen" ved å kompensere for noen av disse egenskapene ved hjelp av statistiske teknikker.
+
+Her er noen begreper du bør kjenne til for å kunne jobbe med tidsserier:
+
+🎓 **Trender**
+
+Trender er definert som målbare økninger og reduksjoner over tid. [Les mer](https://machinelearningmastery.com/time-series-trends-in-python). I sammenheng med tidsserier handler det om hvordan man bruker og, hvis nødvendig, fjerner trender fra tidsserien.
+
+🎓 **[Sesongvariasjon](https://machinelearningmastery.com/time-series-seasonality-with-python/)**
+
+Sesongvariasjon er definert som periodiske svingninger, som for eksempel høytidssalg som kan påvirke salget. [Ta en titt](https://itl.nist.gov/div898/handbook/pmc/section4/pmc443.htm) på hvordan forskjellige typer plott viser sesongvariasjon i data.
+
+🎓 **Avvik**
+
+Avvik er datapunkter som ligger langt unna den normale variansen i dataene.
+
+🎓 **Langsiktig syklus**
+
+Uavhengig av sesongvariasjon kan data vise en langsiktig syklus, som for eksempel en økonomisk nedgang som varer lenger enn ett år.
+
+🎓 **Konstant varians**
+
+Over tid viser noen data konstante svingninger, som energiforbruk per dag og natt.
+
+🎓 **Brå endringer**
+
+Dataene kan vise en brå endring som kan kreve ytterligere analyse. For eksempel førte den plutselige nedstengningen av virksomheter på grunn av COVID til endringer i dataene.
+
+✅ Her er et [eksempel på et tidsserieplott](https://www.kaggle.com/kashnitsky/topic-9-part-1-time-series-analysis-in-python) som viser daglig bruk av in-game valuta over noen år. Kan du identifisere noen av egenskapene som er nevnt ovenfor i disse dataene?
+
+![In-game valuta](../../../../7-TimeSeries/1-Introduction/images/currency.png)
+
+## Øvelse - komme i gang med strømforbruksdata
+
+La oss komme i gang med å lage en tidsseriemodell for å forutsi fremtidig strømforbruk basert på tidligere forbruk.
+
+> Dataene i dette eksemplet er hentet fra GEFCom2014 prognosekonkurransen. Det består av 3 år med timebaserte verdier for elektrisitetsforbruk og temperatur mellom 2012 og 2014.
+>
+> Tao Hong, Pierre Pinson, Shu Fan, Hamidreza Zareipour, Alberto Troccoli og Rob J. Hyndman, "Probabilistic energy forecasting: Global Energy Forecasting Competition 2014 and beyond", International Journal of Forecasting, vol.32, no.3, pp 896-913, juli-september, 2016.
+
+1. I `working`-mappen for denne leksjonen, åpne _notebook.ipynb_-filen. Start med å legge til biblioteker som vil hjelpe deg med å laste inn og visualisere data
+
+    ```python
+    import os
+    import matplotlib.pyplot as plt
+    from common.utils import load_data
+    %matplotlib inline
+    ```
+
+    Merk at du bruker filene fra den inkluderte `common`-mappen som setter opp miljøet ditt og håndterer nedlasting av dataene.
+
+2. Undersøk deretter dataene som en dataframe ved å kalle `load_data()` og `head()`:
+
+    ```python
+    data_dir = './data'
+    energy = load_data(data_dir)[['load']]
+    energy.head()
+    ```
+
+    Du kan se at det er to kolonner som representerer dato og forbruk:
+
+    |                     |  load  |
+    | :-----------------: | :----: |
+    | 2012-01-01 00:00:00 | 2698.0 |
+    | 2012-01-01 01:00:00 | 2558.0 |
+    | 2012-01-01 02:00:00 | 2444.0 |
+    | 2012-01-01 03:00:00 | 2402.0 |
+    | 2012-01-01 04:00:00 | 2403.0 |
+
+3. Nå, plott dataene ved å kalle `plot()`:
+
+    ```python
+    energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
+    plt.xlabel('timestamp', fontsize=12)
+    plt.ylabel('load', fontsize=12)
+    plt.show()
+    ```
+
+    ![energiplott](../../../../7-TimeSeries/1-Introduction/images/energy-plot.png)
+
+4. Nå, plott den første uken i juli 2014, ved å gi den som input til `energy` i `[fra dato]: [til dato]`-mønsteret:
+
+    ```python
+    energy['2014-07-01':'2014-07-07'].plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
+    plt.xlabel('timestamp', fontsize=12)
+    plt.ylabel('load', fontsize=12)
+    plt.show()
+    ```
+
+    ![juli](../../../../7-TimeSeries/1-Introduction/images/july-2014.png)
+
+    Et vakkert plott! Ta en titt på disse plottene og se om du kan identifisere noen av egenskapene som er nevnt ovenfor. Hva kan vi anta ved å visualisere dataene?
+
+I neste leksjon vil du lage en ARIMA-modell for å lage noen prognoser.
+
+---
+
+## 🚀Utfordring
+
+Lag en liste over alle bransjer og forskningsområder du kan tenke deg som vil ha nytte av tidsserieprognoser. Kan du tenke deg en anvendelse av disse teknikkene innen kunst? Innen økonometrikk? Økologi? Detaljhandel? Industri? Finans? Hvor ellers?
+
+## [Quiz etter leksjonen](https://ff-quizzes.netlify.app/en/ml/)
+
+## Gjennomgang & Selvstudium
+
+Selv om vi ikke dekker dem her, brukes nevrale nettverk noen ganger for å forbedre klassiske metoder for tidsserieprognoser. Les mer om dem [i denne artikkelen](https://medium.com/microsoftazure/neural-networks-for-forecasting-financial-and-economic-time-series-6aca370ff412)
+
+## Oppgave
+
+[Visualiser flere tidsserier](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/7-TimeSeries/1-Introduction/assignment.md

@@ -0,0 +1,25 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "d1781b0b92568ea1d119d0a198b576b4",
+  "translation_date": "2025-09-05T21:22:37+00:00",
+  "source_file": "7-TimeSeries/1-Introduction/assignment.md",
+  "language_code": "no"
+}
+-->
+# Visualiser noen flere tidsserier
+
+## Instruksjoner
+
+Du har begynt å lære om tidsserieprognoser ved å se på typen data som krever denne spesielle modelleringen. Du har visualisert noen data knyttet til energi. Nå, se deg rundt etter andre data som kan dra nytte av tidsserieprognoser. Finn tre eksempler (prøv [Kaggle](https://kaggle.com) og [Azure Open Datasets](https://azure.microsoft.com/en-us/services/open-datasets/catalog/?WT.mc_id=academic-77952-leestott)) og lag en notatbok for å visualisere dem. Noter eventuelle spesielle egenskaper de har (sesongvariasjoner, brå endringer eller andre trender) i notatboken.
+
+## Vurderingskriterier
+
+| Kriterier | Eksemplarisk                                           | Tilfredsstillende                                   | Trenger forbedring                                                                       |
+| --------- | ------------------------------------------------------ | -------------------------------------------------- | --------------------------------------------------------------------------------------- |
+|           | Tre datasett er plottet og forklart i en notatbok      | To datasett er plottet og forklart i en notatbok   | Få datasett er plottet eller forklart i en notatbok, eller dataene som presenteres er utilstrekkelige |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/7-TimeSeries/1-Introduction/solution/Julia/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+  "translation_date": "2025-09-05T21:23:00+00:00",
+  "source_file": "7-TimeSeries/1-Introduction/solution/Julia/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/7-TimeSeries/1-Introduction/solution/R/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
+  "translation_date": "2025-09-05T21:22:51+00:00",
+  "source_file": "7-TimeSeries/1-Introduction/solution/R/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/7-TimeSeries/2-ARIMA/README.md

@@ -0,0 +1,407 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "917dbf890db71a322f306050cb284749",
+  "translation_date": "2025-09-05T21:19:25+00:00",
+  "source_file": "7-TimeSeries/2-ARIMA/README.md",
+  "language_code": "no"
+}
+-->
+# Tidsserieprognoser med ARIMA
+
+I forrige leksjon lærte du litt om tidsserieprognoser og lastet inn et datasett som viser svingninger i elektrisk belastning over en tidsperiode.
+
+[![Introduksjon til ARIMA](https://img.youtube.com/vi/IUSk-YDau10/0.jpg)](https://youtu.be/IUSk-YDau10 "Introduksjon til ARIMA")
+
+> 🎥 Klikk på bildet ovenfor for en video: En kort introduksjon til ARIMA-modeller. Eksempelet er gjort i R, men konseptene er universelle.
+
+## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
+
+## Introduksjon
+
+I denne leksjonen vil du oppdage en spesifikk måte å bygge modeller på med [ARIMA: *A*uto*R*egressive *I*ntegrated *M*oving *A*verage](https://wikipedia.org/wiki/Autoregressive_integrated_moving_average). ARIMA-modeller er spesielt godt egnet til å tilpasse data som viser [ikke-stasjonaritet](https://wikipedia.org/wiki/Stationary_process).
+
+## Generelle konsepter
+
+For å kunne jobbe med ARIMA, er det noen konsepter du må kjenne til:
+
+- 🎓 **Stasjonaritet**. Fra et statistisk perspektiv refererer stasjonaritet til data der distribusjonen ikke endres når den forskyves i tid. Ikke-stasjonære data viser derimot svingninger på grunn av trender som må transformeres for å kunne analyseres. Sesongvariasjoner, for eksempel, kan introdusere svingninger i data og kan elimineres ved en prosess kalt 'sesongdifferensiering'.
+
+- 🎓 **[Differensiering](https://wikipedia.org/wiki/Autoregressive_integrated_moving_average#Differencing)**. Differensiering av data, igjen fra et statistisk perspektiv, refererer til prosessen med å transformere ikke-stasjonære data for å gjøre dem stasjonære ved å fjerne deres ikke-konstante trend. "Differensiering fjerner endringene i nivået til en tidsserie, eliminerer trend og sesongvariasjoner og stabiliserer dermed gjennomsnittet av tidsserien." [Paper av Shixiong et al](https://arxiv.org/abs/1904.07632)
+
+## ARIMA i konteksten av tidsserier
+
+La oss pakke ut delene av ARIMA for bedre å forstå hvordan det hjelper oss med å modellere tidsserier og lage prognoser basert på dem.
+
+- **AR - for AutoRegressiv**. Autoregressive modeller, som navnet antyder, ser 'tilbake' i tid for å analysere tidligere verdier i dataene dine og gjøre antakelser om dem. Disse tidligere verdiene kalles 'lags'. Et eksempel kan være data som viser månedlige salg av blyanter. Hver måneds salgssum vil bli betraktet som en 'utviklende variabel' i datasettet. Denne modellen bygges ved at "den utviklende variabelen av interesse regresseres på sine egne forsinkede (dvs. tidligere) verdier." [wikipedia](https://wikipedia.org/wiki/Autoregressive_integrated_moving_average)
+
+- **I - for Integrert**. I motsetning til de lignende 'ARMA'-modellene, refererer 'I' i ARIMA til dens *[integrerte](https://wikipedia.org/wiki/Order_of_integration)* aspekt. Dataene blir 'integrert' når differensieringstrinn brukes for å eliminere ikke-stasjonaritet.
+
+- **MA - for Glidende Gjennomsnitt**. Det [glidende gjennomsnittet](https://wikipedia.org/wiki/Moving-average_model) i denne modellen refererer til utgangsvariabelen som bestemmes ved å observere nåværende og tidligere verdier av lags.
+
+Kort oppsummert: ARIMA brukes til å lage en modell som passer så tett som mulig til den spesielle formen for tidsseriedata.
+
+## Øvelse - bygg en ARIMA-modell
+
+Åpne [_/working_](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA/working)-mappen i denne leksjonen og finn filen [_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/7-TimeSeries/2-ARIMA/working/notebook.ipynb).
+
+1. Kjør notebooken for å laste inn Python-biblioteket `statsmodels`; du trenger dette for ARIMA-modeller.
+
+1. Last inn nødvendige biblioteker.
+
+1. Deretter laster du inn flere biblioteker som er nyttige for å plotte data:
+
+    ```python
+    import os
+    import warnings
+    import matplotlib.pyplot as plt
+    import numpy as np
+    import pandas as pd
+    import datetime as dt
+    import math
+
+    from pandas.plotting import autocorrelation_plot
+    from statsmodels.tsa.statespace.sarimax import SARIMAX
+    from sklearn.preprocessing import MinMaxScaler
+    from common.utils import load_data, mape
+    from IPython.display import Image
+
+    %matplotlib inline
+    pd.options.display.float_format = '{:,.2f}'.format
+    np.set_printoptions(precision=2)
+    warnings.filterwarnings("ignore") # specify to ignore warning messages
+    ```
+
+1. Last inn data fra `/data/energy.csv`-filen til en Pandas dataframe og ta en titt:
+
+    ```python
+    energy = load_data('./data')[['load']]
+    energy.head(10)
+    ```
+
+1. Plot all tilgjengelig energidata fra januar 2012 til desember 2014. Det bør ikke være noen overraskelser, da vi så disse dataene i forrige leksjon:
+
+    ```python
+    energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
+    plt.xlabel('timestamp', fontsize=12)
+    plt.ylabel('load', fontsize=12)
+    plt.show()
+    ```
+
+    Nå, la oss bygge en modell!
+
+### Opprett trenings- og testdatasett
+
+Nå er dataene dine lastet inn, så du kan dele dem opp i trenings- og testsett. Du vil trene modellen din på treningssettet. Som vanlig, etter at modellen er ferdig trent, vil du evaluere nøyaktigheten ved hjelp av testsettet. Du må sørge for at testsettet dekker en senere tidsperiode enn treningssettet for å sikre at modellen ikke får informasjon fra fremtidige tidsperioder.
+
+1. Tildel en to-måneders periode fra 1. september til 31. oktober 2014 til treningssettet. Testsettet vil inkludere to-måneders perioden fra 1. november til 31. desember 2014:
+
+    ```python
+    train_start_dt = '2014-11-01 00:00:00'
+    test_start_dt = '2014-12-30 00:00:00'
+    ```
+
+    Siden disse dataene reflekterer det daglige energiforbruket, er det et sterkt sesongmønster, men forbruket er mest likt forbruket i mer nylige dager.
+
+1. Visualiser forskjellene:
+
+    ```python
+    energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)][['load']].rename(columns={'load':'train'}) \
+        .join(energy[test_start_dt:][['load']].rename(columns={'load':'test'}), how='outer') \
+        .plot(y=['train', 'test'], figsize=(15, 8), fontsize=12)
+    plt.xlabel('timestamp', fontsize=12)
+    plt.ylabel('load', fontsize=12)
+    plt.show()
+    ```
+
+    ![trenings- og testdata](../../../../7-TimeSeries/2-ARIMA/images/train-test.png)
+
+    Derfor bør det være tilstrekkelig å bruke et relativt lite tidsvindu for å trene dataene.
+
+    > Merk: Siden funksjonen vi bruker for å tilpasse ARIMA-modellen bruker in-sample validering under tilpasning, vil vi utelate valideringsdata.
+
+### Forbered dataene for trening
+
+Nå må du forberede dataene for trening ved å filtrere og skalere dem. Filtrer datasettet ditt for kun å inkludere de nødvendige tidsperiodene og kolonnene, og skaler dataene for å sikre at de projiseres i intervallet 0,1.
+
+1. Filtrer det originale datasettet for kun å inkludere de nevnte tidsperiodene per sett og kun inkludere den nødvendige kolonnen 'load' pluss datoen:
+
+    ```python
+    train = energy.copy()[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']]
+    test = energy.copy()[energy.index >= test_start_dt][['load']]
+
+    print('Training data shape: ', train.shape)
+    print('Test data shape: ', test.shape)
+    ```
+
+    Du kan se formen på dataene:
+
+    ```output
+    Training data shape:  (1416, 1)
+    Test data shape:  (48, 1)
+    ```
+
+1. Skaler dataene til å være i området (0, 1).
+
+    ```python
+    scaler = MinMaxScaler()
+    train['load'] = scaler.fit_transform(train)
+    train.head(10)
+    ```
+
+1. Visualiser de originale vs. skalerte dataene:
+
+    ```python
+    energy[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']].rename(columns={'load':'original load'}).plot.hist(bins=100, fontsize=12)
+    train.rename(columns={'load':'scaled load'}).plot.hist(bins=100, fontsize=12)
+    plt.show()
+    ```
+
+    ![original](../../../../7-TimeSeries/2-ARIMA/images/original.png)
+
+    > De originale dataene
+
+    ![skalert](../../../../7-TimeSeries/2-ARIMA/images/scaled.png)
+
+    > De skalerte dataene
+
+1. Nå som du har kalibrert de skalerte dataene, kan du skalere testdataene:
+
+    ```python
+    test['load'] = scaler.transform(test)
+    test.head()
+    ```
+
+### Implementer ARIMA
+
+Det er på tide å implementere ARIMA! Du vil nå bruke `statsmodels`-biblioteket som du installerte tidligere.
+
+Nå må du følge flere trinn:
+
+   1. Definer modellen ved å kalle `SARIMAX()` og sende inn modellparametrene: p, d og q-parametere, samt P, D og Q-parametere.
+   2. Forbered modellen for treningsdataene ved å kalle fit()-funksjonen.
+   3. Lag prognoser ved å kalle `forecast()`-funksjonen og spesifisere antall steg (horisonten) som skal prognoseres.
+
+> 🎓 Hva er alle disse parameterne til? I en ARIMA-modell er det 3 parametere som brukes for å modellere de viktigste aspektene ved en tidsserie: sesongvariasjon, trend og støy. Disse parameterne er:
+
+`p`: parameteren knyttet til den autoregressive delen av modellen, som inkorporerer *tidligere* verdier.  
+`d`: parameteren knyttet til den integrerte delen av modellen, som påvirker mengden *differensiering* (🎓 husk differensiering 👆?) som skal brukes på en tidsserie.  
+`q`: parameteren knyttet til den glidende gjennomsnittsdelen av modellen.
+
+> Merk: Hvis dataene dine har en sesongmessig komponent - som disse dataene har - bruker vi en sesongmessig ARIMA-modell (SARIMA). I så fall må du bruke et annet sett med parametere: `P`, `D` og `Q`, som beskriver de samme assosiasjonene som `p`, `d` og `q`, men tilsvarer de sesongmessige komponentene i modellen.
+
+1. Start med å sette din foretrukne horisontverdi. La oss prøve 3 timer:
+
+    ```python
+    # Specify the number of steps to forecast ahead
+    HORIZON = 3
+    print('Forecasting horizon:', HORIZON, 'hours')
+    ```
+
+    Å velge de beste verdiene for en ARIMA-modells parametere kan være utfordrende, da det er noe subjektivt og tidkrevende. Du kan vurdere å bruke en `auto_arima()`-funksjon fra [`pyramid`-biblioteket](https://alkaline-ml.com/pmdarima/0.9.0/modules/generated/pyramid.arima.auto_arima.html).
+
+1. For nå, prøv noen manuelle valg for å finne en god modell.
+
+    ```python
+    order = (4, 1, 0)
+    seasonal_order = (1, 1, 0, 24)
+
+    model = SARIMAX(endog=train, order=order, seasonal_order=seasonal_order)
+    results = model.fit()
+
+    print(results.summary())
+    ```
+
+    En tabell med resultater blir skrevet ut.
+
+Du har bygget din første modell! Nå må vi finne en måte å evaluere den på.
+
+### Evaluer modellen din
+
+For å evaluere modellen din kan du utføre den såkalte `walk forward`-valideringen. I praksis blir tidsseriemodeller re-trent hver gang nye data blir tilgjengelige. Dette lar modellen lage den beste prognosen ved hvert tidssteg.
+
+Start ved begynnelsen av tidsserien med denne teknikken, tren modellen på treningsdatasettet. Deretter lager du en prognose for neste tidssteg. Prognosen evalueres mot den kjente verdien. Treningssettet utvides deretter til å inkludere den kjente verdien, og prosessen gjentas.
+
+> Merk: Du bør holde treningssettets vindu fast for mer effektiv trening, slik at hver gang du legger til en ny observasjon i treningssettet, fjerner du observasjonen fra begynnelsen av settet.
+
+Denne prosessen gir en mer robust estimering av hvordan modellen vil prestere i praksis. Imidlertid kommer det med beregningskostnaden ved å lage så mange modeller. Dette er akseptabelt hvis dataene er små eller hvis modellen er enkel, men kan være et problem i stor skala.
+
+Walk-forward validering er gullstandarden for evaluering av tidsseriemodeller og anbefales for dine egne prosjekter.
+
+1. Først, opprett et testdatapunkt for hvert HORIZON-steg.
+
+    ```python
+    test_shifted = test.copy()
+
+    for t in range(1, HORIZON+1):
+        test_shifted['load+'+str(t)] = test_shifted['load'].shift(-t, freq='H')
+
+    test_shifted = test_shifted.dropna(how='any')
+    test_shifted.head(5)
+    ```
+
+    |            |          | load | load+1 | load+2 |
+    | ---------- | -------- | ---- | ------ | ------ |
+    | 2014-12-30 | 00:00:00 | 0.33 | 0.29   | 0.27   |
+    | 2014-12-30 | 01:00:00 | 0.29 | 0.27   | 0.27   |
+    | 2014-12-30 | 02:00:00 | 0.27 | 0.27   | 0.30   |
+    | 2014-12-30 | 03:00:00 | 0.27 | 0.30   | 0.41   |
+    | 2014-12-30 | 04:00:00 | 0.30 | 0.41   | 0.57   |
+
+    Dataene forskyves horisontalt i henhold til horisontpunktet.
+
+1. Lag prognoser for testdataene dine ved hjelp av denne glidende vindustilnærmingen i en løkke på størrelse med testdatasettets lengde:
+
+    ```python
+    %%time
+    training_window = 720 # dedicate 30 days (720 hours) for training
+
+    train_ts = train['load']
+    test_ts = test_shifted
+
+    history = [x for x in train_ts]
+    history = history[(-training_window):]
+
+    predictions = list()
+
+    order = (2, 1, 0)
+    seasonal_order = (1, 1, 0, 24)
+
+    for t in range(test_ts.shape[0]):
+        model = SARIMAX(endog=history, order=order, seasonal_order=seasonal_order)
+        model_fit = model.fit()
+        yhat = model_fit.forecast(steps = HORIZON)
+        predictions.append(yhat)
+        obs = list(test_ts.iloc[t])
+        # move the training window
+        history.append(obs[0])
+        history.pop(0)
+        print(test_ts.index[t])
+        print(t+1, ': predicted =', yhat, 'expected =', obs)
+    ```
+
+    Du kan se treningen foregå:
+
+    ```output
+    2014-12-30 00:00:00
+    1 : predicted = [0.32 0.29 0.28] expected = [0.32945389435989236, 0.2900626678603402, 0.2739480752014323]
+
+    2014-12-30 01:00:00
+    2 : predicted = [0.3  0.29 0.3 ] expected = [0.2900626678603402, 0.2739480752014323, 0.26812891674127126]
+
+    2014-12-30 02:00:00
+    3 : predicted = [0.27 0.28 0.32] expected = [0.2739480752014323, 0.26812891674127126, 0.3025962399283795]
+    ```
+
+1. Sammenlign prognosene med den faktiske belastningen:
+
+    ```python
+    eval_df = pd.DataFrame(predictions, columns=['t+'+str(t) for t in range(1, HORIZON+1)])
+    eval_df['timestamp'] = test.index[0:len(test.index)-HORIZON+1]
+    eval_df = pd.melt(eval_df, id_vars='timestamp', value_name='prediction', var_name='h')
+    eval_df['actual'] = np.array(np.transpose(test_ts)).ravel()
+    eval_df[['prediction', 'actual']] = scaler.inverse_transform(eval_df[['prediction', 'actual']])
+    eval_df.head()
+    ```
+
+    Output  
+    |     |            | timestamp | h   | prediction | actual   |
+    | --- | ---------- | --------- | --- | ---------- | -------- |
+    | 0   | 2014-12-30 | 00:00:00  | t+1 | 3,008.74   | 3,023.00 |
+    | 1   | 2014-12-30 | 01:00:00  | t+1 | 2,955.53   | 2,935.00 |
+    | 2   | 2014-12-30 | 02:00:00  | t+1 | 2,900.17   | 2,899.00 |
+    | 3   | 2014-12-30 | 03:00:00  | t+1 | 2,917.69   | 2,886.00 |
+    | 4   | 2014-12-30 | 04:00:00  | t+1 | 2,946.99   | 2,963.00 |
+
+    Observer prognosen for timebaserte data sammenlignet med den faktiske belastningen. Hvor nøyaktig er dette?
+
+### Sjekk modellens nøyaktighet
+
+Sjekk nøyaktigheten til modellen din ved å teste dens gjennomsnittlige absolutte prosentvise feil (MAPE) over alle prognosene.
+> **🧮 Vis meg matematikken**
+>
+> ![MAPE](../../../../7-TimeSeries/2-ARIMA/images/mape.png)
+>
+> [MAPE](https://www.linkedin.com/pulse/what-mape-mad-msd-time-series-allameh-statistics/) brukes for å vise prediksjonsnøyaktighet som et forhold definert av formelen ovenfor. Forskjellen mellom faktisk og forutsagt deles på det faktiske.
+>
+> "Den absolutte verdien i denne beregningen summeres for hvert prognosert tidspunkt og deles på antall tilpassede punkter n." [wikipedia](https://wikipedia.org/wiki/Mean_absolute_percentage_error)
+1. Uttrykk ligningen i kode:
+
+    ```python
+    if(HORIZON > 1):
+        eval_df['APE'] = (eval_df['prediction'] - eval_df['actual']).abs() / eval_df['actual']
+        print(eval_df.groupby('h')['APE'].mean())
+    ```
+
+1. Beregn MAPE for ett steg:
+
+    ```python
+    print('One step forecast MAPE: ', (mape(eval_df[eval_df['h'] == 't+1']['prediction'], eval_df[eval_df['h'] == 't+1']['actual']))*100, '%')
+    ```
+
+    MAPE for ett steg:  0.5570581332313952 %
+
+1. Skriv ut MAPE for flertrinnsprognosen:
+
+    ```python
+    print('Multi-step forecast MAPE: ', mape(eval_df['prediction'], eval_df['actual'])*100, '%')
+    ```
+
+    ```output
+    Multi-step forecast MAPE:  1.1460048657704118 %
+    ```
+
+    Et lavt tall er best: husk at en prognose med en MAPE på 10 er feil med 10%.
+
+1. Men som alltid, det er enklere å se denne typen nøyaktighetsmåling visuelt, så la oss plotte det:
+
+    ```python
+     if(HORIZON == 1):
+        ## Plotting single step forecast
+        eval_df.plot(x='timestamp', y=['actual', 'prediction'], style=['r', 'b'], figsize=(15, 8))
+
+    else:
+        ## Plotting multi step forecast
+        plot_df = eval_df[(eval_df.h=='t+1')][['timestamp', 'actual']]
+        for t in range(1, HORIZON+1):
+            plot_df['t+'+str(t)] = eval_df[(eval_df.h=='t+'+str(t))]['prediction'].values
+
+        fig = plt.figure(figsize=(15, 8))
+        ax = plt.plot(plot_df['timestamp'], plot_df['actual'], color='red', linewidth=4.0)
+        ax = fig.add_subplot(111)
+        for t in range(1, HORIZON+1):
+            x = plot_df['timestamp'][(t-1):]
+            y = plot_df['t+'+str(t)][0:len(x)]
+            ax.plot(x, y, color='blue', linewidth=4*math.pow(.9,t), alpha=math.pow(0.8,t))
+
+        ax.legend(loc='best')
+
+    plt.xlabel('timestamp', fontsize=12)
+    plt.ylabel('load', fontsize=12)
+    plt.show()
+    ```
+
+    ![en tidsseriemodell](../../../../7-TimeSeries/2-ARIMA/images/accuracy.png)
+
+🏆 Et veldig fint plot som viser en modell med god nøyaktighet. Bra jobbet!
+
+---
+
+## 🚀Utfordring
+
+Utforsk måter å teste nøyaktigheten til en tidsseriemodell. Vi berører MAPE i denne leksjonen, men finnes det andre metoder du kan bruke? Undersøk dem og kommenter dem. Et nyttig dokument kan finnes [her](https://otexts.com/fpp2/accuracy.html)
+
+## [Quiz etter leksjonen](https://ff-quizzes.netlify.app/en/ml/)
+
+## Gjennomgang & Selvstudium
+
+Denne leksjonen berører kun det grunnleggende innen tidsserieprognoser med ARIMA. Ta deg tid til å utdype kunnskapen din ved å utforske [dette repositoriet](https://microsoft.github.io/forecasting/) og dets ulike modelltyper for å lære andre måter å bygge tidsseriemodeller på.
+
+## Oppgave
+
+[En ny ARIMA-modell](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/7-TimeSeries/2-ARIMA/assignment.md

@@ -0,0 +1,25 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "1c814013e10866dfd92cdb32caaae3ac",
+  "translation_date": "2025-09-05T21:20:16+00:00",
+  "source_file": "7-TimeSeries/2-ARIMA/assignment.md",
+  "language_code": "no"
+}
+-->
+# En ny ARIMA-modell
+
+## Instruksjoner
+
+Nå som du har bygget en ARIMA-modell, lag en ny med ferske data (prøv en av [disse datasettene fra Duke](http://www2.stat.duke.edu/~mw/ts_data_sets.html). Kommenter arbeidet ditt i en notebook, visualiser dataene og modellen din, og test nøyaktigheten ved hjelp av MAPE.
+
+## Vurderingskriterier
+
+| Kriterier | Eksemplarisk                                                                                                      | Tilfredsstillende                                        | Trenger forbedring                 |
+| --------- | ----------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------- | ---------------------------------- |
+|           | En notebook presenteres med en ny ARIMA-modell bygget, testet og forklart med visualiseringer og angitt nøyaktighet. | Notebooken som presenteres er ikke kommentert eller inneholder feil | En ufullstendig notebook presenteres |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/7-TimeSeries/2-ARIMA/solution/Julia/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+  "translation_date": "2025-09-05T21:20:39+00:00",
+  "source_file": "7-TimeSeries/2-ARIMA/solution/Julia/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/7-TimeSeries/2-ARIMA/solution/R/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
+  "translation_date": "2025-09-05T21:20:29+00:00",
+  "source_file": "7-TimeSeries/2-ARIMA/solution/R/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/7-TimeSeries/3-SVR/README.md

@@ -0,0 +1,393 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "482bccabe1df958496ea71a3667995cd",
+  "translation_date": "2025-09-05T21:24:09+00:00",
+  "source_file": "7-TimeSeries/3-SVR/README.md",
+  "language_code": "no"
+}
+-->
+# Tidsserieprognoser med Support Vector Regressor
+
+I forrige leksjon lærte du hvordan du bruker ARIMA-modellen til å lage tidsserieprediksjoner. Nå skal vi se på Support Vector Regressor-modellen, som er en regresjonsmodell brukt til å forutsi kontinuerlige data.
+
+## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/) 
+
+## Introduksjon
+
+I denne leksjonen vil du oppdage en spesifikk måte å bygge modeller med [**SVM**: **S**upport **V**ector **M**achine](https://en.wikipedia.org/wiki/Support-vector_machine) for regresjon, eller **SVR: Support Vector Regressor**. 
+
+### SVR i konteksten av tidsserier [^1]
+
+Før du forstår viktigheten av SVR i tidsserieprediksjon, er det noen viktige konsepter du bør kjenne til:
+
+- **Regresjon:** En overvåket læringsteknikk for å forutsi kontinuerlige verdier basert på et gitt sett med input. Ideen er å tilpasse en kurve (eller linje) i funksjonsrommet som har flest mulig datapunkter. [Klikk her](https://en.wikipedia.org/wiki/Regression_analysis) for mer informasjon.
+- **Support Vector Machine (SVM):** En type overvåket maskinlæringsmodell brukt til klassifisering, regresjon og deteksjon av avvik. Modellen er et hyperplan i funksjonsrommet, som i tilfelle klassifisering fungerer som en grense, og i tilfelle regresjon fungerer som den beste tilpassede linjen. I SVM brukes vanligvis en Kernel-funksjon for å transformere datasettet til et rom med høyere dimensjoner, slik at de blir lettere separerbare. [Klikk her](https://en.wikipedia.org/wiki/Support-vector_machine) for mer informasjon om SVM.
+- **Support Vector Regressor (SVR):** En type SVM som finner den beste tilpassede linjen (som i tilfelle SVM er et hyperplan) som har flest mulig datapunkter.
+
+### Hvorfor SVR? [^1]
+
+I forrige leksjon lærte du om ARIMA, som er en svært vellykket statistisk lineær metode for å forutsi tidsseriedata. Men i mange tilfeller har tidsseriedata *ikke-linearitet*, som ikke kan modelleres av lineære metoder. I slike tilfeller gjør SVMs evne til å ta hensyn til ikke-linearitet i dataene for regresjonsoppgaver SVR vellykket i tidsserieprognoser.
+
+## Øvelse - bygg en SVR-modell
+
+De første stegene for datapreparering er de samme som i forrige leksjon om [ARIMA](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA). 
+
+Åpne [_/working_](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/3-SVR/working)-mappen i denne leksjonen og finn [_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/7-TimeSeries/3-SVR/working/notebook.ipynb)-filen.[^2]
+
+1. Kjør notebooken og importer de nødvendige bibliotekene: [^2]
+
+   ```python
+   import sys
+   sys.path.append('../../')
+   ```
+
+   ```python
+   import os
+   import warnings
+   import matplotlib.pyplot as plt
+   import numpy as np
+   import pandas as pd
+   import datetime as dt
+   import math
+   
+   from sklearn.svm import SVR
+   from sklearn.preprocessing import MinMaxScaler
+   from common.utils import load_data, mape
+   ```
+
+2. Last inn dataene fra `/data/energy.csv`-filen til en Pandas-datastruktur og se på dem: [^2]
+
+   ```python
+   energy = load_data('../../data')[['load']]
+   ```
+
+3. Plott alle tilgjengelige energidata fra januar 2012 til desember 2014: [^2]
+
+   ```python
+   energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
+   plt.xlabel('timestamp', fontsize=12)
+   plt.ylabel('load', fontsize=12)
+   plt.show()
+   ```
+
+   ![full data](../../../../7-TimeSeries/3-SVR/images/full-data.png)
+
+   Nå skal vi bygge vår SVR-modell.
+
+### Opprett trenings- og testdatasett
+
+Nå er dataene dine lastet inn, så du kan dele dem opp i trenings- og testsett. Deretter vil du omforme dataene for å lage et tidsstegbasert datasett som vil være nødvendig for SVR. Du vil trene modellen på treningssettet. Etter at modellen er ferdig trent, vil du evaluere dens nøyaktighet på treningssettet, testsettet og deretter hele datasettet for å se den generelle ytelsen. Du må sørge for at testsettet dekker en senere tidsperiode enn treningssettet for å sikre at modellen ikke får informasjon fra fremtidige tidsperioder [^2] (en situasjon kjent som *Overfitting*).
+
+1. Tildel en to-måneders periode fra 1. september til 31. oktober 2014 til treningssettet. Testsettet vil inkludere to-måneders perioden fra 1. november til 31. desember 2014: [^2]
+
+   ```python
+   train_start_dt = '2014-11-01 00:00:00'
+   test_start_dt = '2014-12-30 00:00:00'
+   ```
+
+2. Visualiser forskjellene: [^2]
+
+   ```python
+   energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)][['load']].rename(columns={'load':'train'}) \
+       .join(energy[test_start_dt:][['load']].rename(columns={'load':'test'}), how='outer') \
+       .plot(y=['train', 'test'], figsize=(15, 8), fontsize=12)
+   plt.xlabel('timestamp', fontsize=12)
+   plt.ylabel('load', fontsize=12)
+   plt.show()
+   ```
+
+   ![training and testing data](../../../../7-TimeSeries/3-SVR/images/train-test.png)
+
+### Forbered dataene for trening
+
+Nå må du forberede dataene for trening ved å filtrere og skalere dataene dine. Filtrer datasettet for kun å inkludere de tidsperiodene og kolonnene du trenger, og skaler for å sikre at dataene projiseres i intervallet 0,1.
+
+1. Filtrer det originale datasettet for kun å inkludere de nevnte tidsperiodene per sett og kun inkludere den nødvendige kolonnen 'load' pluss datoen: [^2]
+
+   ```python
+   train = energy.copy()[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']]
+   test = energy.copy()[energy.index >= test_start_dt][['load']]
+   
+   print('Training data shape: ', train.shape)
+   print('Test data shape: ', test.shape)
+   ```
+
+   ```output
+   Training data shape:  (1416, 1)
+   Test data shape:  (48, 1)
+   ```
+   
+2. Skaler treningsdataene til å være i området (0, 1): [^2]
+
+   ```python
+   scaler = MinMaxScaler()
+   train['load'] = scaler.fit_transform(train)
+   ```
+   
+4. Nå skalerer du testdataene: [^2]
+
+   ```python
+   test['load'] = scaler.transform(test)
+   ```
+
+### Opprett data med tidssteg [^1]
+
+For SVR transformerer du inputdataene til formen `[batch, timesteps]`. Så du omformer de eksisterende `train_data` og `test_data` slik at det er en ny dimensjon som refererer til tidsstegene. 
+
+```python
+# Converting to numpy arrays
+train_data = train.values
+test_data = test.values
+```
+
+For dette eksempelet tar vi `timesteps = 5`. Så input til modellen er dataene for de første 4 tidsstegene, og output vil være dataene for det 5. tidssteget.
+
+```python
+timesteps=5
+```
+
+Konverter treningsdata til 2D tensor ved hjelp av nested list comprehension:
+
+```python
+train_data_timesteps=np.array([[j for j in train_data[i:i+timesteps]] for i in range(0,len(train_data)-timesteps+1)])[:,:,0]
+train_data_timesteps.shape
+```
+
+```output
+(1412, 5)
+```
+
+Konverter testdata til 2D tensor:
+
+```python
+test_data_timesteps=np.array([[j for j in test_data[i:i+timesteps]] for i in range(0,len(test_data)-timesteps+1)])[:,:,0]
+test_data_timesteps.shape
+```
+
+```output
+(44, 5)
+```
+
+Velg input og output fra trenings- og testdata:
+
+```python
+x_train, y_train = train_data_timesteps[:,:timesteps-1],train_data_timesteps[:,[timesteps-1]]
+x_test, y_test = test_data_timesteps[:,:timesteps-1],test_data_timesteps[:,[timesteps-1]]
+
+print(x_train.shape, y_train.shape)
+print(x_test.shape, y_test.shape)
+```
+
+```output
+(1412, 4) (1412, 1)
+(44, 4) (44, 1)
+```
+
+### Implementer SVR [^1]
+
+Nå er det på tide å implementere SVR. For å lese mer om denne implementeringen, kan du referere til [denne dokumentasjonen](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVR.html). For vår implementering følger vi disse stegene:
+
+  1. Definer modellen ved å kalle `SVR()` og sende inn modellens hyperparametere: kernel, gamma, c og epsilon
+  2. Forbered modellen for treningsdataene ved å kalle funksjonen `fit()`
+  3. Lag prediksjoner ved å kalle funksjonen `predict()`
+
+Nå oppretter vi en SVR-modell. Her bruker vi [RBF-kjernen](https://scikit-learn.org/stable/modules/svm.html#parameters-of-the-rbf-kernel), og setter hyperparameterne gamma, C og epsilon til henholdsvis 0.5, 10 og 0.05.
+
+```python
+model = SVR(kernel='rbf',gamma=0.5, C=10, epsilon = 0.05)
+```
+
+#### Tren modellen på treningsdata [^1]
+
+```python
+model.fit(x_train, y_train[:,0])
+```
+
+```output
+SVR(C=10, cache_size=200, coef0=0.0, degree=3, epsilon=0.05, gamma=0.5,
+    kernel='rbf', max_iter=-1, shrinking=True, tol=0.001, verbose=False)
+```
+
+#### Lag modellprediksjoner [^1]
+
+```python
+y_train_pred = model.predict(x_train).reshape(-1,1)
+y_test_pred = model.predict(x_test).reshape(-1,1)
+
+print(y_train_pred.shape, y_test_pred.shape)
+```
+
+```output
+(1412, 1) (44, 1)
+```
+
+Du har bygget din SVR! Nå må vi evaluere den.
+
+### Evaluer modellen din [^1]
+
+For evaluering skal vi først skalere dataene tilbake til vår originale skala. Deretter, for å sjekke ytelsen, skal vi plotte den originale og predikerte tidsserien, og også skrive ut MAPE-resultatet.
+
+Skaler den predikerte og originale outputen:
+
+```python
+# Scaling the predictions
+y_train_pred = scaler.inverse_transform(y_train_pred)
+y_test_pred = scaler.inverse_transform(y_test_pred)
+
+print(len(y_train_pred), len(y_test_pred))
+```
+
+```python
+# Scaling the original values
+y_train = scaler.inverse_transform(y_train)
+y_test = scaler.inverse_transform(y_test)
+
+print(len(y_train), len(y_test))
+```
+
+#### Sjekk modellens ytelse på trenings- og testdata [^1]
+
+Vi henter tidsstemplene fra datasettet for å vise på x-aksen i vårt plot. Merk at vi bruker de første ```timesteps-1``` verdiene som input for den første outputen, så tidsstemplene for outputen vil starte etter det.
+
+```python
+train_timestamps = energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)].index[timesteps-1:]
+test_timestamps = energy[test_start_dt:].index[timesteps-1:]
+
+print(len(train_timestamps), len(test_timestamps))
+```
+
+```output
+1412 44
+```
+
+Plot prediksjonene for treningsdata:
+
+```python
+plt.figure(figsize=(25,6))
+plt.plot(train_timestamps, y_train, color = 'red', linewidth=2.0, alpha = 0.6)
+plt.plot(train_timestamps, y_train_pred, color = 'blue', linewidth=0.8)
+plt.legend(['Actual','Predicted'])
+plt.xlabel('Timestamp')
+plt.title("Training data prediction")
+plt.show()
+```
+
+![training data prediction](../../../../7-TimeSeries/3-SVR/images/train-data-predict.png)
+
+Skriv ut MAPE for treningsdata
+
+```python
+print('MAPE for training data: ', mape(y_train_pred, y_train)*100, '%')
+```
+
+```output
+MAPE for training data: 1.7195710200875551 %
+```
+
+Plot prediksjonene for testdata
+
+```python
+plt.figure(figsize=(10,3))
+plt.plot(test_timestamps, y_test, color = 'red', linewidth=2.0, alpha = 0.6)
+plt.plot(test_timestamps, y_test_pred, color = 'blue', linewidth=0.8)
+plt.legend(['Actual','Predicted'])
+plt.xlabel('Timestamp')
+plt.show()
+```
+
+![testing data prediction](../../../../7-TimeSeries/3-SVR/images/test-data-predict.png)
+
+Skriv ut MAPE for testdata
+
+```python
+print('MAPE for testing data: ', mape(y_test_pred, y_test)*100, '%')
+```
+
+```output
+MAPE for testing data:  1.2623790187854018 %
+```
+
+🏆 Du har et veldig godt resultat på testdatasettet!
+
+### Sjekk modellens ytelse på hele datasettet [^1]
+
+```python
+# Extracting load values as numpy array
+data = energy.copy().values
+
+# Scaling
+data = scaler.transform(data)
+
+# Transforming to 2D tensor as per model input requirement
+data_timesteps=np.array([[j for j in data[i:i+timesteps]] for i in range(0,len(data)-timesteps+1)])[:,:,0]
+print("Tensor shape: ", data_timesteps.shape)
+
+# Selecting inputs and outputs from data
+X, Y = data_timesteps[:,:timesteps-1],data_timesteps[:,[timesteps-1]]
+print("X shape: ", X.shape,"\nY shape: ", Y.shape)
+```
+
+```output
+Tensor shape:  (26300, 5)
+X shape:  (26300, 4) 
+Y shape:  (26300, 1)
+```
+
+```python
+# Make model predictions
+Y_pred = model.predict(X).reshape(-1,1)
+
+# Inverse scale and reshape
+Y_pred = scaler.inverse_transform(Y_pred)
+Y = scaler.inverse_transform(Y)
+```
+
+```python
+plt.figure(figsize=(30,8))
+plt.plot(Y, color = 'red', linewidth=2.0, alpha = 0.6)
+plt.plot(Y_pred, color = 'blue', linewidth=0.8)
+plt.legend(['Actual','Predicted'])
+plt.xlabel('Timestamp')
+plt.show()
+```
+
+![full data prediction](../../../../7-TimeSeries/3-SVR/images/full-data-predict.png)
+
+```python
+print('MAPE: ', mape(Y_pred, Y)*100, '%')
+```
+
+```output
+MAPE:  2.0572089029888656 %
+```
+
+🏆 Veldig fine plott som viser en modell med god nøyaktighet. Bra jobbet!
+
+---
+
+## 🚀Utfordring
+
+- Prøv å justere hyperparameterne (gamma, C, epsilon) mens du oppretter modellen og evaluer på dataene for å se hvilke sett med hyperparametere som gir de beste resultatene på testdataene. For å lære mer om disse hyperparameterne, kan du referere til dokumentet [her](https://scikit-learn.org/stable/modules/svm.html#parameters-of-the-rbf-kernel). 
+- Prøv å bruke forskjellige kjernefunksjoner for modellen og analyser deres ytelse på datasettet. Et nyttig dokument kan finnes [her](https://scikit-learn.org/stable/modules/svm.html#kernel-functions).
+- Prøv å bruke forskjellige verdier for `timesteps` for modellen for å se tilbake og lage prediksjoner.
+
+## [Quiz etter leksjonen](https://ff-quizzes.netlify.app/en/ml/)
+
+## Gjennomgang & Selvstudie
+
+Denne leksjonen var en introduksjon til bruken av SVR for tidsserieprognoser. For å lese mer om SVR, kan du referere til [denne bloggen](https://www.analyticsvidhya.com/blog/2020/03/support-vector-regression-tutorial-for-machine-learning/). Denne [dokumentasjonen på scikit-learn](https://scikit-learn.org/stable/modules/svm.html) gir en mer omfattende forklaring om SVM generelt, [SVR](https://scikit-learn.org/stable/modules/svm.html#regression) og også andre implementeringsdetaljer som de forskjellige [kjernefunksjonene](https://scikit-learn.org/stable/modules/svm.html#kernel-functions) som kan brukes, og deres parametere.
+
+## Oppgave
+
+[En ny SVR-modell](assignment.md)
+
+## Krediteringer
+
+[^1]: Teksten, koden og outputen i denne seksjonen ble bidratt av [@AnirbanMukherjeeXD](https://github.com/AnirbanMukherjeeXD)
+[^2]: Teksten, koden og outputen i denne seksjonen ble hentet fra [ARIMA](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/7-TimeSeries/3-SVR/assignment.md

@@ -0,0 +1,27 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "94aa2fc6154252ae30a3f3740299707a",
+  "translation_date": "2025-09-05T21:24:51+00:00",
+  "source_file": "7-TimeSeries/3-SVR/assignment.md",
+  "language_code": "no"
+}
+-->
+# En ny SVR-modell
+
+## Instruksjoner [^1]
+
+Nå som du har bygget en SVR-modell, bygg en ny med ferske data (prøv en av [disse datasettene fra Duke](http://www2.stat.duke.edu/~mw/ts_data_sets.html)). Kommenter arbeidet ditt i en notebook, visualiser dataene og modellen din, og test nøyaktigheten ved hjelp av passende grafer og MAPE. Prøv også å justere de ulike hyperparameterne og bruke forskjellige verdier for tidsstegene.
+
+## Vurderingskriterier [^1]
+
+| Kriterier | Eksemplarisk                                                | Tilfredsstillende                                         | Trenger forbedring                |
+| --------- | ----------------------------------------------------------- | -------------------------------------------------------- | ---------------------------------- |
+|           | En notebook presenteres med en SVR-modell bygget, testet og forklart med visualiseringer og nøyaktighet angitt. | Notebooken som presenteres er ikke kommentert eller inneholder feil. | En ufullstendig notebook presenteres |
+
+[^1]:Teksten i denne seksjonen er basert på [oppgaven fra ARIMA](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA/assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/7-TimeSeries/README.md

@@ -0,0 +1,37 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "61342603bad8acadbc6b2e4e3aab3f66",
+  "translation_date": "2025-09-05T21:17:47+00:00",
+  "source_file": "7-TimeSeries/README.md",
+  "language_code": "no"
+}
+-->
+# Introduksjon til tidsserieprognoser
+
+Hva er tidsserieprognoser? Det handler om å forutsi fremtidige hendelser ved å analysere trender fra fortiden.
+
+## Regionalt tema: globalt strømforbruk ✨
+
+I disse to leksjonene vil du bli introdusert til tidsserieprognoser, et noe mindre kjent område innen maskinlæring som likevel er svært verdifullt for industri- og forretningsapplikasjoner, blant andre felt. Selv om nevrale nettverk kan brukes for å forbedre nytten av disse modellene, vil vi studere dem i konteksten av klassisk maskinlæring, ettersom modellene hjelper med å forutsi fremtidig ytelse basert på fortiden.
+
+Vårt regionale fokus er elektrisk forbruk i verden, et interessant datasett for å lære om å forutsi fremtidig strømforbruk basert på mønstre fra tidligere belastning. Du kan se hvordan denne typen prognoser kan være svært nyttig i en forretningssammenheng.
+
+![elektrisk nett](../../../7-TimeSeries/images/electric-grid.jpg)
+
+Foto av [Peddi Sai hrithik](https://unsplash.com/@shutter_log?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) av elektriske tårn på en vei i Rajasthan på [Unsplash](https://unsplash.com/s/photos/electric-india?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)
+
+## Leksjoner
+
+1. [Introduksjon til tidsserieprognoser](1-Introduction/README.md)
+2. [Bygge ARIMA-modeller for tidsserier](2-ARIMA/README.md)
+3. [Bygge Support Vector Regressor for tidsserieprognoser](3-SVR/README.md)
+
+## Krediteringer
+
+"Introduksjon til tidsserieprognoser" ble skrevet med ⚡️ av [Francesca Lazzeri](https://twitter.com/frlazzeri) og [Jen Looper](https://twitter.com/jenlooper). Notatbøkene dukket først opp online i [Azure "Deep Learning For Time Series"-repoet](https://github.com/Azure/DeepLearningForTimeSeriesForecasting) opprinnelig skrevet av Francesca Lazzeri. SVR-leksjonen ble skrevet av [Anirban Mukherjee](https://github.com/AnirbanMukherjeeXD)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør betraktes som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/8-Reinforcement/1-QLearning/README.md

@@ -0,0 +1,256 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "911efd5e595089000cb3c16fce1beab8",
+  "translation_date": "2025-09-05T22:05:43+00:00",
+  "source_file": "8-Reinforcement/1-QLearning/README.md",
+  "language_code": "no"
+}
+-->
+# Introduksjon til forsterkende læring og Q-Læring
+
+![Oppsummering av forsterkning i maskinlæring i en sketchnote](../../../../sketchnotes/ml-reinforcement.png)
+> Sketchnote av [Tomomi Imura](https://www.twitter.com/girlie_mac)
+
+Forsterkende læring involverer tre viktige konsepter: agenten, noen tilstander, og et sett med handlinger per tilstand. Ved å utføre en handling i en spesifisert tilstand, får agenten en belønning. Tenk igjen på dataspillet Super Mario. Du er Mario, du er i et spillnivå, stående ved kanten av en klippe. Over deg er det en mynt. Du som Mario, i et spillnivå, på en spesifikk posisjon ... det er din tilstand. Å ta et steg til høyre (en handling) vil føre deg over kanten, og det vil gi deg en lav numerisk score. Men å trykke på hopp-knappen vil gi deg et poeng og holde deg i live. Det er et positivt utfall og bør gi deg en positiv numerisk score.
+
+Ved å bruke forsterkende læring og en simulator (spillet), kan du lære hvordan du spiller spillet for å maksimere belønningen, som er å holde seg i live og score så mange poeng som mulig.
+
+[![Intro til forsterkende læring](https://img.youtube.com/vi/lDq_en8RNOo/0.jpg)](https://www.youtube.com/watch?v=lDq_en8RNOo)
+
+> 🎥 Klikk på bildet over for å høre Dmitry diskutere forsterkende læring
+
+## [Quiz før forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+## Forutsetninger og oppsett
+
+I denne leksjonen skal vi eksperimentere med litt kode i Python. Du bør kunne kjøre Jupyter Notebook-koden fra denne leksjonen, enten på din egen datamaskin eller i skyen.
+
+Du kan åpne [notatboken for leksjonen](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/notebook.ipynb) og gå gjennom denne leksjonen for å bygge.
+
+> **Merk:** Hvis du åpner denne koden fra skyen, må du også hente filen [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py), som brukes i notatbok-koden. Legg den i samme katalog som notatboken.
+
+## Introduksjon
+
+I denne leksjonen skal vi utforske verdenen til **[Peter og ulven](https://en.wikipedia.org/wiki/Peter_and_the_Wolf)**, inspirert av et musikalsk eventyr av den russiske komponisten [Sergei Prokofiev](https://en.wikipedia.org/wiki/Sergei_Prokofiev). Vi skal bruke **forsterkende læring** for å la Peter utforske sitt miljø, samle smakfulle epler og unngå å møte ulven.
+
+**Forsterkende læring** (RL) er en læringsteknikk som lar oss lære optimal oppførsel for en **agent** i et **miljø** ved å kjøre mange eksperimenter. En agent i dette miljøet bør ha et **mål**, definert av en **belønningsfunksjon**.
+
+## Miljøet
+
+For enkelhets skyld, la oss anta at Peters verden er et kvadratisk brett med størrelse `bredde` x `høyde`, som dette:
+
+![Peters miljø](../../../../8-Reinforcement/1-QLearning/images/environment.png)
+
+Hver celle i dette brettet kan enten være:
+
+* **bakke**, som Peter og andre skapninger kan gå på.
+* **vann**, som man åpenbart ikke kan gå på.
+* et **tre** eller **gress**, et sted hvor man kan hvile.
+* et **eple**, som representerer noe Peter vil være glad for å finne for å mate seg selv.
+* en **ulv**, som er farlig og bør unngås.
+
+Det finnes et eget Python-modul, [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py), som inneholder koden for å arbeide med dette miljøet. Fordi denne koden ikke er viktig for å forstå konseptene våre, vil vi importere modulen og bruke den til å lage brettet (kodeblokk 1):
+
+```python
+from rlboard import *
+
+width, height = 8,8
+m = Board(width,height)
+m.randomize(seed=13)
+m.plot()
+```
+
+Denne koden bør skrive ut et bilde av miljøet som ligner på det ovenfor.
+
+## Handlinger og strategi
+
+I vårt eksempel vil Peters mål være å finne et eple, mens han unngår ulven og andre hindringer. For å gjøre dette kan han i hovedsak gå rundt til han finner et eple.
+
+Derfor kan han på enhver posisjon velge mellom en av følgende handlinger: opp, ned, venstre og høyre.
+
+Vi vil definere disse handlingene som et ordbok, og knytte dem til par av tilsvarende koordinatendringer. For eksempel vil det å bevege seg til høyre (`R`) tilsvare paret `(1,0)`. (kodeblokk 2):
+
+```python
+actions = { "U" : (0,-1), "D" : (0,1), "L" : (-1,0), "R" : (1,0) }
+action_idx = { a : i for i,a in enumerate(actions.keys()) }
+```
+
+For å oppsummere, strategien og målet for dette scenariet er som følger:
+
+- **Strategien**, for vår agent (Peter) er definert av en såkalt **policy**. En policy er en funksjon som returnerer handlingen i en gitt tilstand. I vårt tilfelle er tilstanden til problemet representert av brettet, inkludert spillerens nåværende posisjon.
+
+- **Målet**, med forsterkende læring er å til slutt lære en god policy som lar oss løse problemet effektivt. Men som en baseline, la oss vurdere den enkleste policyen kalt **tilfeldig vandring**.
+
+## Tilfeldig vandring
+
+La oss først løse problemet vårt ved å implementere en strategi for tilfeldig vandring. Med tilfeldig vandring vil vi tilfeldig velge neste handling fra de tillatte handlingene, til vi når eplet (kodeblokk 3).
+
+1. Implementer den tilfeldige vandringen med koden nedenfor:
+
+    ```python
+    def random_policy(m):
+        return random.choice(list(actions))
+    
+    def walk(m,policy,start_position=None):
+        n = 0 # number of steps
+        # set initial position
+        if start_position:
+            m.human = start_position 
+        else:
+            m.random_start()
+        while True:
+            if m.at() == Board.Cell.apple:
+                return n # success!
+            if m.at() in [Board.Cell.wolf, Board.Cell.water]:
+                return -1 # eaten by wolf or drowned
+            while True:
+                a = actions[policy(m)]
+                new_pos = m.move_pos(m.human,a)
+                if m.is_valid(new_pos) and m.at(new_pos)!=Board.Cell.water:
+                    m.move(a) # do the actual move
+                    break
+            n+=1
+    
+    walk(m,random_policy)
+    ```
+
+    Kallet til `walk` bør returnere lengden på den tilsvarende stien, som kan variere fra en kjøring til en annen. 
+
+1. Kjør vandringseksperimentet et antall ganger (si, 100), og skriv ut de resulterende statistikkene (kodeblokk 4):
+
+    ```python
+    def print_statistics(policy):
+        s,w,n = 0,0,0
+        for _ in range(100):
+            z = walk(m,policy)
+            if z<0:
+                w+=1
+            else:
+                s += z
+                n += 1
+        print(f"Average path length = {s/n}, eaten by wolf: {w} times")
+    
+    print_statistics(random_policy)
+    ```
+
+    Merk at gjennomsnittlig lengde på en sti er rundt 30-40 steg, noe som er ganske mye, gitt at gjennomsnittlig avstand til nærmeste eple er rundt 5-6 steg.
+
+    Du kan også se hvordan Peters bevegelser ser ut under den tilfeldige vandringen:
+
+    ![Peters tilfeldige vandring](../../../../8-Reinforcement/1-QLearning/images/random_walk.gif)
+
+## Belønningsfunksjon
+
+For å gjøre vår policy mer intelligent, må vi forstå hvilke bevegelser som er "bedre" enn andre. For å gjøre dette må vi definere målet vårt.
+
+Målet kan defineres i form av en **belønningsfunksjon**, som vil returnere en scoreverdi for hver tilstand. Jo høyere tallet er, jo bedre er belønningsfunksjonen. (kodeblokk 5)
+
+```python
+move_reward = -0.1
+goal_reward = 10
+end_reward = -10
+
+def reward(m,pos=None):
+    pos = pos or m.human
+    if not m.is_valid(pos):
+        return end_reward
+    x = m.at(pos)
+    if x==Board.Cell.water or x == Board.Cell.wolf:
+        return end_reward
+    if x==Board.Cell.apple:
+        return goal_reward
+    return move_reward
+```
+
+En interessant ting med belønningsfunksjoner er at i de fleste tilfeller *får vi bare en betydelig belønning på slutten av spillet*. Dette betyr at algoritmen vår på en eller annen måte må huske "gode" steg som fører til en positiv belønning til slutt, og øke deres betydning. På samme måte bør alle bevegelser som fører til dårlige resultater avskrekkes.
+
+## Q-Læring
+
+En algoritme som vi skal diskutere her kalles **Q-Læring**. I denne algoritmen er policyen definert av en funksjon (eller en datastruktur) kalt en **Q-Tabell**. Den registrerer "godheten" til hver av handlingene i en gitt tilstand.
+
+Den kalles en Q-Tabell fordi det ofte er praktisk å representere den som en tabell, eller en flerdimensjonal matrise. Siden brettet vårt har dimensjonene `bredde` x `høyde`, kan vi representere Q-Tabellen ved hjelp av en numpy-matrise med formen `bredde` x `høyde` x `len(actions)`: (kodeblokk 6)
+
+```python
+Q = np.ones((width,height,len(actions)),dtype=np.float)*1.0/len(actions)
+```
+
+Legg merke til at vi initialiserer alle verdiene i Q-Tabellen med en lik verdi, i vårt tilfelle - 0.25. Dette tilsvarer policyen "tilfeldig vandring", fordi alle bevegelser i hver tilstand er like gode. Vi kan sende Q-Tabellen til `plot`-funksjonen for å visualisere tabellen på brettet: `m.plot(Q)`.
+
+![Peters miljø](../../../../8-Reinforcement/1-QLearning/images/env_init.png)
+
+I midten av hver celle er det en "pil" som indikerer den foretrukne retningen for bevegelse. Siden alle retninger er like, vises en prikk.
+
+Nå må vi kjøre simuleringen, utforske miljøet vårt, og lære en bedre fordeling av Q-Tabell-verdier, som vil tillate oss å finne veien til eplet mye raskere.
+
+## Essensen av Q-Læring: Bellman-likningen
+
+Når vi begynner å bevege oss, vil hver handling ha en tilsvarende belønning, dvs. vi kan teoretisk velge neste handling basert på den høyeste umiddelbare belønningen. Men i de fleste tilstander vil ikke bevegelsen oppnå målet vårt om å nå eplet, og dermed kan vi ikke umiddelbart avgjøre hvilken retning som er bedre.
+
+> Husk at det ikke er det umiddelbare resultatet som betyr noe, men heller det endelige resultatet, som vi vil oppnå på slutten av simuleringen.
+
+For å ta hensyn til denne forsinkede belønningen, må vi bruke prinsippene for **[dynamisk programmering](https://en.wikipedia.org/wiki/Dynamic_programming)**, som lar oss tenke på problemet vårt rekursivt.
+
+Anta at vi nå er i tilstanden *s*, og vi ønsker å bevege oss til neste tilstand *s'*. Ved å gjøre det vil vi motta den umiddelbare belønningen *r(s,a)*, definert av belønningsfunksjonen, pluss en fremtidig belønning. Hvis vi antar at Q-Tabellen vår korrekt reflekterer "attraktiviteten" til hver handling, vil vi i tilstanden *s'* velge en handling *a* som tilsvarer maksimal verdi av *Q(s',a')*. Dermed vil den beste mulige fremtidige belønningen vi kunne få i tilstanden *s* bli definert som `max`
+
+## Sjekke policyen
+
+Siden Q-Tabellen viser "attraktiviteten" til hver handling i hver tilstand, er det ganske enkelt å bruke den til å definere effektiv navigering i vår verden. I det enkleste tilfellet kan vi velge handlingen som tilsvarer den høyeste verdien i Q-Tabellen: (kodeblokk 9)
+
+```python
+def qpolicy_strict(m):
+        x,y = m.human
+        v = probs(Q[x,y])
+        a = list(actions)[np.argmax(v)]
+        return a
+
+walk(m,qpolicy_strict)
+```
+
+> Hvis du prøver koden ovenfor flere ganger, kan du legge merke til at den noen ganger "henger", og du må trykke på STOP-knappen i notatboken for å avbryte den. Dette skjer fordi det kan oppstå situasjoner der to tilstander "peker" på hverandre når det gjelder optimal Q-verdi, i så fall ender agenten opp med å bevege seg mellom disse tilstandene uendelig.
+
+## 🚀Utfordring
+
+> **Oppgave 1:** Endre `walk`-funksjonen slik at den begrenser maksimal lengde på stien til et visst antall steg (for eksempel 100), og se koden ovenfor returnere denne verdien fra tid til annen.
+
+> **Oppgave 2:** Endre `walk`-funksjonen slik at den ikke går tilbake til steder den allerede har vært tidligere. Dette vil forhindre at `walk` går i loop, men agenten kan fortsatt ende opp med å bli "fanget" på et sted den ikke kan unnslippe fra.
+
+## Navigering
+
+En bedre navigeringspolicy ville være den vi brukte under trening, som kombinerer utnyttelse og utforskning. I denne policyen vil vi velge hver handling med en viss sannsynlighet, proporsjonal med verdiene i Q-Tabellen. Denne strategien kan fortsatt føre til at agenten returnerer til en posisjon den allerede har utforsket, men som du kan se fra koden nedenfor, resulterer den i en veldig kort gjennomsnittlig sti til ønsket lokasjon (husk at `print_statistics` kjører simuleringen 100 ganger): (kodeblokk 10)
+
+```python
+def qpolicy(m):
+        x,y = m.human
+        v = probs(Q[x,y])
+        a = random.choices(list(actions),weights=v)[0]
+        return a
+
+print_statistics(qpolicy)
+```
+
+Etter å ha kjørt denne koden, bør du få en mye kortere gjennomsnittlig stilengde enn før, i området 3-6.
+
+## Undersøke læringsprosessen
+
+Som vi har nevnt, er læringsprosessen en balanse mellom utforskning og utnyttelse av opparbeidet kunnskap om problemrommets struktur. Vi har sett at resultatene av læringen (evnen til å hjelpe en agent med å finne en kort sti til målet) har forbedret seg, men det er også interessant å observere hvordan gjennomsnittlig stilengde oppfører seg under læringsprosessen:
+
+## Oppsummering av læringen:
+
+- **Gjennomsnittlig stilengde øker**. Det vi ser her er at i starten øker gjennomsnittlig stilengde. Dette skyldes sannsynligvis at når vi ikke vet noe om miljøet, er vi mer sannsynlig å bli fanget i dårlige tilstander, som vann eller ulv. Etter hvert som vi lærer mer og begynner å bruke denne kunnskapen, kan vi utforske miljøet lenger, men vi vet fortsatt ikke veldig godt hvor eplene er.
+
+- **Stilengden avtar etter hvert som vi lærer mer**. Når vi har lært nok, blir det lettere for agenten å nå målet, og stilengden begynner å avta. Vi er imidlertid fortsatt åpne for utforskning, så vi avviker ofte fra den beste stien og utforsker nye alternativer, noe som gjør stien lengre enn optimal.
+
+- **Lengden øker brått**. Det vi også observerer på denne grafen er at på et tidspunkt økte lengden brått. Dette indikerer den stokastiske naturen til prosessen, og at vi på et tidspunkt kan "ødelegge" Q-Tabell-koeffisientene ved å overskrive dem med nye verdier. Dette bør ideelt sett minimeres ved å redusere læringsraten (for eksempel mot slutten av treningen justerer vi Q-Tabell-verdiene med en liten verdi).
+
+Alt i alt er det viktig å huske at suksessen og kvaliteten på læringsprosessen avhenger betydelig av parametere, som læringsrate, læringsrate-avtakelse og diskonteringsfaktor. Disse kalles ofte **hyperparametere**, for å skille dem fra **parametere**, som vi optimaliserer under trening (for eksempel Q-Tabell-koeffisienter). Prosessen med å finne de beste verdiene for hyperparametere kalles **hyperparameteroptimalisering**, og det fortjener et eget tema.
+
+## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+## Oppgave 
+[En mer realistisk verden](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/8-Reinforcement/1-QLearning/assignment.md

@@ -0,0 +1,41 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "68394b2102d3503882e5e914bd0ff5c1",
+  "translation_date": "2025-09-05T22:07:28+00:00",
+  "source_file": "8-Reinforcement/1-QLearning/assignment.md",
+  "language_code": "no"
+}
+-->
+# En Mer Realistisk Verden
+
+I vår situasjon kunne Peter bevege seg rundt nesten uten å bli sliten eller sulten. I en mer realistisk verden må han sette seg ned og hvile fra tid til annen, og også spise for å holde seg i live. La oss gjøre vår verden mer realistisk ved å implementere følgende regler:
+
+1. Ved å bevege seg fra ett sted til et annet, mister Peter **energi** og får noe **utmattelse**.
+2. Peter kan få mer energi ved å spise epler.
+3. Peter kan kvitte seg med utmattelse ved å hvile under et tre eller på gresset (dvs. gå til en plass på brettet med et tre eller gress - grønt felt).
+4. Peter må finne og drepe ulven.
+5. For å drepe ulven må Peter ha visse nivåer av energi og utmattelse, ellers taper han kampen.
+
+## Instruksjoner
+
+Bruk den originale [notebook.ipynb](../../../../8-Reinforcement/1-QLearning/notebook.ipynb)-notatboken som utgangspunkt for løsningen din.
+
+Modifiser belønningsfunksjonen ovenfor i henhold til spillreglene, kjør forsterkningslæringsalgoritmen for å lære den beste strategien for å vinne spillet, og sammenlign resultatene av tilfeldig vandring med algoritmen din når det gjelder antall spill vunnet og tapt.
+
+> **Note**: I din nye verden er tilstanden mer kompleks, og inkluderer i tillegg til menneskets posisjon også nivåer av utmattelse og energi. Du kan velge å representere tilstanden som en tuple (Brett, energi, utmattelse), eller definere en klasse for tilstanden (du kan også velge å avlede den fra `Board`), eller til og med modifisere den originale `Board`-klassen i [rlboard.py](../../../../8-Reinforcement/1-QLearning/rlboard.py).
+
+I løsningen din, vennligst behold koden som er ansvarlig for strategien med tilfeldig vandring, og sammenlign resultatene av algoritmen din med tilfeldig vandring til slutt.
+
+> **Note**: Du kan trenge å justere hyperparametere for å få det til å fungere, spesielt antall epoker. Fordi suksessen i spillet (å bekjempe ulven) er en sjelden hendelse, kan du forvente mye lengre treningstid.
+
+## Vurderingskriterier
+
+| Kriterier | Fremragende                                                                                                                                                                                             | Tilfredsstillende                                                                                                                                                                                | Trenger Forbedring                                                                                                                          |
+| --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
+|           | En notatbok presenteres med definisjonen av nye verdensregler, Q-Learning-algoritme og noen tekstlige forklaringer. Q-Learning er i stand til å forbedre resultatene betydelig sammenlignet med tilfeldig vandring. | Notatbok presenteres, Q-Learning er implementert og forbedrer resultatene sammenlignet med tilfeldig vandring, men ikke betydelig; eller notatboken er dårlig dokumentert og koden er ikke godt strukturert | Noen forsøk på å redefinere verdensreglene er gjort, men Q-Learning-algoritmen fungerer ikke, eller belønningsfunksjonen er ikke fullt definert |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/8-Reinforcement/1-QLearning/solution/Julia/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+  "translation_date": "2025-09-05T22:07:59+00:00",
+  "source_file": "8-Reinforcement/1-QLearning/solution/Julia/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/8-Reinforcement/1-QLearning/solution/R/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
+  "translation_date": "2025-09-05T22:07:50+00:00",
+  "source_file": "8-Reinforcement/1-QLearning/solution/R/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/8-Reinforcement/2-Gym/README.md

@@ -0,0 +1,333 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "107d5bb29da8a562e7ae72262d251a75",
+  "translation_date": "2025-09-05T22:09:29+00:00",
+  "source_file": "8-Reinforcement/2-Gym/README.md",
+  "language_code": "no"
+}
+-->
+## Forutsetninger
+
+I denne leksjonen skal vi bruke et bibliotek kalt **OpenAI Gym** for å simulere ulike **miljøer**. Du kan kjøre koden fra denne leksjonen lokalt (f.eks. fra Visual Studio Code), i så fall vil simuleringen åpne seg i et nytt vindu. Når du kjører koden online, kan det være nødvendig å gjøre noen justeringer i koden, som beskrevet [her](https://towardsdatascience.com/rendering-openai-gym-envs-on-binder-and-google-colab-536f99391cc7).
+
+## OpenAI Gym
+
+I den forrige leksjonen ble reglene for spillet og tilstanden definert av klassen `Board`, som vi laget selv. Her skal vi bruke et spesielt **simuleringsmiljø** som simulerer fysikken bak den balanserende stangen. Et av de mest populære simuleringsmiljøene for trening av forsterkningslæringsalgoritmer kalles [Gym](https://gym.openai.com/), som vedlikeholdes av [OpenAI](https://openai.com/). Ved å bruke dette gymmet kan vi lage ulike **miljøer**, fra en CartPole-simulering til Atari-spill.
+
+> **Merk**: Du kan se andre tilgjengelige miljøer fra OpenAI Gym [her](https://gym.openai.com/envs/#classic_control).
+
+Først, la oss installere gym og importere nødvendige biblioteker (kodeblokk 1):
+
+```python
+import sys
+!{sys.executable} -m pip install gym 
+
+import gym
+import matplotlib.pyplot as plt
+import numpy as np
+import random
+```
+
+## Oppgave - initialiser et CartPole-miljø
+
+For å jobbe med et CartPole-balanseringsproblem må vi initialisere det tilsvarende miljøet. Hvert miljø er knyttet til:
+
+- **Observasjonsrom** som definerer strukturen til informasjonen vi mottar fra miljøet. For CartPole-problemet mottar vi posisjonen til stangen, hastighet og noen andre verdier.
+
+- **Handlingsrom** som definerer mulige handlinger. I vårt tilfelle er handlingsrommet diskret og består av to handlinger - **venstre** og **høyre**. (kodeblokk 2)
+
+1. For å initialisere, skriv følgende kode:
+
+    ```python
+    env = gym.make("CartPole-v1")
+    print(env.action_space)
+    print(env.observation_space)
+    print(env.action_space.sample())
+    ```
+
+For å se hvordan miljøet fungerer, la oss kjøre en kort simulering i 100 steg. Ved hvert steg gir vi en av handlingene som skal utføres - i denne simuleringen velger vi bare tilfeldig en handling fra `action_space`.
+
+1. Kjør koden nedenfor og se hva det fører til.
+
+    ✅ Husk at det er foretrukket å kjøre denne koden på en lokal Python-installasjon! (kodeblokk 3)
+
+    ```python
+    env.reset()
+    
+    for i in range(100):
+       env.render()
+       env.step(env.action_space.sample())
+    env.close()
+    ```
+
+    Du bør se noe som ligner på dette bildet:
+
+    ![ikke-balanserende CartPole](../../../../8-Reinforcement/2-Gym/images/cartpole-nobalance.gif)
+
+1. Under simuleringen må vi få observasjoner for å avgjøre hvordan vi skal handle. Faktisk returnerer step-funksjonen nåværende observasjoner, en belønningsfunksjon og en flagg som indikerer om det gir mening å fortsette simuleringen eller ikke: (kodeblokk 4)
+
+    ```python
+    env.reset()
+    
+    done = False
+    while not done:
+       env.render()
+       obs, rew, done, info = env.step(env.action_space.sample())
+       print(f"{obs} -> {rew}")
+    env.close()
+    ```
+
+    Du vil ende opp med å se noe som dette i notebook-utgangen:
+
+    ```text
+    [ 0.03403272 -0.24301182  0.02669811  0.2895829 ] -> 1.0
+    [ 0.02917248 -0.04828055  0.03248977  0.00543839] -> 1.0
+    [ 0.02820687  0.14636075  0.03259854 -0.27681916] -> 1.0
+    [ 0.03113408  0.34100283  0.02706215 -0.55904489] -> 1.0
+    [ 0.03795414  0.53573468  0.01588125 -0.84308041] -> 1.0
+    ...
+    [ 0.17299878  0.15868546 -0.20754175 -0.55975453] -> 1.0
+    [ 0.17617249  0.35602306 -0.21873684 -0.90998894] -> 1.0
+    ```
+
+    Observasjonsvektoren som returneres ved hvert steg av simuleringen inneholder følgende verdier:
+    - Posisjon til vognen
+    - Hastighet til vognen
+    - Vinkel til stangen
+    - Rotasjonshastighet til stangen
+
+1. Finn minimums- og maksimumsverdien av disse tallene: (kodeblokk 5)
+
+    ```python
+    print(env.observation_space.low)
+    print(env.observation_space.high)
+    ```
+
+    Du vil også legge merke til at belønningsverdien ved hvert simuleringssteg alltid er 1. Dette er fordi målet vårt er å overleve så lenge som mulig, dvs. holde stangen i en rimelig vertikal posisjon i lengst mulig tid.
+
+    ✅ Faktisk anses CartPole-simuleringen som løst hvis vi klarer å oppnå en gjennomsnittlig belønning på 195 over 100 påfølgende forsøk.
+
+## Diskretisering av tilstand
+
+I Q-Læring må vi bygge en Q-Tabell som definerer hva vi skal gjøre i hver tilstand. For å kunne gjøre dette må tilstanden være **diskret**, mer presist, den bør inneholde et begrenset antall diskrete verdier. Dermed må vi på en eller annen måte **diskretisere** observasjonene våre, og kartlegge dem til et begrenset sett med tilstander.
+
+Det finnes noen måter vi kan gjøre dette på:
+
+- **Del inn i intervaller**. Hvis vi kjenner intervallet til en viss verdi, kan vi dele dette intervallet inn i et antall **intervaller**, og deretter erstatte verdien med nummeret på intervallet den tilhører. Dette kan gjøres ved hjelp av numpy-metoden [`digitize`](https://numpy.org/doc/stable/reference/generated/numpy.digitize.html). I dette tilfellet vil vi nøyaktig vite størrelsen på tilstanden, fordi den vil avhenge av antall intervaller vi velger for digitalisering.
+
+✅ Vi kan bruke lineær interpolasjon for å bringe verdier til et begrenset intervall (for eksempel fra -20 til 20), og deretter konvertere tallene til heltall ved å runde dem av. Dette gir oss litt mindre kontroll over størrelsen på tilstanden, spesielt hvis vi ikke kjenner de nøyaktige grensene for inngangsverdiene. For eksempel, i vårt tilfelle har 2 av 4 verdier ikke øvre/nedre grenser for verdiene sine, noe som kan resultere i et uendelig antall tilstander.
+
+I vårt eksempel vil vi gå for den andre tilnærmingen. Som du kanskje legger merke til senere, til tross for udefinerte øvre/nedre grenser, tar disse verdiene sjelden verdier utenfor visse begrensede intervaller, og dermed vil tilstander med ekstreme verdier være svært sjeldne.
+
+1. Her er funksjonen som vil ta observasjonen fra modellen vår og produsere en tuple med 4 heltallsverdier: (kodeblokk 6)
+
+    ```python
+    def discretize(x):
+        return tuple((x/np.array([0.25, 0.25, 0.01, 0.1])).astype(np.int))
+    ```
+
+1. La oss også utforske en annen diskretiseringsmetode ved bruk av intervaller: (kodeblokk 7)
+
+    ```python
+    def create_bins(i,num):
+        return np.arange(num+1)*(i[1]-i[0])/num+i[0]
+    
+    print("Sample bins for interval (-5,5) with 10 bins\n",create_bins((-5,5),10))
+    
+    ints = [(-5,5),(-2,2),(-0.5,0.5),(-2,2)] # intervals of values for each parameter
+    nbins = [20,20,10,10] # number of bins for each parameter
+    bins = [create_bins(ints[i],nbins[i]) for i in range(4)]
+    
+    def discretize_bins(x):
+        return tuple(np.digitize(x[i],bins[i]) for i in range(4))
+    ```
+
+1. La oss nå kjøre en kort simulering og observere disse diskrete miljøverdiene. Prøv gjerne både `discretize` og `discretize_bins` og se om det er noen forskjell.
+
+    ✅ `discretize_bins` returnerer nummeret på intervallet, som er 0-basert. Dermed returnerer den for verdier av inngangsvariabelen rundt 0 nummeret fra midten av intervallet (10). I `discretize` brydde vi oss ikke om området for utgangsverdiene, og tillot dem å være negative, slik at tilstandsverdiene ikke er forskjøvet, og 0 tilsvarer 0. (kodeblokk 8)
+
+    ```python
+    env.reset()
+    
+    done = False
+    while not done:
+       #env.render()
+       obs, rew, done, info = env.step(env.action_space.sample())
+       #print(discretize_bins(obs))
+       print(discretize(obs))
+    env.close()
+    ```
+
+    ✅ Fjern kommentaren på linjen som starter med `env.render` hvis du vil se hvordan miljøet utføres. Ellers kan du utføre det i bakgrunnen, som er raskere. Vi vil bruke denne "usynlige" utførelsen under vår Q-Læringsprosess.
+
+## Strukturen til Q-Tabellen
+
+I vår forrige leksjon var tilstanden et enkelt par med tall fra 0 til 8, og dermed var det praktisk å representere Q-Tabellen med en numpy-tensor med formen 8x8x2. Hvis vi bruker intervall-diskretisering, er størrelsen på tilstandsvektoren vår også kjent, så vi kan bruke samme tilnærming og representere tilstanden med en array med formen 20x20x10x10x2 (her er 2 dimensjonen til handlingsrommet, og de første dimensjonene tilsvarer antall intervaller vi har valgt å bruke for hver av parameterne i observasjonsrommet).
+
+Imidlertid er det noen ganger ikke kjent de nøyaktige dimensjonene til observasjonsrommet. I tilfelle av funksjonen `discretize`, kan vi aldri være sikre på at tilstanden vår holder seg innenfor visse grenser, fordi noen av de opprinnelige verdiene ikke er begrenset. Dermed vil vi bruke en litt annen tilnærming og representere Q-Tabellen med en ordbok.
+
+1. Bruk paret *(state,action)* som nøkkelen i ordboken, og verdien vil tilsvare verdien i Q-Tabellen. (kodeblokk 9)
+
+    ```python
+    Q = {}
+    actions = (0,1)
+    
+    def qvalues(state):
+        return [Q.get((state,a),0) for a in actions]
+    ```
+
+    Her definerer vi også en funksjon `qvalues()`, som returnerer en liste med verdier fra Q-Tabellen for en gitt tilstand som tilsvarer alle mulige handlinger. Hvis oppføringen ikke er til stede i Q-Tabellen, vil vi returnere 0 som standard.
+
+## La oss starte Q-Læring
+
+Nå er vi klare til å lære Peter å balansere!
+
+1. Først, la oss sette noen hyperparametere: (kodeblokk 10)
+
+    ```python
+    # hyperparameters
+    alpha = 0.3
+    gamma = 0.9
+    epsilon = 0.90
+    ```
+
+    Her er `alpha` **læringsraten** som definerer i hvilken grad vi skal justere de nåværende verdiene i Q-Tabellen ved hvert steg. I den forrige leksjonen startet vi med 1, og deretter reduserte vi `alpha` til lavere verdier under treningen. I dette eksemplet vil vi holde den konstant bare for enkelhets skyld, og du kan eksperimentere med å justere `alpha`-verdiene senere.
+
+    `gamma` er **diskonteringsfaktoren** som viser i hvilken grad vi skal prioritere fremtidig belønning over nåværende belønning.
+
+    `epsilon` er **utforsknings-/utnyttelsesfaktoren** som avgjør om vi skal foretrekke utforskning fremfor utnyttelse eller omvendt. I algoritmen vår vil vi i `epsilon` prosent av tilfellene velge neste handling i henhold til verdiene i Q-Tabellen, og i de resterende tilfellene vil vi utføre en tilfeldig handling. Dette vil tillate oss å utforske områder av søkeområdet som vi aldri har sett før.
+
+    ✅ Når det gjelder balansering - å velge en tilfeldig handling (utforskning) vil fungere som et tilfeldig dytt i feil retning, og stangen må lære seg å gjenopprette balansen fra disse "feilene".
+
+### Forbedre algoritmen
+
+Vi kan også gjøre to forbedringer i algoritmen vår fra forrige leksjon:
+
+- **Beregn gjennomsnittlig kumulativ belønning** over et antall simuleringer. Vi vil skrive ut fremgangen hver 5000 iterasjoner, og vi vil beregne gjennomsnittet av vår kumulative belønning over den perioden. Det betyr at hvis vi får mer enn 195 poeng - kan vi anse problemet som løst, med enda høyere kvalitet enn nødvendig.
+
+- **Beregn maksimal gjennomsnittlig kumulativ belønning**, `Qmax`, og vi vil lagre Q-Tabellen som tilsvarer det resultatet. Når du kjører treningen, vil du legge merke til at noen ganger begynner den gjennomsnittlige kumulative belønningen å synke, og vi ønsker å beholde verdiene i Q-Tabellen som tilsvarer den beste modellen observert under treningen.
+
+1. Samle alle kumulative belønninger ved hver simulering i `rewards`-vektoren for videre plotting. (kodeblokk 11)
+
+    ```python
+    def probs(v,eps=1e-4):
+        v = v-v.min()+eps
+        v = v/v.sum()
+        return v
+    
+    Qmax = 0
+    cum_rewards = []
+    rewards = []
+    for epoch in range(100000):
+        obs = env.reset()
+        done = False
+        cum_reward=0
+        # == do the simulation ==
+        while not done:
+            s = discretize(obs)
+            if random.random()<epsilon:
+                # exploitation - chose the action according to Q-Table probabilities
+                v = probs(np.array(qvalues(s)))
+                a = random.choices(actions,weights=v)[0]
+            else:
+                # exploration - randomly chose the action
+                a = np.random.randint(env.action_space.n)
+    
+            obs, rew, done, info = env.step(a)
+            cum_reward+=rew
+            ns = discretize(obs)
+            Q[(s,a)] = (1 - alpha) * Q.get((s,a),0) + alpha * (rew + gamma * max(qvalues(ns)))
+        cum_rewards.append(cum_reward)
+        rewards.append(cum_reward)
+        # == Periodically print results and calculate average reward ==
+        if epoch%5000==0:
+            print(f"{epoch}: {np.average(cum_rewards)}, alpha={alpha}, epsilon={epsilon}")
+            if np.average(cum_rewards) > Qmax:
+                Qmax = np.average(cum_rewards)
+                Qbest = Q
+            cum_rewards=[]
+    ```
+
+Hva du kan legge merke til fra disse resultatene:
+
+- **Nær målet vårt**. Vi er veldig nær å oppnå målet om å få 195 kumulative belønninger over 100+ påfølgende simuleringer, eller vi kan faktisk ha oppnådd det! Selv om vi får mindre tall, vet vi fortsatt ikke, fordi vi beregner gjennomsnittet over 5000 kjøringer, og bare 100 kjøringer er nødvendig i de formelle kriteriene.
+
+- **Belønningen begynner å synke**. Noen ganger begynner belønningen å synke, noe som betyr at vi kan "ødelegge" allerede lærte verdier i Q-Tabellen med de som gjør situasjonen verre.
+
+Denne observasjonen er mer tydelig synlig hvis vi plotter treningsfremgangen.
+
+## Plotting av treningsfremgang
+
+Under treningen har vi samlet den kumulative belønningsverdien ved hver iterasjon i `rewards`-vektoren. Slik ser det ut når vi plotter det mot iterasjonsnummeret:
+
+```python
+plt.plot(rewards)
+```
+
+![rå fremgang](../../../../8-Reinforcement/2-Gym/images/train_progress_raw.png)
+
+Fra denne grafen er det ikke mulig å si noe, fordi på grunn av den stokastiske treningsprosessen varierer lengden på treningsøktene sterkt. For å gi mer mening til denne grafen kan vi beregne **glidende gjennomsnitt** over en serie eksperimenter, la oss si 100. Dette kan gjøres praktisk ved hjelp av `np.convolve`: (kodeblokk 12)
+
+```python
+def running_average(x,window):
+    return np.convolve(x,np.ones(window)/window,mode='valid')
+
+plt.plot(running_average(rewards,100))
+```
+
+![treningsfremgang](../../../../8-Reinforcement/2-Gym/images/train_progress_runav.png)
+
+## Variasjon av hyperparametere
+
+For å gjøre læringen mer stabil gir det mening å justere noen av hyperparameterne våre under treningen. Spesielt:
+
+- **For læringsraten**, `alpha`, kan vi starte med verdier nær 1, og deretter fortsette å redusere parameteren. Med tiden vil vi få gode sannsynlighetsverdier i Q-Tabellen, og dermed bør vi justere dem litt, og ikke overskrive dem helt med nye verdier.
+
+- **Øk epsilon**. Vi kan ønske å øke `epsilon` sakte, for å utforske mindre og utnytte mer. Det gir sannsynligvis mening å starte med en lav verdi av `epsilon`, og bevege seg opp mot nesten 1.
+> **Oppgave 1**: Prøv deg frem med verdier for hyperparametere og se om du kan oppnå høyere kumulativ belønning. Får du over 195?
+> **Oppgave 2**: For å løse problemet formelt, må du oppnå en gjennomsnittlig belønning på 195 over 100 sammenhengende kjøringer. Mål dette under treningen og sørg for at du har løst problemet formelt!
+
+## Se resultatet i praksis
+
+Det kan være interessant å faktisk se hvordan den trente modellen oppfører seg. La oss kjøre simuleringen og følge samme strategi for valg av handlinger som under treningen, ved å prøve ut fra sannsynlighetsfordelingen i Q-Tabellen: (kodeblokk 13)
+
+```python
+obs = env.reset()
+done = False
+while not done:
+   s = discretize(obs)
+   env.render()
+   v = probs(np.array(qvalues(s)))
+   a = random.choices(actions,weights=v)[0]
+   obs,_,done,_ = env.step(a)
+env.close()
+```
+
+Du bør se noe som dette:
+
+![en balanserende cartpole](../../../../8-Reinforcement/2-Gym/images/cartpole-balance.gif)
+
+---
+
+## 🚀Utfordring
+
+> **Oppgave 3**: Her brukte vi den endelige kopien av Q-Tabellen, som kanskje ikke er den beste. Husk at vi har lagret den best-presterende Q-Tabellen i variabelen `Qbest`! Prøv det samme eksempelet med den best-presterende Q-Tabellen ved å kopiere `Qbest` over til `Q` og se om du merker noen forskjell.
+
+> **Oppgave 4**: Her valgte vi ikke den beste handlingen på hvert steg, men prøvde heller ut fra den tilsvarende sannsynlighetsfordelingen. Ville det gi mer mening å alltid velge den beste handlingen, med den høyeste verdien i Q-Tabellen? Dette kan gjøres ved å bruke funksjonen `np.argmax` for å finne handlingsnummeret som tilsvarer den høyeste verdien i Q-Tabellen. Implementer denne strategien og se om det forbedrer balansen.
+
+## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+## Oppgave
+[Tren en Mountain Car](assignment.md)
+
+## Konklusjon
+
+Vi har nå lært hvordan vi kan trene agenter til å oppnå gode resultater bare ved å gi dem en belønningsfunksjon som definerer ønsket tilstand i spillet, og ved å gi dem muligheten til å utforske søkeområdet intelligent. Vi har med suksess anvendt Q-Learning-algoritmen i tilfeller med diskrete og kontinuerlige miljøer, men med diskrete handlinger.
+
+Det er også viktig å studere situasjoner der handlingsrommet også er kontinuerlig, og når observasjonsrommet er mye mer komplekst, som bildet fra skjermen i et Atari-spill. I slike problemer trenger vi ofte å bruke mer kraftige maskinlæringsteknikker, som nevrale nettverk, for å oppnå gode resultater. Disse mer avanserte temaene er emnet for vårt kommende mer avanserte AI-kurs.
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/8-Reinforcement/2-Gym/assignment.md

@@ -0,0 +1,55 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "1f2b7441745eb52e25745423b247016b",
+  "translation_date": "2025-09-05T22:11:06+00:00",
+  "source_file": "8-Reinforcement/2-Gym/assignment.md",
+  "language_code": "no"
+}
+-->
+# Tren Mountain Car
+
+[OpenAI Gym](http://gym.openai.com) er designet slik at alle miljøer tilbyr samme API - altså de samme metodene `reset`, `step` og `render`, og de samme abstraksjonene for **handlingsrom** og **observasjonsrom**. Derfor bør det være mulig å tilpasse de samme forsterkningslæringsalgoritmene til forskjellige miljøer med minimale kodeendringer.
+
+## Et Mountain Car-miljø
+
+[Mountain Car-miljøet](https://gym.openai.com/envs/MountainCar-v0/) inneholder en bil som sitter fast i en dal:
+
+Målet er å komme seg ut av dalen og fange flagget, ved å utføre en av følgende handlinger på hvert steg:
+
+| Verdi | Betydning |
+|---|---|
+| 0 | Akselerer til venstre |
+| 1 | Ikke akselerer |
+| 2 | Akselerer til høyre |
+
+Hovedutfordringen i dette problemet er imidlertid at bilens motor ikke er sterk nok til å klatre opp fjellet i én enkelt passering. Derfor er den eneste måten å lykkes på å kjøre frem og tilbake for å bygge opp nok moment.
+
+Observasjonsrommet består kun av to verdier:
+
+| Nr | Observasjon  | Min | Maks |
+|-----|--------------|-----|-----|
+|  0  | Bilens posisjon | -1.2| 0.6 |
+|  1  | Bilens hastighet | -0.07 | 0.07 |
+
+Belønningssystemet for Mountain Car er ganske utfordrende:
+
+ * En belønning på 0 gis hvis agenten når flagget (posisjon = 0.5) på toppen av fjellet.
+ * En belønning på -1 gis hvis agentens posisjon er mindre enn 0.5.
+
+Episoden avsluttes hvis bilens posisjon er mer enn 0.5, eller hvis episodens lengde overstiger 200.
+## Instruksjoner
+
+Tilpass vår forsterkningslæringsalgoritme for å løse Mountain Car-problemet. Start med eksisterende [notebook.ipynb](../../../../8-Reinforcement/2-Gym/notebook.ipynb)-kode, bytt ut miljøet, endre funksjonene for diskretisering av tilstander, og prøv å få den eksisterende algoritmen til å trene med minimale kodeendringer. Optimaliser resultatet ved å justere hyperparametere.
+
+> **Merk**: Justering av hyperparametere vil sannsynligvis være nødvendig for at algoritmen skal konvergere. 
+## Vurderingskriterier
+
+| Kriterier | Eksemplarisk | Tilfredsstillende | Trenger forbedring |
+| -------- | --------- | -------- | ----------------- |
+|          | Q-Learning-algoritmen er vellykket tilpasset fra CartPole-eksempelet, med minimale kodeendringer, og er i stand til å løse problemet med å fange flagget på under 200 steg. | En ny Q-Learning-algoritme er hentet fra Internett, men er godt dokumentert; eller eksisterende algoritme er tilpasset, men oppnår ikke ønskede resultater | Studenten klarte ikke å tilpasse noen algoritme vellykket, men har gjort betydelige fremskritt mot løsningen (implementert tilstands-diskretisering, Q-Tabell datastruktur, osv.) |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/8-Reinforcement/2-Gym/solution/Julia/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
+  "translation_date": "2025-09-05T22:11:33+00:00",
+  "source_file": "8-Reinforcement/2-Gym/solution/Julia/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/8-Reinforcement/2-Gym/solution/R/README.md

@@ -0,0 +1,15 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
+  "translation_date": "2025-09-05T22:11:24+00:00",
+  "source_file": "8-Reinforcement/2-Gym/solution/R/README.md",
+  "language_code": "no"
+}
+-->
+
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/8-Reinforcement/README.md

@@ -0,0 +1,67 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "20ca019012b1725de956681d036d8b18",
+  "translation_date": "2025-09-05T22:01:42+00:00",
+  "source_file": "8-Reinforcement/README.md",
+  "language_code": "no"
+}
+-->
+# Introduksjon til forsterkende læring
+
+Forsterkende læring, RL, regnes som en av de grunnleggende paradigmer innen maskinlæring, ved siden av veiledet læring og uveiledet læring. RL handler om beslutninger: å ta riktige beslutninger eller i det minste lære av dem.
+
+Tenk deg at du har et simulert miljø, som aksjemarkedet. Hva skjer hvis du innfører en gitt regulering? Har det en positiv eller negativ effekt? Hvis noe negativt skjer, må du ta denne _negative forsterkningen_, lære av den og endre kurs. Hvis det er et positivt utfall, må du bygge videre på den _positive forsterkningen_.
+
+![Peter og ulven](../../../8-Reinforcement/images/peter.png)
+
+> Peter og vennene hans må unnslippe den sultne ulven! Bilde av [Jen Looper](https://twitter.com/jenlooper)
+
+## Regionalt tema: Peter og ulven (Russland)
+
+[Peter og ulven](https://en.wikipedia.org/wiki/Peter_and_the_Wolf) er et musikalsk eventyr skrevet av den russiske komponisten [Sergej Prokofjev](https://en.wikipedia.org/wiki/Sergei_Prokofiev). Det er en historie om den unge pioneren Peter, som modig går ut av huset sitt til skogkanten for å jage ulven. I denne delen skal vi trene maskinlæringsalgoritmer som vil hjelpe Peter:
+
+- **Utforske** området rundt og bygge et optimalt navigasjonskart.
+- **Lære** å bruke et skateboard og balansere på det, for å bevege seg raskere rundt.
+
+[![Peter og ulven](https://img.youtube.com/vi/Fmi5zHg4QSM/0.jpg)](https://www.youtube.com/watch?v=Fmi5zHg4QSM)
+
+> 🎥 Klikk på bildet over for å høre Peter og ulven av Prokofjev
+
+## Forsterkende læring
+
+I tidligere deler har du sett to eksempler på maskinlæringsproblemer:
+
+- **Veiledet**, der vi har datasett som foreslår eksempler på løsninger til problemet vi ønsker å løse. [Klassifisering](../4-Classification/README.md) og [regresjon](../2-Regression/README.md) er oppgaver innen veiledet læring.
+- **Uveiledet**, der vi ikke har merkede treningsdata. Hovedeksempelet på uveiledet læring er [Clustering](../5-Clustering/README.md).
+
+I denne delen vil vi introdusere deg for en ny type læringsproblem som ikke krever merkede treningsdata. Det finnes flere typer slike problemer:
+
+- **[Semi-veiledet læring](https://wikipedia.org/wiki/Semi-supervised_learning)**, der vi har mye umerkede data som kan brukes til å forhåndstrene modellen.
+- **[Forsterkende læring](https://wikipedia.org/wiki/Reinforcement_learning)**, der en agent lærer hvordan den skal oppføre seg ved å utføre eksperimenter i et simulert miljø.
+
+### Eksempel - dataspill
+
+Anta at du vil lære en datamaskin å spille et spill, som sjakk eller [Super Mario](https://wikipedia.org/wiki/Super_Mario). For at datamaskinen skal spille et spill, må den forutsi hvilken handling den skal ta i hver spilltilstand. Selv om dette kan virke som et klassifiseringsproblem, er det ikke det - fordi vi ikke har et datasett med tilstander og tilsvarende handlinger. Selv om vi kanskje har noen data, som eksisterende sjakkpartier eller opptak av spillere som spiller Super Mario, er det sannsynlig at disse dataene ikke dekker et stort nok antall mulige tilstander.
+
+I stedet for å lete etter eksisterende spilldata, er **Forsterkende læring** (RL) basert på ideen om *å få datamaskinen til å spille* mange ganger og observere resultatet. For å bruke forsterkende læring trenger vi to ting:
+
+- **Et miljø** og **en simulator** som lar oss spille et spill mange ganger. Denne simulatoren vil definere alle spillregler samt mulige tilstander og handlinger.
+
+- **En belønningsfunksjon**, som forteller oss hvor godt vi gjorde det under hver handling eller spill.
+
+Den største forskjellen mellom andre typer maskinlæring og RL er at i RL vet vi vanligvis ikke om vi vinner eller taper før vi er ferdige med spillet. Dermed kan vi ikke si om en bestemt handling alene er god eller ikke - vi mottar bare en belønning ved slutten av spillet. Målet vårt er å designe algoritmer som lar oss trene en modell under usikre forhold. Vi skal lære om en RL-algoritme kalt **Q-læring**.
+
+## Leksjoner
+
+1. [Introduksjon til forsterkende læring og Q-læring](1-QLearning/README.md)
+2. [Bruke et gymsimuleringsmiljø](2-Gym/README.md)
+
+## Kreditering
+
+"Introduksjon til forsterkende læring" ble skrevet med ♥️ av [Dmitry Soshnikov](http://soshnikov.com)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/9-Real-World/1-Applications/README.md

@@ -0,0 +1,159 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "83320d6b6994909e35d830cebf214039",
+  "translation_date": "2025-09-05T21:33:30+00:00",
+  "source_file": "9-Real-World/1-Applications/README.md",
+  "language_code": "no"
+}
+-->
+# Postscript: Maskinlæring i den virkelige verden
+
+![Oppsummering av maskinlæring i den virkelige verden i en sketchnote](../../../../sketchnotes/ml-realworld.png)
+> Sketchnote av [Tomomi Imura](https://www.twitter.com/girlie_mac)
+
+I dette kurset har du lært mange måter å forberede data for trening og lage maskinlæringsmodeller. Du har bygget en rekke klassiske regresjons-, klyngings-, klassifiserings-, naturlig språkbehandlings- og tidsseriemodeller. Gratulerer! Nå lurer du kanskje på hva alt dette skal brukes til... hva er de virkelige anvendelsene for disse modellene?
+
+Selv om AI, som ofte bruker dyp læring, har fått mye oppmerksomhet i industrien, finnes det fortsatt verdifulle bruksområder for klassiske maskinlæringsmodeller. Du bruker kanskje noen av disse anvendelsene allerede i dag! I denne leksjonen skal du utforske hvordan åtte ulike industrier og fagområder bruker disse typene modeller for å gjøre sine applikasjoner mer effektive, pålitelige, intelligente og verdifulle for brukerne.
+
+## [Quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)
+
+## 💰 Finans
+
+Finanssektoren tilbyr mange muligheter for maskinlæring. Mange problemer i dette området egner seg godt til å bli modellert og løst ved hjelp av ML.
+
+### Kredittkortsvindel
+
+Vi lærte om [k-means klynging](../../5-Clustering/2-K-Means/README.md) tidligere i kurset, men hvordan kan det brukes til å løse problemer relatert til kredittkortsvindel?
+
+K-means klynging er nyttig i en teknikk for kredittkortsvindel kalt **uteliggermåling**. Uteliggere, eller avvik i observasjoner om et datasett, kan fortelle oss om et kredittkort brukes på en normal måte eller om noe uvanlig skjer. Som vist i artikkelen nedenfor, kan du sortere kredittkortdata ved hjelp av en k-means klyngingsalgoritme og tilordne hver transaksjon til en klynge basert på hvor mye den skiller seg ut. Deretter kan du evaluere de mest risikable klyngene for å avgjøre om transaksjonene er svindel eller legitime.
+[Referanse](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.680.1195&rep=rep1&type=pdf)
+
+### Formuesforvaltning
+
+I formuesforvaltning håndterer en person eller firma investeringer på vegne av sine klienter. Jobben deres er å opprettholde og øke formuen på lang sikt, så det er viktig å velge investeringer som gir god avkastning.
+
+En måte å evaluere hvordan en investering presterer på er gjennom statistisk regresjon. [Lineær regresjon](../../2-Regression/1-Tools/README.md) er et verdifullt verktøy for å forstå hvordan et fond presterer i forhold til en referanseindeks. Vi kan også finne ut om resultatene av regresjonen er statistisk signifikante, eller hvor mye de vil påvirke en klients investeringer. Du kan til og med utvide analysen ved hjelp av multippel regresjon, hvor flere risikofaktorer tas med i betraktning. For et eksempel på hvordan dette fungerer for et spesifikt fond, se artikkelen nedenfor om evaluering av fondsprestasjoner ved hjelp av regresjon.
+[Referanse](http://www.brightwoodventures.com/evaluating-fund-performance-using-regression/)
+
+## 🎓 Utdanning
+
+Utdanningssektoren er også et veldig interessant område hvor ML kan brukes. Det finnes spennende problemer å løse, som å oppdage juks på prøver eller essays, eller håndtere skjevheter, enten de er utilsiktede eller ikke, i vurderingsprosessen.
+
+### Forutsi studentatferd
+
+[Coursera](https://coursera.com), en leverandør av åpne nettkurs, har en flott teknologiblogg hvor de diskuterer mange ingeniørbeslutninger. I denne casestudien plottet de en regresjonslinje for å utforske en mulig korrelasjon mellom en lav NPS (Net Promoter Score)-vurdering og kursretensjon eller frafall.
+[Referanse](https://medium.com/coursera-engineering/controlled-regression-quantifying-the-impact-of-course-quality-on-learner-retention-31f956bd592a)
+
+### Redusere skjevheter
+
+[Grammarly](https://grammarly.com), en skriveassistent som sjekker for stave- og grammatikkfeil, bruker sofistikerte [naturlig språkbehandlingssystemer](../../6-NLP/README.md) i sine produkter. De publiserte en interessant casestudie i sin teknologiblogg om hvordan de håndterte kjønnsbias i maskinlæring, som du lærte om i vår [introduksjonsleksjon om rettferdighet](../../1-Introduction/3-fairness/README.md).
+[Referanse](https://www.grammarly.com/blog/engineering/mitigating-gender-bias-in-autocorrect/)
+
+## 👜 Detaljhandel
+
+Detaljhandelssektoren kan definitivt dra nytte av bruk av ML, med alt fra å skape en bedre kundereise til å optimalisere lagerbeholdning.
+
+### Personalisere kundereisen
+
+Hos Wayfair, et selskap som selger hjemmevarer som møbler, er det avgjørende å hjelpe kundene med å finne de riktige produktene for deres smak og behov. I denne artikkelen beskriver ingeniører fra selskapet hvordan de bruker ML og NLP for å "vise de riktige resultatene for kundene". Spesielt har deres Query Intent Engine blitt bygget for å bruke enhetsuttrekking, klassifiseringstrening, uttrekking av eiendeler og meninger, og sentimentmerking på kundeanmeldelser. Dette er et klassisk eksempel på hvordan NLP fungerer i netthandel.
+[Referanse](https://www.aboutwayfair.com/tech-innovation/how-we-use-machine-learning-and-natural-language-processing-to-empower-search)
+
+### Lagerstyring
+
+Innovative, smidige selskaper som [StitchFix](https://stitchfix.com), en abonnementstjeneste som sender klær til forbrukere, er sterkt avhengige av ML for anbefalinger og lagerstyring. Deres stylingteam samarbeider med deres innkjøpsteam, faktisk: "en av våre dataforskere eksperimenterte med en genetisk algoritme og brukte den på klær for å forutsi hva som ville være et vellykket klesplagg som ikke eksisterer i dag. Vi presenterte dette for innkjøpsteamet, og nå kan de bruke det som et verktøy."
+[Referanse](https://www.zdnet.com/article/how-stitch-fix-uses-machine-learning-to-master-the-science-of-styling/)
+
+## 🏥 Helsevesen
+
+Helsevesenet kan bruke ML til å optimalisere forskningsoppgaver og logistiske problemer som å forhindre gjeninnleggelser eller stoppe sykdomsspredning.
+
+### Administrere kliniske studier
+
+Toksisitet i kliniske studier er en stor bekymring for legemiddelprodusenter. Hvor mye toksisitet er akseptabelt? I denne studien førte analyser av ulike metoder for kliniske studier til utviklingen av en ny tilnærming for å forutsi sannsynligheten for utfall i kliniske studier. Spesielt var de i stand til å bruke random forest for å lage en [klassifiserer](../../4-Classification/README.md) som kan skille mellom grupper av legemidler.
+[Referanse](https://www.sciencedirect.com/science/article/pii/S2451945616302914)
+
+### Administrere sykehusgjeninnleggelser
+
+Sykehusbehandling er kostbart, spesielt når pasienter må gjeninnlegges. Denne artikkelen diskuterer et selskap som bruker ML for å forutsi potensialet for gjeninnleggelser ved hjelp av [klynging](../../5-Clustering/README.md)-algoritmer. Disse klyngene hjelper analytikere med å "oppdage grupper av gjeninnleggelser som kan ha en felles årsak".
+[Referanse](https://healthmanagement.org/c/healthmanagement/issuearticle/hospital-readmissions-and-machine-learning)
+
+### Sykdomshåndtering
+
+Den nylige pandemien har kastet lys over hvordan maskinlæring kan bidra til å stoppe spredningen av sykdommer. I denne artikkelen vil du kjenne igjen bruken av ARIMA, logistiske kurver, lineær regresjon og SARIMA. "Dette arbeidet er et forsøk på å beregne spredningshastigheten for dette viruset og dermed forutsi dødsfall, tilfriskninger og bekreftede tilfeller, slik at det kan hjelpe oss med å forberede oss bedre og overleve."
+[Referanse](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7979218/)
+
+## 🌲 Økologi og grønn teknologi
+
+Natur og økologi består av mange sensitive systemer hvor samspillet mellom dyr og natur kommer i fokus. Det er viktig å kunne måle disse systemene nøyaktig og handle riktig hvis noe skjer, som en skogbrann eller en nedgang i dyrepopulasjonen.
+
+### Skogforvaltning
+
+Du lærte om [forsterkende læring](../../8-Reinforcement/README.md) i tidligere leksjoner. Det kan være veldig nyttig når man prøver å forutsi mønstre i naturen. Spesielt kan det brukes til å spore økologiske problemer som skogbranner og spredning av invasive arter. I Canada brukte en gruppe forskere forsterkende læring for å bygge modeller for skogbrannens dynamikk basert på satellittbilder. Ved å bruke en innovativ "spatially spreading process (SSP)" forestilte de seg en skogbrann som "agenten ved enhver celle i landskapet." "Sett med handlinger brannen kan ta fra et sted på et gitt tidspunkt inkluderer å spre seg nord, sør, øst eller vest, eller ikke spre seg."
+
+Denne tilnærmingen snur den vanlige RL-oppsettet siden dynamikken i den tilsvarende Markov Decision Process (MDP) er en kjent funksjon for umiddelbar spredning av skogbrann." Les mer om de klassiske algoritmene brukt av denne gruppen på lenken nedenfor.
+[Referanse](https://www.frontiersin.org/articles/10.3389/fict.2018.00006/full)
+
+### Bevegelsessporing av dyr
+
+Mens dyp læring har skapt en revolusjon i visuell sporing av dyrebevegelser (du kan bygge din egen [isbjørnsporer](https://docs.microsoft.com/learn/modules/build-ml-model-with-azure-stream-analytics/?WT.mc_id=academic-77952-leestott) her), har klassisk ML fortsatt en plass i denne oppgaven.
+
+Sensorer for å spore bevegelser hos husdyr og IoT bruker denne typen visuell prosessering, men mer grunnleggende ML-teknikker er nyttige for å forhåndsbehandle data. For eksempel, i denne artikkelen ble sauers kroppsholdninger overvåket og analysert ved hjelp av ulike klassifiseringsalgoritmer. Du vil kanskje kjenne igjen ROC-kurven på side 335.
+[Referanse](https://druckhaus-hofmann.de/gallery/31-wj-feb-2020.pdf)
+
+### ⚡️ Energistyring
+
+I våre leksjoner om [tidsserieprognoser](../../7-TimeSeries/README.md) introduserte vi konseptet med smarte parkeringsmålere for å generere inntekter for en by basert på forståelse av tilbud og etterspørsel. Denne artikkelen diskuterer i detalj hvordan klynging, regresjon og tidsserieprognoser kombineres for å hjelpe med å forutsi fremtidig energibruk i Irland, basert på smarte målere.
+[Referanse](https://www-cdn.knime.com/sites/default/files/inline-images/knime_bigdata_energy_timeseries_whitepaper.pdf)
+
+## 💼 Forsikring
+
+Forsikringssektoren er en annen sektor som bruker ML for å konstruere og optimalisere levedyktige finansielle og aktuarielle modeller.
+
+### Volatilitetsstyring
+
+MetLife, en leverandør av livsforsikring, er åpen om hvordan de analyserer og reduserer volatilitet i sine finansielle modeller. I denne artikkelen vil du legge merke til visualiseringer av binær og ordinal klassifisering. Du vil også oppdage visualiseringer av prognoser.
+[Referanse](https://investments.metlife.com/content/dam/metlifecom/us/investments/insights/research-topics/macro-strategy/pdf/MetLifeInvestmentManagement_MachineLearnedRanking_070920.pdf)
+
+## 🎨 Kunst, kultur og litteratur
+
+Innen kunst, for eksempel journalistikk, finnes det mange interessante problemer. Å oppdage falske nyheter er et stort problem, da det har vist seg å påvirke folks meninger og til og med undergrave demokratier. Museer kan også dra nytte av bruk av ML i alt fra å finne koblinger mellom artefakter til ressursplanlegging.
+
+### Oppdage falske nyheter
+
+Å oppdage falske nyheter har blitt et katt-og-mus-spill i dagens medier. I denne artikkelen foreslår forskere at et system som kombinerer flere av ML-teknikkene vi har studert kan testes, og den beste modellen kan implementeres: "Dette systemet er basert på naturlig språkbehandling for å trekke ut funksjoner fra dataene, og deretter brukes disse funksjonene til opplæring av maskinlæringsklassifiserere som Naive Bayes, Support Vector Machine (SVM), Random Forest (RF), Stochastic Gradient Descent (SGD) og Logistic Regression (LR)."
+[Referanse](https://www.irjet.net/archives/V7/i6/IRJET-V7I6688.pdf)
+
+Denne artikkelen viser hvordan kombinasjonen av ulike ML-domener kan gi interessante resultater som kan bidra til å stoppe spredningen av falske nyheter og forhindre reell skade; i dette tilfellet var motivasjonen spredningen av rykter om COVID-behandlinger som utløste voldelige opptøyer.
+
+### Museum ML
+
+Museer er på terskelen til en AI-revolusjon hvor katalogisering og digitalisering av samlinger og finne koblinger mellom artefakter blir enklere etter hvert som teknologien utvikler seg. Prosjekter som [In Codice Ratio](https://www.sciencedirect.com/science/article/abs/pii/S0306457321001035#:~:text=1.,studies%20over%20large%20historical%20sources.) hjelper med å låse opp mysteriene i utilgjengelige samlinger som Vatikanets arkiver. Men, den forretningsmessige siden av museer drar også nytte av ML-modeller.
+
+For eksempel bygde Art Institute of Chicago modeller for å forutsi hva publikum er interessert i og når de vil besøke utstillinger. Målet er å skape individualiserte og optimaliserte besøksopplevelser hver gang brukeren besøker museet. "I regnskapsåret 2017 forutså modellen besøkstall og inntekter med en nøyaktighet på 1 prosent, sier Andrew Simnick, senior visepresident ved Art Institute."
+[Referanse](https://www.chicagobusiness.com/article/20180518/ISSUE01/180519840/art-institute-of-chicago-uses-data-to-make-exhibit-choices)
+
+## 🏷 Markedsføring
+
+### Kundesegmentering
+
+De mest effektive markedsføringsstrategiene retter seg mot kunder på ulike måter basert på forskjellige grupperinger. I denne artikkelen diskuteres bruken av klyngingsalgoritmer for å støtte differensiert markedsføring. Differensiert markedsføring hjelper selskaper med å forbedre merkevaregjenkjenning, nå flere kunder og tjene mer penger.
+[Referanse](https://ai.inqline.com/machine-learning-for-marketing-customer-segmentation/)
+
+## 🚀 Utfordring
+
+Identifiser en annen sektor som drar nytte av noen av teknikkene du har lært i dette kurset, og oppdag hvordan den bruker ML.
+## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
+
+## Gjennomgang og selvstudium
+
+Wayfair sitt data science-team har flere interessante videoer om hvordan de bruker ML i selskapet sitt. Det er verdt [å ta en titt](https://www.youtube.com/channel/UCe2PjkQXqOuwkW1gw6Ameuw/videos)!
+
+## Oppgave
+
+[En ML skattejakt](assignment.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/9-Real-World/1-Applications/assignment.md

@@ -0,0 +1,27 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "fdebfcd0a3f12c9e2b436ded1aa79885",
+  "translation_date": "2025-09-05T21:34:24+00:00",
+  "source_file": "9-Real-World/1-Applications/assignment.md",
+  "language_code": "no"
+}
+-->
+# En ML Skattejakt
+
+## Instruksjoner
+
+I denne leksjonen lærte du om mange virkelige brukstilfeller som ble løst ved hjelp av klassisk ML. Selv om bruken av dyp læring, nye teknikker og verktøy innen AI, og utnyttelse av nevrale nettverk har bidratt til å akselerere utviklingen av verktøy for å hjelpe i disse sektorene, har klassisk ML ved bruk av teknikkene i dette pensumet fortsatt stor verdi.
+
+I denne oppgaven skal du forestille deg at du deltar i en hackathon. Bruk det du har lært i pensumet til å foreslå en løsning ved hjelp av klassisk ML for å løse et problem i en av sektorene som ble diskutert i denne leksjonen. Lag en presentasjon der du diskuterer hvordan du vil implementere ideen din. Ekstrapoeng hvis du kan samle inn eksempeldata og bygge en ML-modell for å støtte konseptet ditt!
+
+## Vurderingskriterier
+
+| Kriterier | Eksemplarisk                                                        | Tilfredsstillende                                 | Trenger forbedring     |
+| --------- | ------------------------------------------------------------------- | ------------------------------------------------ | ---------------------- |
+|           | En PowerPoint-presentasjon blir presentert - bonus for å bygge en modell | En ikke-innovativ, grunnleggende presentasjon blir presentert | Arbeidet er ufullstendig |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/9-Real-World/2-Debugging-ML-Models/README.md

@@ -0,0 +1,183 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "df2b538e8fbb3e91cf0419ae2f858675",
+  "translation_date": "2025-09-05T21:36:12+00:00",
+  "source_file": "9-Real-World/2-Debugging-ML-Models/README.md",
+  "language_code": "no"
+}
+-->
+# Postscript: Modellfeilsøking i maskinlæring ved bruk av komponenter fra Responsible AI-dashboardet
+
+## [Pre-lecture quiz](https://ff-quizzes.netlify.app/en/ml/)
+
+## Introduksjon
+
+Maskinlæring påvirker våre daglige liv. AI finner veien inn i noen av de viktigste systemene som berører oss som individer og samfunnet vårt, fra helsevesen, finans, utdanning og arbeidsliv. For eksempel er systemer og modeller involvert i daglige beslutningsoppgaver, som helsediagnoser eller deteksjon av svindel. Som en konsekvens blir fremskrittene innen AI og den akselererte adopsjonen møtt med stadig utviklende samfunnsforventninger og økende regulering. Vi ser stadig områder der AI-systemer ikke lever opp til forventningene; de avdekker nye utfordringer; og myndigheter begynner å regulere AI-løsninger. Derfor er det viktig at disse modellene analyseres for å sikre rettferdige, pålitelige, inkluderende, transparente og ansvarlige resultater for alle.
+
+I dette kurset skal vi se på praktiske verktøy som kan brukes til å vurdere om en modell har problemer knyttet til ansvarlig AI. Tradisjonelle feilsøkingsmetoder for maskinlæring er ofte basert på kvantitative beregninger som aggregert nøyaktighet eller gjennomsnittlig feilrate. Tenk deg hva som kan skje når dataene du bruker til å bygge disse modellene mangler visse demografiske grupper, som rase, kjønn, politisk syn, religion, eller er uforholdsmessig representert. Hva med når modellens output tolkes til å favorisere en demografisk gruppe? Dette kan føre til over- eller underrepresentasjon av sensitive egenskaper, noe som resulterer i rettferdighets-, inkluderings- eller pålitelighetsproblemer fra modellen. En annen faktor er at maskinlæringsmodeller ofte anses som "black boxes", noe som gjør det vanskelig å forstå og forklare hva som driver modellens prediksjoner. Alle disse er utfordringer dataforskere og AI-utviklere står overfor når de ikke har tilstrekkelige verktøy for å feilsøke og vurdere rettferdigheten eller påliteligheten til en modell.
+
+I denne leksjonen vil du lære om feilsøking av modeller ved bruk av:
+
+- **Feilanalyse**: Identifisere hvor i datadistribusjonen modellen har høye feilrater.
+- **Modelloversikt**: Utføre sammenlignende analyser på tvers av ulike datakohorter for å avdekke forskjeller i modellens ytelsesmetrikker.
+- **Dataanalyse**: Undersøke hvor det kan være over- eller underrepresentasjon i dataene som kan skjevfordele modellen til å favorisere én demografisk gruppe fremfor en annen.
+- **Funksjonsviktighet**: Forstå hvilke funksjoner som driver modellens prediksjoner på globalt eller lokalt nivå.
+
+## Forutsetninger
+
+Som en forutsetning, vennligst gjennomgå [Responsible AI tools for developers](https://www.microsoft.com/ai/ai-lab-responsible-ai-dashboard)
+
+> ![Gif om Responsible AI Tools](../../../../9-Real-World/2-Debugging-ML-Models/images/rai-overview.gif)
+
+## Feilanalyse
+
+Tradisjonelle ytelsesmetrikker for modeller som brukes til å måle nøyaktighet, er ofte beregninger basert på korrekte vs feilaktige prediksjoner. For eksempel kan det å fastslå at en modell er nøyaktig 89 % av tiden med en feilrate på 0,001 anses som god ytelse. Feilene er imidlertid ofte ikke jevnt fordelt i det underliggende datasettet. Du kan få en modellnøyaktighet på 89 %, men oppdage at det er ulike områder i dataene der modellen feiler 42 % av tiden. Konsekvensen av disse feilene i visse datagrupper kan føre til rettferdighets- eller pålitelighetsproblemer. Det er avgjørende å forstå områdene der modellen presterer godt eller ikke. Dataområdene med høy feilrate kan vise seg å være viktige demografiske grupper.
+
+![Analyser og feilsøk modellfeil](../../../../9-Real-World/2-Debugging-ML-Models/images/ea-error-distribution.png)
+
+Feilanalysemodulen på RAI-dashboardet illustrerer hvordan modellfeil er fordelt på ulike kohorter med en trevisualisering. Dette er nyttig for å identifisere funksjoner eller områder der det er høy feilrate i datasettet ditt. Ved å se hvor de fleste av modellens feil oppstår, kan du begynne å undersøke årsaken. Du kan også opprette datakohorter for å utføre analyser. Disse datakohortene hjelper i feilsøkingsprosessen med å avgjøre hvorfor modellens ytelse er god i én kohort, men feilaktig i en annen.
+
+![Feilanalyse](../../../../9-Real-World/2-Debugging-ML-Models/images/ea-error-cohort.png)
+
+De visuelle indikatorene på trevisualiseringen hjelper deg med å lokalisere problemområdene raskere. For eksempel, jo mørkere rødfargen på en tre-node, desto høyere er feilraten.
+
+Varmekart er en annen visualiseringsfunksjonalitet som brukere kan bruke til å undersøke feilraten ved hjelp av én eller to funksjoner for å finne bidragsytere til modellfeil på tvers av hele datasettet eller kohorter.
+
+![Feilanalyse Varmekart](../../../../9-Real-World/2-Debugging-ML-Models/images/ea-heatmap.png)
+
+Bruk feilanalyse når du trenger å:
+
+* Få en dyp forståelse av hvordan modellfeil er fordelt på et datasett og på flere input- og funksjonsdimensjoner.
+* Bryte ned de samlede ytelsesmetrikker for automatisk å oppdage feilaktige kohorter og informere om målrettede tiltak for å redusere feil.
+
+## Modelloversikt
+
+Evaluering av ytelsen til en maskinlæringsmodell krever en helhetlig forståelse av dens oppførsel. Dette kan oppnås ved å gjennomgå mer enn én metrikk, som feilrate, nøyaktighet, tilbakekalling, presisjon eller MAE (Mean Absolute Error), for å finne forskjeller blant ytelsesmetrikker. Én ytelsesmetrikk kan se bra ut, men unøyaktigheter kan avdekkes i en annen metrikk. I tillegg hjelper sammenligning av metrikker for forskjeller på tvers av hele datasettet eller kohorter med å belyse hvor modellen presterer godt eller ikke. Dette er spesielt viktig for å se modellens ytelse blant sensitive vs insensitive funksjoner (f.eks. pasientens rase, kjønn eller alder) for å avdekke potensiell urettferdighet modellen kan ha. For eksempel kan det å oppdage at modellen er mer feilaktig i en kohort med sensitive funksjoner avsløre potensiell urettferdighet.
+
+Modelloversiktsmodulen på RAI-dashboardet hjelper ikke bare med å analysere ytelsesmetrikker for datarepresentasjon i en kohort, men gir brukere muligheten til å sammenligne modellens oppførsel på tvers av ulike kohorter.
+
+![Datasettkohorter - modelloversikt i RAI-dashboardet](../../../../9-Real-World/2-Debugging-ML-Models/images/model-overview-dataset-cohorts.png)
+
+Modulens funksjonsbaserte analysefunksjonalitet lar brukere snevre inn datasubgrupper innenfor en bestemt funksjon for å identifisere avvik på et detaljert nivå. For eksempel har dashboardet innebygd intelligens for automatisk å generere kohorter for en bruker-valgt funksjon (f.eks. *"time_in_hospital < 3"* eller *"time_in_hospital >= 7"*). Dette gjør det mulig for en bruker å isolere en bestemt funksjon fra en større datagruppe for å se om den er en nøkkelpåvirker for modellens feilaktige resultater.
+
+![Funksjonskohorter - modelloversikt i RAI-dashboardet](../../../../9-Real-World/2-Debugging-ML-Models/images/model-overview-feature-cohorts.png)
+
+Modelloversiktsmodulen støtter to klasser av forskjellsmetrikker:
+
+**Forskjeller i modellens ytelse**: Disse metrikker beregner forskjellen i verdiene til den valgte ytelsesmetrikk på tvers av undergrupper av data. Her er noen eksempler:
+
+* Forskjell i nøyaktighetsrate
+* Forskjell i feilrate
+* Forskjell i presisjon
+* Forskjell i tilbakekalling
+* Forskjell i gjennomsnittlig absolutt feil (MAE)
+
+**Forskjeller i utvalgsrate**: Denne metrikk inneholder forskjellen i utvalgsrate (gunstig prediksjon) blant undergrupper. Et eksempel på dette er forskjellen i lånegodkjenningsrater. Utvalgsrate betyr andelen datapunkter i hver klasse klassifisert som 1 (i binær klassifisering) eller distribusjonen av prediksjonsverdier (i regresjon).
+
+## Dataanalyse
+
+> "Hvis du torturerer dataene lenge nok, vil de tilstå hva som helst" - Ronald Coase
+
+Denne uttalelsen høres ekstrem ut, men det er sant at data kan manipuleres for å støtte enhver konklusjon. Slik manipulasjon kan noen ganger skje utilsiktet. Som mennesker har vi alle bias, og det er ofte vanskelig å bevisst vite når vi introduserer bias i dataene. Å garantere rettferdighet i AI og maskinlæring forblir en kompleks utfordring.
+
+Data er et stort blindpunkt for tradisjonelle modellytelsesmetrikker. Du kan ha høye nøyaktighetsscorer, men dette reflekterer ikke alltid den underliggende databiasen som kan være i datasettet ditt. For eksempel, hvis et datasett med ansatte har 27 % kvinner i lederstillinger i et selskap og 73 % menn på samme nivå, kan en AI-modell for jobbannonsering som er trent på disse dataene, målrette seg mot en overvekt av mannlige kandidater for seniorstillinger. Denne ubalansen i dataene skjevfordelte modellens prediksjon til å favorisere ett kjønn. Dette avslører et rettferdighetsproblem der det er kjønnsbias i AI-modellen.
+
+Dataanalysemodulen på RAI-dashboardet hjelper med å identifisere områder der det er over- og underrepresentasjon i datasettet. Den hjelper brukere med å diagnostisere årsaken til feil og rettferdighetsproblemer som introduseres fra dataubalanser eller mangel på representasjon av en bestemt datagruppe. Dette gir brukere muligheten til å visualisere datasett basert på predikerte og faktiske resultater, feilgrupper og spesifikke funksjoner. Noen ganger kan det å oppdage en underrepresentert datagruppe også avdekke at modellen ikke lærer godt, og dermed har høye unøyaktigheter. En modell med databias er ikke bare et rettferdighetsproblem, men viser også at modellen ikke er inkluderende eller pålitelig.
+
+![Dataanalysemodulen på RAI-dashboardet](../../../../9-Real-World/2-Debugging-ML-Models/images/dataanalysis-cover.png)
+
+Bruk dataanalyse når du trenger å:
+
+* Utforske statistikken i datasettet ditt ved å velge ulike filtre for å dele opp dataene i ulike dimensjoner (også kjent som kohorter).
+* Forstå distribusjonen av datasettet ditt på tvers av ulike kohorter og funksjonsgrupper.
+* Bestemme om funnene dine relatert til rettferdighet, feilanalyse og årsakssammenhenger (avledet fra andre dashboardmoduler) er et resultat av distribusjonen i datasettet ditt.
+* Avgjøre hvilke områder du bør samle inn mer data for å redusere feil som kommer fra representasjonsproblemer, støy i etiketter, støy i funksjoner, etikettbias og lignende faktorer.
+
+## Modellfortolkning
+
+Maskinlæringsmodeller har en tendens til å være "black boxes". Å forstå hvilke nøkkelfunksjoner i dataene som driver en modells prediksjon kan være utfordrende. Det er viktig å gi transparens om hvorfor en modell gjør en bestemt prediksjon. For eksempel, hvis et AI-system forutsier at en diabetiker er i fare for å bli innlagt på sykehus igjen innen 30 dager, bør det kunne gi støttende data som ledet til denne prediksjonen. Å ha støttende dataindikatorer gir transparens som hjelper klinikere eller sykehus med å ta velinformerte beslutninger. I tillegg gjør det å kunne forklare hvorfor en modell gjorde en prediksjon for en individuell pasient det mulig å oppfylle ansvarlighet med helsereguleringer. Når du bruker maskinlæringsmodeller på måter som påvirker menneskers liv, er det avgjørende å forstå og forklare hva som påvirker modellens oppførsel. Modellforklarbarhet og fortolkning hjelper med å svare på spørsmål i scenarier som:
+
+* Modellfeilsøking: Hvorfor gjorde modellen min denne feilen? Hvordan kan jeg forbedre modellen min?
+* Menneske-AI-samarbeid: Hvordan kan jeg forstå og stole på modellens beslutninger?
+* Regulatorisk samsvar: Oppfyller modellen min juridiske krav?
+
+Funksjonsviktighetsmodulen på RAI-dashboardet hjelper deg med å feilsøke og få en omfattende forståelse av hvordan en modell gjør prediksjoner. Det er også et nyttig verktøy for maskinlæringsprofesjonelle og beslutningstakere for å forklare og vise bevis på funksjoner som påvirker modellens oppførsel for regulatorisk samsvar. Videre kan brukere utforske både globale og lokale forklaringer for å validere hvilke funksjoner som driver modellens prediksjon. Globale forklaringer viser de viktigste funksjonene som påvirket modellens samlede prediksjon. Lokale forklaringer viser hvilke funksjoner som ledet til modellens prediksjon for en individuell sak. Muligheten til å evaluere lokale forklaringer er også nyttig i feilsøking eller revisjon av en spesifikk sak for bedre å forstå og tolke hvorfor en modell gjorde en korrekt eller feilaktig prediksjon.
+
+![Funksjonsviktighetsmodulen på RAI-dashboardet](../../../../9-Real-World/2-Debugging-ML-Models/images/9-feature-importance.png)
+
+* Globale forklaringer: For eksempel, hvilke funksjoner påvirker den generelle oppførselen til en diabetesmodell for sykehusinnleggelse?
+* Lokale forklaringer: For eksempel, hvorfor ble en diabetiker over 60 år med tidligere sykehusinnleggelser forutsagt å bli innlagt eller ikke innlagt igjen innen 30 dager?
+
+I feilsøkingsprosessen med å undersøke modellens ytelse på tvers av ulike kohorter, viser Funksjonsviktighet hvilken grad av påvirkning en funksjon har på tvers av kohorter. Det hjelper med å avdekke avvik når man sammenligner nivået av innflytelse funksjonen har på å drive modellens feilaktige prediksjoner. Funksjonsviktighetsmodulen kan vise hvilke verdier i en funksjon som positivt eller negativt påvirket modellens resultat. For eksempel, hvis en modell gjorde en feilaktig prediksjon, gir modulen deg muligheten til å bore ned og identifisere hvilke funksjoner eller funksjonsverdier som drev prediksjonen. Dette detaljnivået hjelper ikke bare med feilsøking, men gir transparens og ansvarlighet i revisjonssituasjoner. Til slutt kan modulen hjelpe deg med å identifisere rettferdighetsproblemer. For å illustrere, hvis en sensitiv funksjon som etnisitet eller kjønn har stor innflytelse på modellens prediksjon, kan dette være et tegn på rase- eller kjønnsbias i modellen.
+
+![Funksjonsviktighet](../../../../9-Real-World/2-Debugging-ML-Models/images/9-features-influence.png)
+
+Bruk fortolkning når du trenger å:
+
+* Bestemme hvor pålitelige prediksjonene til AI-systemet ditt er ved å forstå hvilke funksjoner som er viktigst for prediksjonene.
+* Tilnærme deg feilsøkingen av modellen din ved først å forstå den og identifisere om modellen bruker sunne funksjoner eller bare falske korrelasjoner.
+* Avdekke potensielle kilder til urettferdighet ved å forstå om modellen baserer prediksjoner på sensitive funksjoner eller på funksjoner som er sterkt korrelert med dem.
+* Bygge brukertillit til modellens beslutninger ved å generere lokale forklaringer for å illustrere resultatene.
+* Fullføre en regulatorisk revisjon av et AI-system for å validere modeller og overvåke effekten av modellens beslutninger på mennesker.
+
+## Konklusjon
+
+Alle komponentene i RAI-dashboardet er praktiske verktøy som hjelper deg med å bygge maskinlæringsmodeller som er mindre skadelige og mer pålitelige for samfunnet. Det forbedrer forebyggingen av trusler mot menneskerettigheter; diskriminering eller ekskludering av visse grupper fra livsmuligheter; og risikoen for fysisk eller psykisk skade. Det hjelper også med å bygge tillit til modellens beslutninger ved å generere lokale forklaringer for å illustrere resultatene. Noen av de potensielle skadene kan klassifiseres som:
+
+- **Allokering**, hvis for eksempel ett kjønn eller en etnisitet favoriseres over en annen.
+- **Tjenestekvalitet**. Hvis du trener dataene for ett spesifikt scenario, men virkeligheten er mye mer kompleks, fører det til en dårlig fungerende tjeneste.
+- **Stereotypisering**. Å assosiere en gitt gruppe med forhåndsbestemte attributter.
+- **Nedvurdering**. Å urettferdig kritisere og merke noe eller noen.
+- **Over- eller underrepresentasjon**. Tanken er at en bestemt gruppe ikke er synlig i en viss yrke, og enhver tjeneste eller funksjon som fortsetter å fremme dette bidrar til skade.
+
+### Azure RAI-dashboard
+
+[Azure RAI-dashboard](https://learn.microsoft.com/en-us/azure/machine-learning/concept-responsible-ai-dashboard?WT.mc_id=aiml-90525-ruyakubu) er bygget på åpen kildekodeverktøy utviklet av ledende akademiske institusjoner og organisasjoner, inkludert Microsoft, som er avgjørende for datasientister og AI-utviklere for bedre å forstå modellatferd, oppdage og redusere uønskede problemer fra AI-modeller.
+
+- Lær hvordan du bruker de forskjellige komponentene ved å sjekke ut RAI-dashboard [dokumentasjonen.](https://learn.microsoft.com/en-us/azure/machine-learning/how-to-responsible-ai-dashboard?WT.mc_id=aiml-90525-ruyakubu)
+
+- Sjekk ut noen RAI-dashboard [eksempelskript](https://github.com/Azure/RAI-vNext-Preview/tree/main/examples/notebooks) for å feilsøke mer ansvarlige AI-scenarier i Azure Machine Learning.
+
+---
+## 🚀 Utfordring
+
+For å forhindre at statistiske eller datamessige skjevheter introduseres i utgangspunktet, bør vi:
+
+- ha en mangfoldig bakgrunn og ulike perspektiver blant de som jobber med systemene
+- investere i datasett som reflekterer mangfoldet i samfunnet vårt
+- utvikle bedre metoder for å oppdage og korrigere skjevheter når de oppstår
+
+Tenk på virkelige situasjoner der urettferdighet er tydelig i modellbygging og bruk. Hva annet bør vi ta hensyn til?
+
+## [Quiz etter forelesning](https://ff-quizzes.netlify.app/en/ml/)
+## Gjennomgang og selvstudium
+
+I denne leksjonen har du lært noen av de praktiske verktøyene for å integrere ansvarlig AI i maskinlæring.
+
+Se denne workshoppen for å dykke dypere inn i temaene:
+
+- Responsible AI Dashboard: En helhetlig løsning for å operationalisere RAI i praksis av Besmira Nushi og Mehrnoosh Sameki
+
+[![Responsible AI Dashboard: En helhetlig løsning for å operationalisere RAI i praksis](https://img.youtube.com/vi/f1oaDNl3djg/0.jpg)](https://www.youtube.com/watch?v=f1oaDNl3djg "Responsible AI Dashboard: En helhetlig løsning for å operationalisere RAI i praksis")
+
+> 🎥 Klikk på bildet over for en video: Responsible AI Dashboard: En helhetlig løsning for å operationalisere RAI i praksis av Besmira Nushi og Mehrnoosh Sameki
+
+Referer til følgende materialer for å lære mer om ansvarlig AI og hvordan man bygger mer pålitelige modeller:
+
+- Microsofts RAI-dashboardverktøy for feilsøking av ML-modeller: [Ressurser for ansvarlige AI-verktøy](https://aka.ms/rai-dashboard)
+
+- Utforsk Responsible AI-verktøysettet: [Github](https://github.com/microsoft/responsible-ai-toolbox)
+
+- Microsofts RAI-ressurssenter: [Ressurser for ansvarlig AI – Microsoft AI](https://www.microsoft.com/ai/responsible-ai-resources?activetab=pivot1%3aprimaryr4)
+
+- Microsofts FATE-forskningsgruppe: [FATE: Fairness, Accountability, Transparency, and Ethics in AI - Microsoft Research](https://www.microsoft.com/research/theme/fate/)
+
+## Oppgave
+
+[Utforsk RAI-dashboard](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.

translations/no/9-Real-World/2-Debugging-ML-Models/assignment.md

@@ -0,0 +1,25 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "91c6a180ef08e20cc15acfd2d6d6e164",
+  "translation_date": "2025-09-05T21:37:15+00:00",
+  "source_file": "9-Real-World/2-Debugging-ML-Models/assignment.md",
+  "language_code": "no"
+}
+-->
+# Utforsk Responsible AI (RAI) dashboard
+
+## Instruksjoner
+
+I denne leksjonen lærte du om RAI dashboard, en samling av komponenter bygget på "open-source"-verktøy for å hjelpe dataforskere med feilanalyse, datautforskning, vurdering av rettferdighet, modellfortolkning, kontrafaktiske/hva-hvis-vurderinger og kausalanalyse på AI-systemer. For denne oppgaven, utforsk noen av RAI dashboard sine eksempler [notebooks](https://github.com/Azure/RAI-vNext-Preview/tree/main/examples/notebooks) og rapporter funnene dine i et papir eller en presentasjon.
+
+## Vurderingskriterier
+
+| Kriterier | Fremragende | Tilfredsstillende | Trenger forbedring |
+| --------- | ----------- | ----------------- | ------------------ |
+|           | Et papir eller PowerPoint-presentasjon blir levert som diskuterer RAI dashboard sine komponenter, notebook som ble kjørt, og konklusjonene som ble trukket fra å kjøre den | Et papir blir levert uten konklusjoner | Ingen papir blir levert |
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/9-Real-World/README.md

@@ -0,0 +1,32 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "5e069a0ac02a9606a69946c2b3c574a9",
+  "translation_date": "2025-09-05T21:31:41+00:00",
+  "source_file": "9-Real-World/README.md",
+  "language_code": "no"
+}
+-->
+# Postscript: Virkelige anvendelser av klassisk maskinlæring
+
+I denne delen av læreplanen vil du bli introdusert for noen virkelige anvendelser av klassisk ML. Vi har søkt på internett for å finne forskningsartikler og artikler om applikasjoner som har brukt disse strategiene, og unngått nevrale nettverk, dyp læring og AI så mye som mulig. Lær om hvordan ML brukes i forretningssystemer, økologiske applikasjoner, finans, kunst og kultur, og mer.
+
+![chess](../../../9-Real-World/images/chess.jpg)
+
+> Foto av <a href="https://unsplash.com/@childeye?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Alexis Fauvet</a> på <a href="https://unsplash.com/s/photos/artificial-intelligence?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
+  
+## Leksjon
+
+1. [Virkelige anvendelser for ML](1-Applications/README.md)
+2. [Feilsøking av modeller i maskinlæring ved bruk av Responsible AI dashboard-komponenter](2-Debugging-ML-Models/README.md)
+
+## Kreditering
+
+"Virkelige anvendelser" ble skrevet av et team av folk, inkludert [Jen Looper](https://twitter.com/jenlooper) og [Ornella Altunyan](https://twitter.com/ornelladotcom).
+
+"Feilsøking av modeller i maskinlæring ved bruk av Responsible AI dashboard-komponenter" ble skrevet av [Ruth Yakubu](https://twitter.com/ruthieyakubu)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/CODE_OF_CONDUCT.md

@@ -0,0 +1,23 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "c06b12caf3c901eb3156e3dd5b0aea56",
+  "translation_date": "2025-09-05T21:04:33+00:00",
+  "source_file": "CODE_OF_CONDUCT.md",
+  "language_code": "no"
+}
+-->
+# Microsoft Open Source Code of Conduct
+
+Dette prosjektet har tatt i bruk [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
+
+Ressurser:
+
+- [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/)
+- [Microsoft Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/)
+- Kontakt [opencode@microsoft.com](mailto:opencode@microsoft.com) ved spørsmål eller bekymringer
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/CONTRIBUTING.md

@@ -0,0 +1,30 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "977ec5266dfd78ad1ce2bd8d46fccbda",
+  "translation_date": "2025-09-05T21:03:17+00:00",
+  "source_file": "CONTRIBUTING.md",
+  "language_code": "no"
+}
+-->
+# Bidra
+
+Dette prosjektet ønsker bidrag og forslag velkommen. De fleste bidrag krever at du
+godtar en Contributor License Agreement (CLA) som erklærer at du har rett til,
+og faktisk gir oss rettighetene til å bruke ditt bidrag. For detaljer, besøk
+https://cla.microsoft.com.
+
+> Viktig: når du oversetter tekst i dette repoet, må du sørge for at du ikke bruker maskinoversettelse. Vi vil verifisere oversettelser via fellesskapet, så vennligst kun bidra med oversettelser til språk du er dyktig i.
+
+Når du sender inn en pull request, vil en CLA-bot automatisk avgjøre om du trenger
+å gi en CLA og dekorere PR-en deretter (f.eks. etikett, kommentar). Følg bare
+instruksjonene gitt av boten. Du trenger kun å gjøre dette én gang på tvers av alle repositorier som bruker vår CLA.
+
+Dette prosjektet har tatt i bruk [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
+For mer informasjon, se [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/)
+eller kontakt [opencode@microsoft.com](mailto:opencode@microsoft.com) med eventuelle spørsmål eller kommentarer.
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/README.md

@@ -0,0 +1,177 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "612aef7a03204260e940131b09691977",
+  "translation_date": "2025-09-05T21:01:50+00:00",
+  "source_file": "README.md",
+  "language_code": "no"
+}
+-->
+[![GitHub license](https://img.shields.io/github/license/microsoft/ML-For-Beginners.svg)](https://github.com/microsoft/ML-For-Beginners/blob/master/LICENSE)  
+[![GitHub contributors](https://img.shields.io/github/contributors/microsoft/ML-For-Beginners.svg)](https://GitHub.com/microsoft/ML-For-Beginners/graphs/contributors/)  
+[![GitHub issues](https://img.shields.io/github/issues/microsoft/ML-For-Beginners.svg)](https://GitHub.com/microsoft/ML-For-Beginners/issues/)  
+[![GitHub pull-requests](https://img.shields.io/github/issues-pr/microsoft/ML-For-Beginners.svg)](https://GitHub.com/microsoft/ML-For-Beginners/pulls/)  
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)  
+
+[![GitHub watchers](https://img.shields.io/github/watchers/microsoft/ML-For-Beginners.svg?style=social&label=Watch)](https://GitHub.com/microsoft/ML-For-Beginners/watchers/)  
+[![GitHub forks](https://img.shields.io/github/forks/microsoft/ML-For-Beginners.svg?style=social&label=Fork)](https://GitHub.com/microsoft/ML-For-Beginners/network/)  
+[![GitHub stars](https://img.shields.io/github/stars/microsoft/ML-For-Beginners.svg?style=social&label=Star)](https://GitHub.com/microsoft/ML-For-Beginners/stargazers/)  
+
+### 🌐 Støtte for flere språk  
+
+#### Støttet via GitHub Action (Automatisk og alltid oppdatert)  
+
+[French](../fr/README.md) | [Spanish](../es/README.md) | [German](../de/README.md) | [Russian](../ru/README.md) | [Arabic](../ar/README.md) | [Persian (Farsi)](../fa/README.md) | [Urdu](../ur/README.md) | [Chinese (Simplified)](../zh/README.md) | [Chinese (Traditional, Macau)](../mo/README.md) | [Chinese (Traditional, Hong Kong)](../hk/README.md) | [Chinese (Traditional, Taiwan)](../tw/README.md) | [Japanese](../ja/README.md) | [Korean](../ko/README.md) | [Hindi](../hi/README.md) | [Bengali](../bn/README.md) | [Marathi](../mr/README.md) | [Nepali](../ne/README.md) | [Punjabi (Gurmukhi)](../pa/README.md) | [Portuguese (Portugal)](../pt/README.md) | [Portuguese (Brazil)](../br/README.md) | [Italian](../it/README.md) | [Polish](../pl/README.md) | [Turkish](../tr/README.md) | [Greek](../el/README.md) | [Thai](../th/README.md) | [Swedish](../sv/README.md) | [Danish](../da/README.md) | [Norwegian](./README.md) | [Finnish](../fi/README.md) | [Dutch](../nl/README.md) | [Hebrew](../he/README.md) | [Vietnamese](../vi/README.md) | [Indonesian](../id/README.md) | [Malay](../ms/README.md) | [Tagalog (Filipino)](../tl/README.md) | [Swahili](../sw/README.md) | [Hungarian](../hu/README.md) | [Czech](../cs/README.md) | [Slovak](../sk/README.md) | [Romanian](../ro/README.md) | [Bulgarian](../bg/README.md) | [Serbian (Cyrillic)](../sr/README.md) | [Croatian](../hr/README.md) | [Slovenian](../sl/README.md) | [Ukrainian](../uk/README.md) | [Burmese (Myanmar)](../my/README.md)  
+
+#### Bli med i fellesskapet  
+
+[![Azure AI Discord](https://dcbadge.limes.pink/api/server/kzRShWzttr)](https://discord.gg/kzRShWzttr)  
+
+# Maskinlæring for nybegynnere - Et pensum  
+
+> 🌍 Reis rundt i verden mens vi utforsker maskinlæring gjennom verdens kulturer 🌍  
+
+Cloud Advocates hos Microsoft er glade for å tilby et 12-ukers, 26-leksjons pensum om **maskinlæring**. I dette pensumet vil du lære om det som noen ganger kalles **klassisk maskinlæring**, hovedsakelig ved bruk av Scikit-learn som bibliotek og unngå dyp læring, som dekkes i vårt [AI for Beginners-pensum](https://aka.ms/ai4beginners). Kombiner disse leksjonene med vårt ['Data Science for Beginners'-pensum](https://aka.ms/ds4beginners), også!  
+
+Reis med oss rundt i verden mens vi bruker disse klassiske teknikkene på data fra mange områder av verden. Hver leksjon inkluderer quiz før og etter leksjonen, skriftlige instruksjoner for å fullføre leksjonen, en løsning, en oppgave og mer. Vår prosjektbaserte pedagogikk lar deg lære mens du bygger, en bevist måte å få nye ferdigheter til å sitte.  
+
+**✍️ Stor takk til våre forfattere** Jen Looper, Stephen Howell, Francesca Lazzeri, Tomomi Imura, Cassie Breviu, Dmitry Soshnikov, Chris Noring, Anirban Mukherjee, Ornella Altunyan, Ruth Yakubu og Amy Boyd  
+
+**🎨 Takk også til våre illustratører** Tomomi Imura, Dasani Madipalli og Jen Looper  
+
+**🙏 Spesiell takk 🙏 til våre Microsoft Student Ambassador-forfattere, anmeldere og innholdsbidragsytere**, spesielt Rishit Dagli, Muhammad Sakib Khan Inan, Rohan Raj, Alexandru Petrescu, Abhishek Jaiswal, Nawrin Tabassum, Ioan Samuila og Snigdha Agarwal  
+
+**🤩 Ekstra takknemlighet til Microsoft Student Ambassadors Eric Wanjau, Jasleen Sondhi og Vidushi Gupta for våre R-leksjoner!**  
+
+# Kom i gang  
+
+Følg disse trinnene:  
+1. **Fork repoet**: Klikk på "Fork"-knappen øverst til høyre på denne siden.  
+2. **Klon repoet**:   `git clone https://github.com/microsoft/ML-For-Beginners.git`  
+
+> [finn alle tilleggsmaterialer for dette kurset i vår Microsoft Learn-samling](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)  
+
+**[Studenter](https://aka.ms/student-page)**, for å bruke dette pensumet, fork hele repoet til din egen GitHub-konto og fullfør oppgavene alene eller med en gruppe:  
+
+- Start med en quiz før leksjonen.  
+- Les leksjonen og fullfør aktivitetene, ta pauser og reflekter ved hver kunnskapssjekk.  
+- Prøv å lage prosjektene ved å forstå leksjonene i stedet for å kjøre løsningskoden; men den koden er tilgjengelig i `/solution`-mappene i hver prosjektorienterte leksjon.  
+- Ta quiz etter leksjonen.  
+- Fullfør utfordringen.  
+- Fullfør oppgaven.  
+- Etter å ha fullført en leksjonsgruppe, besøk [Diskusjonsforumet](https://github.com/microsoft/ML-For-Beginners/discussions) og "lær høyt" ved å fylle ut den passende PAT-rubrikken. En 'PAT' er et Progress Assessment Tool som er en rubrikk du fyller ut for å fremme læringen din. Du kan også reagere på andre PAT-er slik at vi kan lære sammen.  
+
+> For videre studier anbefaler vi å følge disse [Microsoft Learn](https://docs.microsoft.com/en-us/users/jenlooper-2911/collections/k7o7tg1gp306q4?WT.mc_id=academic-77952-leestott)-modulene og læringsstiene.  
+
+**Lærere**, vi har [inkludert noen forslag](for-teachers.md) om hvordan du kan bruke dette pensumet.  
+
+---
+
+## Videogjennomganger  
+
+Noen av leksjonene er tilgjengelige som korte videoer. Du finner alle disse i leksjonene, eller på [ML for Beginners-spillelisten på Microsoft Developer YouTube-kanalen](https://aka.ms/ml-beginners-videos) ved å klikke på bildet nedenfor.  
+
+[![ML for beginners banner](../../images/ml-for-beginners-video-banner.png)](https://aka.ms/ml-beginners-videos)  
+
+---
+
+## Møt teamet  
+
+[![Promo video](../../images/ml.gif)](https://youtu.be/Tj1XWrDSYJU)  
+
+**Gif av** [Mohit Jaisal](https://linkedin.com/in/mohitjaisal)  
+
+> 🎥 Klikk på bildet ovenfor for en video om prosjektet og folkene som skapte det!  
+
+---
+
+## Pedagogikk  
+
+Vi har valgt to pedagogiske prinsipper mens vi bygde dette pensumet: å sikre at det er praktisk **prosjektbasert** og at det inkluderer **hyppige quizer**. I tillegg har dette pensumet et felles **tema** for å gi det sammenheng.  
+
+Ved å sikre at innholdet er knyttet til prosjekter, blir prosessen mer engasjerende for studenter, og begrepsforståelsen vil bli styrket. I tillegg setter en lavterskelquiz før en klasse studentens intensjon mot å lære et emne, mens en andre quiz etter klassen sikrer ytterligere forståelse. Dette pensumet ble designet for å være fleksibelt og morsomt og kan tas i sin helhet eller delvis. Prosjektene starter små og blir stadig mer komplekse mot slutten av den 12-ukers syklusen. Dette pensumet inkluderer også et tillegg om virkelige applikasjoner av ML, som kan brukes som ekstra kreditt eller som grunnlag for diskusjon.  
+
+> Finn vår [Code of Conduct](CODE_OF_CONDUCT.md), [Contributing](CONTRIBUTING.md), og [Translation](TRANSLATIONS.md)-retningslinjer. Vi ønsker din konstruktive tilbakemelding velkommen!  
+
+## Hver leksjon inkluderer  
+
+- valgfri sketchnote  
+- valgfri tilleggsvideo  
+- videogjennomgang (noen leksjoner)  
+- [quiz før leksjonen](https://ff-quizzes.netlify.app/en/ml/)  
+- skriftlig leksjon  
+- for prosjektbaserte leksjoner, trinnvise guider for hvordan du bygger prosjektet  
+- kunnskapssjekker  
+- en utfordring  
+- tilleggslesing  
+- oppgave  
+- [quiz etter leksjonen](https://ff-quizzes.netlify.app/en/ml/)  
+
+> **En merknad om språk**: Disse leksjonene er hovedsakelig skrevet i Python, men mange er også tilgjengelige i R. For å fullføre en R-leksjon, gå til `/solution`-mappen og se etter R-leksjoner. De inkluderer en .rmd-utvidelse som representerer en **R Markdown**-fil som enkelt kan defineres som en innbygging av `kodeblokker` (av R eller andre språk) og en `YAML-header` (som styrer hvordan utdata formateres, som PDF) i et `Markdown-dokument`. Som sådan fungerer det som et eksemplarisk forfatterrammeverk for datavitenskap siden det lar deg kombinere koden din, dens utdata og tankene dine ved å skrive dem ned i Markdown. Dessuten kan R Markdown-dokumenter gjengis til utdataformater som PDF, HTML eller Word.  
+
+> **En merknad om quizer**: Alle quizer er inneholdt i [Quiz App-mappen](../../quiz-app), for totalt 52 quizer med tre spørsmål hver. De er lenket fra leksjonene, men quiz-appen kan kjøres lokalt; følg instruksjonene i `quiz-app`-mappen for å være vert lokalt eller distribuere til Azure.  
+
+| Leksjonsnummer |                             Emne                              |                   Leksjonsgruppe                   | Læringsmål                                                                                                                     |                                                              Lenket leksjon                                                               |                        Forfatter                        |
+| :-----------: | :------------------------------------------------------------: | :-------------------------------------------------: | ------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------: |
+|      01       |                Introduksjon til maskinlæring                |      [Introduksjon](1-Introduction/README.md)       | Lær de grunnleggende konseptene bak maskinlæring                                                                                |                                             [Leksjon](1-Introduction/1-intro-to-ML/README.md)                                             |                       Muhammad                       |
+|      02       |                Historien til maskinlæring                 |      [Introduksjon](1-Introduction/README.md)       | Lær historien bak dette feltet                                                                                         |                                            [Leksjon](1-Introduction/2-history-of-ML/README.md)                                            |                     Jen og Amy                      |
+|      03       |                 Rettferdighet og maskinlæring                  |      [Introduksjon](1-Introduction/README.md)       | Hva er de viktige filosofiske spørsmålene rundt rettferdighet som studenter bør vurdere når de bygger og bruker ML-modeller? |                                              [Leksjon](1-Introduction/3-fairness/README.md)                                               |                        Tomomi                        |  
+|      04       |                Teknikker for maskinlæring                     |      [Introduksjon](1-Introduction/README.md)       | Hvilke teknikker bruker ML-forskere for å bygge ML-modeller?                                                                      |                                          [Leksjon](1-Introduction/4-techniques-of-ML/README.md)                                           |                    Chris og Jen                     |
+|      05       |                   Introduksjon til regresjon                  |        [Regresjon](2-Regression/README.md)          | Kom i gang med Python og Scikit-learn for regresjonsmodeller                                                                    |         
+<ul><li>[Python](2-Regression/1-Tools/README.md)</li><li>[R](../../2-Regression/1-Tools/solution/R/lesson_1.html)</li></ul>         |      <ul><li>Jen</li><li>Eric Wanjau</li></ul>       |
+|      06       |                Nordamerikanske gresskarpriser 🎃              |        [Regresjon](2-Regression/README.md)          | Visualiser og rengjør data som forberedelse til ML                                                                              |          <ul><li>[Python](2-Regression/2-Data/README.md)</li><li>[R](../../2-Regression/2-Data/solution/R/lesson_2.html)</li></ul>          |      <ul><li>Jen</li><li>Eric Wanjau</li></ul>       |
+|      07       |                Nordamerikanske gresskarpriser 🎃              |        [Regresjon](2-Regression/README.md)          | Bygg lineære og polynomiske regresjonsmodeller                                                                                  |        <ul><li>[Python](2-Regression/3-Linear/README.md)</li><li>[R](../../2-Regression/3-Linear/solution/R/lesson_3.html)</li></ul>        |      <ul><li>Jen og Dmitry</li><li>Eric Wanjau</li></ul>       |
+|      08       |                Nordamerikanske gresskarpriser 🎃              |        [Regresjon](2-Regression/README.md)          | Bygg en logistisk regresjonsmodell                                                                                              |     <ul><li>[Python](2-Regression/4-Logistic/README.md) </li><li>[R](../../2-Regression/4-Logistic/solution/R/lesson_4.html)</li></ul>      |      <ul><li>Jen</li><li>Eric Wanjau</li></ul>       |
+|      09       |                          En webapp 🔌                         |           [Webapp](3-Web-App/README.md)             | Bygg en webapp for å bruke din trente modell                                                                                    |                                                 [Python](3-Web-App/1-Web-App/README.md)                                                  |                         Jen                          |
+|      10       |                 Introduksjon til klassifisering               |    [Klassifisering](4-Classification/README.md)     | Rengjør, forbered og visualiser dataene dine; introduksjon til klassifisering                                                  | <ul><li> [Python](4-Classification/1-Introduction/README.md) </li><li>[R](../../4-Classification/1-Introduction/solution/R/lesson_10.html)  | <ul><li>Jen og Cassie</li><li>Eric Wanjau</li></ul> |
+|      11       |             Deilige asiatiske og indiske retter 🍜            |    [Klassifisering](4-Classification/README.md)     | Introduksjon til klassifikatorer                                                                                                | <ul><li> [Python](4-Classification/2-Classifiers-1/README.md)</li><li>[R](../../4-Classification/2-Classifiers-1/solution/R/lesson_11.html) | <ul><li>Jen og Cassie</li><li>Eric Wanjau</li></ul> |
+|      12       |             Deilige asiatiske og indiske retter 🍜            |    [Klassifisering](4-Classification/README.md)     | Flere klassifikatorer                                                                                                           | <ul><li> [Python](4-Classification/3-Classifiers-2/README.md)</li><li>[R](../../4-Classification/3-Classifiers-2/solution/R/lesson_12.html) | <ul><li>Jen og Cassie</li><li>Eric Wanjau</li></ul> |
+|      13       |             Deilige asiatiske og indiske retter 🍜            |    [Klassifisering](4-Classification/README.md)     | Bygg en anbefalingswebapp ved hjelp av modellen din                                                                             |                                              [Python](4-Classification/4-Applied/README.md)                                              |                         Jen                          |
+|      14       |                   Introduksjon til klynging                   |        [Klynging](5-Clustering/README.md)           | Rengjør, forbered og visualiser dataene dine; introduksjon til klynging                                                        |         <ul><li> [Python](5-Clustering/1-Visualize/README.md)</li><li>[R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html)         |      <ul><li>Jen</li><li>Eric Wanjau</li></ul>       |
+|      15       |              Utforsking av nigerianske musikksmaker 🎧        |        [Klynging](5-Clustering/README.md)           | Utforsk K-Means klyngemetoden                                                                                                  |           <ul><li> [Python](5-Clustering/2-K-Means/README.md)</li><li>[R](../../5-Clustering/2-K-Means/solution/R/lesson_15.html)           |      <ul><li>Jen</li><li>Eric Wanjau</li></ul>       |
+|      16       |        Introduksjon til naturlig språkbehandling ☕️          |   [Naturlig språkbehandling](6-NLP/README.md)       | Lær det grunnleggende om NLP ved å bygge en enkel bot                                                                          |                                             [Python](6-NLP/1-Introduction-to-NLP/README.md)                                              |                       Stephen                        |
+|      17       |                      Vanlige NLP-oppgaver ☕️                  |   [Naturlig språkbehandling](6-NLP/README.md)       | Fordyp deg i NLP ved å forstå vanlige oppgaver knyttet til språkstrukturer                                                     |                                                    [Python](6-NLP/2-Tasks/README.md)                                                     |                       Stephen                        |
+|      18       |             Oversettelse og sentimentanalyse ♥️               |   [Naturlig språkbehandling](6-NLP/README.md)       | Oversettelse og sentimentanalyse med Jane Austen                                                                               |                                            [Python](6-NLP/3-Translation-Sentiment/README.md)                                             |                       Stephen                        |
+|      19       |                  Romantiske hoteller i Europa ♥️              |   [Naturlig språkbehandling](6-NLP/README.md)       | Sentimentanalyse med hotellanmeldelser 1                                                                                       |                                               [Python](6-NLP/4-Hotel-Reviews-1/README.md)                                                |                       Stephen                        |
+|      20       |                  Romantiske hoteller i Europa ♥️              |   [Naturlig språkbehandling](6-NLP/README.md)       | Sentimentanalyse med hotellanmeldelser 2                                                                                       |                                               [Python](6-NLP/5-Hotel-Reviews-2/README.md)                                                |                       Stephen                        |
+|      21       |            Introduksjon til tidsserieprognoser                |        [Tidsserier](7-TimeSeries/README.md)         | Introduksjon til tidsserieprognoser                                                                                            |                                             [Python](7-TimeSeries/1-Introduction/README.md)                                              |                      Francesca                       |
+|      22       | ⚡️ Verdens strømforbruk ⚡️ - tidsserieprognoser med ARIMA    |        [Tidsserier](7-TimeSeries/README.md)         | Tidsserieprognoser med ARIMA                                                                                                   |                                                 [Python](7-TimeSeries/2-ARIMA/README.md)                                                 |                      Francesca                       |
+|      23       |  ⚡️ Verdens strømforbruk ⚡️ - tidsserieprognoser med SVR     |        [Tidsserier](7-TimeSeries/README.md)         | Tidsserieprognoser med Support Vector Regressor                                                                                |                                                  [Python](7-TimeSeries/3-SVR/README.md)                                                  |                       Anirban                        |
+|      24       |             Introduksjon til forsterkende læring              | [Forsterkende læring](8-Reinforcement/README.md)    | Introduksjon til forsterkende læring med Q-Learning                                                                            |                                             [Python](8-Reinforcement/1-QLearning/README.md)                                              |                        Dmitry                        |
+|      25       |                 Hjelp Peter å unngå ulven! 🐺                 | [Forsterkende læring](8-Reinforcement/README.md)    | Forsterkende læring med Gym                                                                                                    |                                                [Python](8-Reinforcement/2-Gym/README.md)                                                 |                        Dmitry                        |
+|  Postscript   |            Virkelige ML-scenarier og applikasjoner            |      [ML i praksis](9-Real-World/README.md)         | Interessante og avslørende virkelige applikasjoner av klassisk ML                                                              |                                             [Leksjon](9-Real-World/1-Applications/README.md)                                              |                         Team                         |
+|  Postscript   |            Modellfeilsøking i ML med RAI-dashboard            |      [ML i praksis](9-Real-World/README.md)         | Modellfeilsøking i maskinlæring ved bruk av Responsible AI-dashboardkomponenter                                                |                                             [Leksjon](9-Real-World/2-Debugging-ML-Models/README.md)                                       |                         Ruth Yakubu                  |
+
+> [finn alle tilleggsmaterialer for dette kurset i vår Microsoft Learn-samling](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
+
+## Offline tilgang
+
+Du kan kjøre denne dokumentasjonen offline ved å bruke [Docsify](https://docsify.js.org/#/). Fork dette repoet, [installer Docsify](https://docsify.js.org/#/quickstart) på din lokale maskin, og deretter i rotmappen av dette repoet, skriv `docsify serve`. Nettstedet vil bli servert på port 3000 på din localhost: `localhost:3000`.
+
+## PDF-er
+
+Finn en PDF av pensum med lenker [her](https://microsoft.github.io/ML-For-Beginners/pdf/readme.pdf).
+
+## 🎒 Andre kurs 
+
+Teamet vårt produserer andre kurs! Sjekk ut:
+
+- [Generativ AI for nybegynnere](https://aka.ms/genai-beginners)
+- [Generativ AI for nybegynnere .NET](https://github.com/microsoft/Generative-AI-for-beginners-dotnet)
+- [Generativ AI med JavaScript](https://github.com/microsoft/generative-ai-with-javascript)
+- [Generativ AI med Java](https://github.com/microsoft/Generative-AI-for-beginners-java)
+- [AI for nybegynnere](https://aka.ms/ai-beginners)
+- [Data Science for nybegynnere](https://aka.ms/datascience-beginners)
+- [ML for nybegynnere](https://aka.ms/ml-beginners)
+- [Cybersikkerhet for nybegynnere](https://github.com/microsoft/Security-101) 
+- [Webutvikling for nybegynnere](https://aka.ms/webdev-beginners)
+- [IoT for nybegynnere](https://aka.ms/iot-beginners)
+- [XR-utvikling for nybegynnere](https://github.com/microsoft/xr-development-for-beginners)
+- [Mestre GitHub Copilot for parprogrammering](https://github.com/microsoft/Mastering-GitHub-Copilot-for-Paired-Programming)
+- [Mestre GitHub Copilot for C#/.NET-utviklere](https://github.com/microsoft/mastering-github-copilot-for-dotnet-csharp-developers)
+- [Velg ditt eget Copilot-eventyr](https://github.com/microsoft/CopilotAdventures)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/SECURITY.md

@@ -0,0 +1,51 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "5e1b8da31aae9cca3d53ad243fa3365a",
+  "translation_date": "2025-09-05T21:03:45+00:00",
+  "source_file": "SECURITY.md",
+  "language_code": "no"
+}
+-->
+## Sikkerhet
+
+Microsoft tar sikkerheten til våre programvareprodukter og tjenester på alvor, inkludert alle kildekoderepositorier som administreres gjennom våre GitHub-organisasjoner, som inkluderer [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), og [våre GitHub-organisasjoner](https://opensource.microsoft.com/).
+
+Hvis du mener at du har funnet en sikkerhetssårbarhet i et Microsoft-eid repositorium som oppfyller [Microsofts definisjon av en sikkerhetssårbarhet](https://docs.microsoft.com/previous-versions/tn-archive/cc751383(v=technet.10)?WT.mc_id=academic-77952-leestott), vennligst rapporter det til oss som beskrevet nedenfor.
+
+## Rapportering av sikkerhetsproblemer
+
+**Vennligst ikke rapporter sikkerhetssårbarheter gjennom offentlige GitHub-issues.**
+
+Rapporter dem i stedet til Microsoft Security Response Center (MSRC) på [https://msrc.microsoft.com/create-report](https://msrc.microsoft.com/create-report).
+
+Hvis du foretrekker å sende inn uten å logge inn, kan du sende e-post til [secure@microsoft.com](mailto:secure@microsoft.com). Hvis mulig, krypter meldingen din med vår PGP-nøkkel; du kan laste den ned fra [Microsoft Security Response Center PGP Key-siden](https://www.microsoft.com/en-us/msrc/pgp-key-msrc).
+
+Du bør motta et svar innen 24 timer. Hvis du av en eller annen grunn ikke gjør det, vennligst følg opp via e-post for å sikre at vi mottok din opprinnelige melding. Tilleggsinformasjon finner du på [microsoft.com/msrc](https://www.microsoft.com/msrc).
+
+Vennligst inkluder den forespurte informasjonen nedenfor (så mye du kan gi) for å hjelpe oss med å forstå naturen og omfanget av det mulige problemet:
+
+  * Type problem (f.eks. buffer overflow, SQL-injeksjon, cross-site scripting, etc.)
+  * Fullstendige stier til kildefil(er) relatert til manifestasjonen av problemet
+  * Plasseringen av den berørte kildekoden (tag/branch/commit eller direkte URL)
+  * Eventuell spesiell konfigurasjon som kreves for å gjenskape problemet
+  * Trinnvise instruksjoner for å gjenskape problemet
+  * Proof-of-concept eller utnyttelseskode (hvis mulig)
+  * Innvirkning av problemet, inkludert hvordan en angriper kan utnytte det
+
+Denne informasjonen vil hjelpe oss med å prioritere rapporten din raskere.
+
+Hvis du rapporterer for en bug bounty, kan mer komplette rapporter bidra til en høyere belønning. Besøk vår [Microsoft Bug Bounty Program](https://microsoft.com/msrc/bounty)-side for mer informasjon om våre aktive programmer.
+
+## Foretrukne språk
+
+Vi foretrekker all kommunikasjon på engelsk.
+
+## Retningslinjer
+
+Microsoft følger prinsippet om [Koordinert sårbarhetsavsløring](https://www.microsoft.com/en-us/msrc/cvd).
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/SUPPORT.md

@@ -0,0 +1,26 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "872be8bc1b93ef1dd9ac3d6e8f99f6ab",
+  "translation_date": "2025-09-05T21:02:59+00:00",
+  "source_file": "SUPPORT.md",
+  "language_code": "no"
+}
+-->
+# Støtte
+## Hvordan rapportere problemer og få hjelp  
+
+Dette prosjektet bruker GitHub Issues for å spore feil og funksjonsforespørsler. Vennligst søk blant eksisterende 
+problemer før du rapporterer nye for å unngå duplikater. For nye problemer, rapporter feilen eller 
+funksjonsforespørselen som en ny Issue.
+
+For hjelp og spørsmål om bruk av dette prosjektet, opprett en Issue.
+
+## Microsofts støttepolicy  
+
+Støtte for dette arkivet er begrenset til ressursene som er oppført ovenfor.
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/docs/_sidebar.md

@@ -0,0 +1,57 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "68dd06c685f6ce840e0acfa313352e7c",
+  "translation_date": "2025-09-05T21:31:12+00:00",
+  "source_file": "docs/_sidebar.md",
+  "language_code": "no"
+}
+-->
+- Introduksjon
+  - [Introduksjon til maskinlæring](../1-Introduction/1-intro-to-ML/README.md)
+  - [Historien om maskinlæring](../1-Introduction/2-history-of-ML/README.md)
+  - [Maskinlæring og rettferdighet](../1-Introduction/3-fairness/README.md)
+  - [Teknikker innen maskinlæring](../1-Introduction/4-techniques-of-ML/README.md)
+
+- Regresjon
+  - [Verktøyene i faget](../2-Regression/1-Tools/README.md)
+  - [Data](../2-Regression/2-Data/README.md)
+  - [Lineær regresjon](../2-Regression/3-Linear/README.md)
+  - [Logistisk regresjon](../2-Regression/4-Logistic/README.md)
+
+- Bygg en webapp
+  - [Webapp](../3-Web-App/1-Web-App/README.md)
+
+- Klassifisering
+  - [Introduksjon til klassifisering](../4-Classification/1-Introduction/README.md)
+  - [Klassifikatorer 1](../4-Classification/2-Classifiers-1/README.md)
+  - [Klassifikatorer 2](../4-Classification/3-Classifiers-2/README.md)
+  - [Anvendt maskinlæring](../4-Classification/4-Applied/README.md)
+
+- Klynging
+  - [Visualiser dataene dine](../5-Clustering/1-Visualize/README.md)
+  - [K-Means](../5-Clustering/2-K-Means/README.md)
+
+- NLP
+  - [Introduksjon til NLP](../6-NLP/1-Introduction-to-NLP/README.md)
+  - [NLP-oppgaver](../6-NLP/2-Tasks/README.md)
+  - [Oversettelse og sentimentanalyse](../6-NLP/3-Translation-Sentiment/README.md)
+  - [Hotellanmeldelser 1](../6-NLP/4-Hotel-Reviews-1/README.md)
+  - [Hotellanmeldelser 2](../6-NLP/5-Hotel-Reviews-2/README.md)
+
+- Tidsserieprognoser
+  - [Introduksjon til tidsserieprognoser](../7-TimeSeries/1-Introduction/README.md)
+  - [ARIMA](../7-TimeSeries/2-ARIMA/README.md)
+  - [SVR](../7-TimeSeries/3-SVR/README.md)
+
+- Forsterkende læring
+  - [Q-Læring](../8-Reinforcement/1-QLearning/README.md)
+  - [Gym](../8-Reinforcement/2-Gym/README.md)
+
+- Maskinlæring i den virkelige verden
+  - [Applikasjoner](../9-Real-World/1-Applications/README.md)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/for-teachers.md

@@ -0,0 +1,37 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "b37de02054fa6c0438ede6fabe1fdfb8",
+  "translation_date": "2025-09-05T21:04:15+00:00",
+  "source_file": "for-teachers.md",
+  "language_code": "no"
+}
+-->
+## For lærere
+
+Ønsker du å bruke dette pensumet i klasserommet ditt? Vær så god!
+
+Faktisk kan du bruke det direkte på GitHub ved å bruke GitHub Classroom.
+
+For å gjøre det, må du forkere dette repoet. Du må opprette et repo for hver leksjon, så du må trekke ut hver mappe til et eget repo. På den måten kan [GitHub Classroom](https://classroom.github.com/classrooms) hente hver leksjon separat.
+
+Disse [fullstendige instruksjonene](https://github.blog/2020-03-18-set-up-your-digital-classroom-with-github-classroom/) gir deg en idé om hvordan du kan sette opp klasserommet ditt.
+
+## Bruke repoet som det er
+
+Hvis du ønsker å bruke dette repoet slik det står nå, uten å bruke GitHub Classroom, kan det også gjøres. Du må kommunisere med studentene dine om hvilken leksjon dere skal jobbe med sammen.
+
+I et online format (Zoom, Teams eller andre) kan du opprette grupperom for quizene og veilede studentene for å hjelpe dem med å forberede seg på læring. Deretter kan du invitere studentene til quizene og be dem sende inn svarene som 'issues' på et bestemt tidspunkt. Du kan gjøre det samme med oppgaver, hvis du ønsker at studentene skal jobbe sammen i det åpne.
+
+Hvis du foretrekker et mer privat format, kan du be studentene dine om å forkere pensumet, leksjon for leksjon, til sine egne private GitHub-repoer og gi deg tilgang. Deretter kan de fullføre quizene og oppgavene privat og sende dem til deg via issues på ditt klasseromsrepo.
+
+Det finnes mange måter å få dette til å fungere i et online klasseromsformat. Gi oss gjerne beskjed om hva som fungerer best for deg!
+
+## Gi oss dine tanker!
+
+Vi ønsker å gjøre dette pensumet nyttig for deg og dine studenter. Gi oss gjerne [tilbakemelding](https://forms.microsoft.com/Pages/ResponsePage.aspx?id=v4j5cvGGr0GRqy180BHbR2humCsRZhxNuI79cm6n0hRUQzRVVU9VVlU5UlFLWTRLWlkyQUxORTg5WS4u).
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/quiz-app/README.md

@@ -0,0 +1,126 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "6d130dffca5db70d7e615f926cb1ad4c",
+  "translation_date": "2025-09-05T21:48:45+00:00",
+  "source_file": "quiz-app/README.md",
+  "language_code": "no"
+}
+-->
+# Quizer
+
+Disse quizene er forhånds- og etterforelesningsquizene for ML-læreplanen på https://aka.ms/ml-beginners
+
+## Prosjektoppsett
+
+```
+npm install
+```
+
+### Kompilerer og oppdaterer automatisk for utvikling
+
+```
+npm run serve
+```
+
+### Kompilerer og minimerer for produksjon
+
+```
+npm run build
+```
+
+### Linter og fikser filer
+
+```
+npm run lint
+```
+
+### Tilpass konfigurasjon
+
+Se [Konfigurasjonsreferanse](https://cli.vuejs.org/config/).
+
+Kreditering: Takk til den originale versjonen av denne quiz-appen: https://github.com/arpan45/simple-quiz-vue
+
+## Distribuere til Azure
+
+Her er en steg-for-steg guide for å komme i gang:
+
+1. Fork en GitHub-repositorium  
+Sørg for at koden til din statiske webapp er i ditt GitHub-repositorium. Fork dette repositoriet.
+
+2. Opprett en Azure Static Web App  
+- Opprett en [Azure-konto](http://azure.microsoft.com)  
+- Gå til [Azure-portalen](https://portal.azure.com)  
+- Klikk på "Opprett en ressurs" og søk etter "Static Web App".  
+- Klikk "Opprett".  
+
+3. Konfigurer den statiske webappen  
+- Grunnleggende: Abonnement: Velg ditt Azure-abonnement.  
+- Ressursgruppe: Opprett en ny ressursgruppe eller bruk en eksisterende.  
+- Navn: Gi et navn til din statiske webapp.  
+- Region: Velg regionen nærmest brukerne dine.  
+
+- #### Distribusjonsdetaljer:  
+- Kilde: Velg "GitHub".  
+- GitHub-konto: Autoriser Azure til å få tilgang til din GitHub-konto.  
+- Organisasjon: Velg din GitHub-organisasjon.  
+- Repositorium: Velg repositoriet som inneholder din statiske webapp.  
+- Gren: Velg grenen du vil distribuere fra.  
+
+- #### Byggdetaljer:  
+- Byggforhåndsinnstillinger: Velg rammeverket appen din er bygget med (f.eks. React, Angular, Vue, osv.).  
+- App-plassering: Angi mappen som inneholder koden til appen din (f.eks. / hvis den er i roten).  
+- API-plassering: Hvis du har en API, spesifiser dens plassering (valgfritt).  
+- Utdata-plassering: Angi mappen der byggeutdataene genereres (f.eks. build eller dist).  
+
+4. Gjennomgå og opprett  
+Gjennomgå innstillingene dine og klikk "Opprett". Azure vil sette opp nødvendige ressurser og opprette en GitHub Actions-arbeidsflyt i ditt repositorium.  
+
+5. GitHub Actions-arbeidsflyt  
+Azure vil automatisk opprette en GitHub Actions-arbeidsflytfil i ditt repositorium (.github/workflows/azure-static-web-apps-<name>.yml). Denne arbeidsflyten vil håndtere bygge- og distribusjonsprosessen.  
+
+6. Overvåk distribusjonen  
+Gå til "Actions"-fanen i ditt GitHub-repositorium.  
+Du bør se en arbeidsflyt som kjører. Denne arbeidsflyten vil bygge og distribuere din statiske webapp til Azure.  
+Når arbeidsflyten er fullført, vil appen din være live på den oppgitte Azure-URL-en.  
+
+### Eksempel på arbeidsflytfil
+
+Her er et eksempel på hvordan GitHub Actions-arbeidsflytfilen kan se ut:  
+name: Azure Static Web Apps CI/CD  
+```
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    types: [opened, synchronize, reopened, closed]
+    branches:
+      - main
+
+jobs:
+  build_and_deploy_job:
+    runs-on: ubuntu-latest
+    name: Build and Deploy Job
+    steps:
+      - uses: actions/checkout@v2
+      - name: Build And Deploy
+        id: builddeploy
+        uses: Azure/static-web-apps-deploy@v1
+        with:
+          azure_static_web_apps_api_token: ${{ secrets.AZURE_STATIC_WEB_APPS_API_TOKEN }}
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          action: "upload"
+          app_location: "/quiz-app" # App source code path
+          api_location: ""API source code path optional
+          output_location: "dist" #Built app content directory - optional
+```
+
+### Tilleggsressurser  
+- [Azure Static Web Apps Dokumentasjon](https://learn.microsoft.com/azure/static-web-apps/getting-started)  
+- [GitHub Actions Dokumentasjon](https://docs.github.com/actions/use-cases-and-examples/deploying/deploying-to-azure-static-web-app)  
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/sketchnotes/LICENSE.md

@@ -0,0 +1,368 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "fba3b94d88bfb9b81369b869a1e9a20f",
+  "translation_date": "2025-09-05T22:00:15+00:00",
+  "source_file": "sketchnotes/LICENSE.md",
+  "language_code": "no"
+}
+-->
+Attribution-ShareAlike 4.0 Internasjonal
+
+=======================================================================
+
+Creative Commons Corporation ("Creative Commons") er ikke et advokatfirma og gir ikke juridiske tjenester eller juridisk rådgivning. Distribusjon av Creative Commons offentlige lisenser skaper ikke et advokat-klient-forhold eller andre relasjoner. Creative Commons gjør sine lisenser og tilhørende informasjon tilgjengelig "som den er". Creative Commons gir ingen garantier angående sine lisenser, noe materiale lisensiert under deres vilkår og betingelser, eller tilhørende informasjon. Creative Commons fraskriver seg alt ansvar for skader som følge av deres bruk i den grad det er mulig.
+
+Bruk av Creative Commons offentlige lisenser
+
+Creative Commons offentlige lisenser gir et standard sett med vilkår og betingelser som skapere og andre rettighetshavere kan bruke for å dele originale verk og annet materiale som er underlagt opphavsrett og visse andre rettigheter spesifisert i den offentlige lisensen nedenfor. Følgende betraktninger er kun for informasjonsformål, er ikke uttømmende, og utgjør ikke en del av våre lisenser.
+
+     Betraktninger for lisensgivere: Våre offentlige lisenser er
+     ment for bruk av de som er autorisert til å gi offentligheten
+     tillatelse til å bruke materiale på måter som ellers er
+     begrenset av opphavsrett og visse andre rettigheter. Våre
+     lisenser er uoppsigelige. Lisensgivere bør lese og forstå
+     vilkårene og betingelsene for lisensen de velger før de
+     anvender den. Lisensgivere bør også sikre alle nødvendige
+     rettigheter før de anvender våre lisenser slik at offentligheten
+     kan gjenbruke materialet som forventet. Lisensgivere bør tydelig
+     merke materiale som ikke er underlagt lisensen. Dette inkluderer
+     annet CC-lisensiert materiale, eller materiale brukt under et
+     unntak eller begrensning til opphavsrett. Flere betraktninger
+     for lisensgivere:
+	wiki.creativecommons.org/Considerations_for_licensors
+
+     Betraktninger for offentligheten: Ved å bruke en av våre
+     offentlige lisenser, gir en lisensgiver offentligheten tillatelse
+     til å bruke det lisensierte materialet under spesifiserte vilkår
+     og betingelser. Hvis lisensgiverens tillatelse ikke er nødvendig
+     av en eller annen grunn – for eksempel på grunn av et gjeldende
+     unntak eller begrensning til opphavsrett – reguleres ikke den
+     bruken av lisensen. Våre lisenser gir kun tillatelser under
+     opphavsrett og visse andre rettigheter som en lisensgiver har
+     myndighet til å gi. Bruk av det lisensierte materialet kan
+     fortsatt være begrenset av andre grunner, inkludert fordi andre
+     har opphavsrett eller andre rettigheter i materialet. En
+     lisensgiver kan komme med spesielle forespørsler, som å be om at
+     alle endringer merkes eller beskrives. Selv om det ikke er
+     påkrevd av våre lisenser, oppfordres du til å respektere slike
+     forespørsler der det er rimelig. Flere betraktninger for
+     offentligheten:
+	wiki.creativecommons.org/Considerations_for_licensees
+
+=======================================================================
+
+Creative Commons Attribution-ShareAlike 4.0 Internasjonal Offentlig Lisens
+
+Ved å utøve de lisensierte rettighetene (definert nedenfor), aksepterer og samtykker du til å være bundet av vilkårene og betingelsene i denne Creative Commons Attribution-ShareAlike 4.0 Internasjonal Offentlig Lisens ("Offentlig Lisens"). I den grad denne Offentlige Lisensen kan tolkes som en kontrakt, gis du de lisensierte rettighetene som en motytelse for din aksept av disse vilkårene og betingelsene, og lisensgiveren gir deg slike rettigheter som en motytelse for fordeler lisensgiveren mottar ved å gjøre det lisensierte materialet tilgjengelig under disse vilkårene og betingelsene.
+
+Seksjon 1 – Definisjoner.
+
+  a. Bearbeidet materiale betyr materiale underlagt opphavsrett og
+     lignende rettigheter som er avledet fra eller basert på det
+     lisensierte materialet og der det lisensierte materialet er
+     oversatt, endret, arrangert, transformert eller på annen måte
+     modifisert på en måte som krever tillatelse under opphavsrett og
+     lignende rettigheter holdt av lisensgiveren. For formålene med
+     denne Offentlige Lisensen, der det lisensierte materialet er et
+     musikalsk verk, fremføring eller lydopptak, produseres alltid
+     bearbeidet materiale der det lisensierte materialet synkroniseres
+     i tidsrelasjon med et bevegelig bilde.
+
+  b. Adapterens lisens betyr lisensen du anvender på dine opphavsrett
+     og lignende rettigheter i dine bidrag til bearbeidet materiale i
+     samsvar med vilkårene og betingelsene i denne Offentlige Lisensen.
+
+  c. BY-SA kompatibel lisens betyr en lisens oppført på
+     creativecommons.org/compatiblelicenses, godkjent av Creative
+     Commons som i hovedsak tilsvarende denne Offentlige Lisensen.
+
+  d. Opphavsrett og lignende rettigheter betyr opphavsrett og/eller
+     lignende rettigheter nært knyttet til opphavsrett, inkludert, men
+     ikke begrenset til, fremføring, kringkasting, lydopptak og sui
+     generis database rettigheter, uten hensyn til hvordan rettighetene
+     er merket eller kategorisert. For formålene med denne Offentlige
+     Lisensen, er rettighetene spesifisert i Seksjon 2(b)(1)-(2) ikke
+     opphavsrett og lignende rettigheter.
+
+  e. Effektive teknologiske tiltak betyr de tiltakene som, i fravær av
+     riktig myndighet, ikke kan omgås under lover som oppfyller
+     forpliktelser under artikkel 11 i WIPO Copyright Treaty vedtatt
+     20. desember 1996, og/eller lignende internasjonale avtaler.
+
+  f. Unntak og begrensninger betyr rimelig bruk, rimelig behandling,
+     og/eller andre unntak eller begrensninger til opphavsrett og
+     lignende rettigheter som gjelder for din bruk av det lisensierte
+     materialet.
+
+  g. Lisenselementer betyr lisensattributtene oppført i navnet på en
+     Creative Commons Offentlig Lisens. Lisenselementene i denne
+     Offentlige Lisensen er Attribution og ShareAlike.
+
+  h. Lisensiert materiale betyr det kunstneriske eller litterære verket,
+     databasen eller annet materiale som lisensgiveren har anvendt
+     denne Offentlige Lisensen på.
+
+  i. Lisensierte rettigheter betyr rettighetene som gis til deg under
+     vilkårene og betingelsene i denne Offentlige Lisensen, som er
+     begrenset til alle opphavsrett og lignende rettigheter som gjelder
+     for din bruk av det lisensierte materialet og som lisensgiveren
+     har myndighet til å lisensiere.
+
+  j. Lisensgiver betyr den eller de individene eller enhetene som gir
+     rettigheter under denne Offentlige Lisensen.
+
+  k. Dele betyr å gi materiale til offentligheten på en hvilken som
+     helst måte eller prosess som krever tillatelse under de lisensierte
+     rettighetene, slik som reproduksjon, offentlig visning, offentlig
+     fremføring, distribusjon, spredning, kommunikasjon eller
+     importering, og å gjøre materialet tilgjengelig for offentligheten
+     inkludert på måter som medlemmer av offentligheten kan få tilgang
+     til materialet fra et sted og på et tidspunkt individuelt valgt av
+     dem.
+
+  l. Sui generis database rettigheter betyr rettigheter andre enn
+     opphavsrett som følger av direktiv 96/9/EC fra Europaparlamentet
+     og Rådet av 11. mars 1996 om juridisk beskyttelse av databaser,
+     som endret og/eller etterfulgt, samt andre i hovedsak tilsvarende
+     rettigheter hvor som helst i verden.
+
+  m. Du betyr den eller de individene eller enhetene som utøver de
+     lisensierte rettighetene under denne Offentlige Lisensen. Din har
+     en tilsvarende betydning.
+
+Seksjon 2 – Omfang.
+
+  a. Lisensgivning.
+
+       1. Underlagt vilkårene og betingelsene i denne Offentlige
+          Lisensen, gir lisensgiveren deg herved en verdensomspennende,
+          royaltyfri, ikke-underlisensierbar, ikke-eksklusiv,
+          uoppsigelig lisens til å utøve de lisensierte rettighetene i
+          det lisensierte materialet til:
+
+            a. reprodusere og dele det lisensierte materialet, helt
+               eller delvis; og
+
+            b. produsere, reprodusere og dele bearbeidet materiale.
+
+       2. Unntak og begrensninger. For å unngå tvil, der unntak og
+          begrensninger gjelder for din bruk, gjelder ikke denne
+          Offentlige Lisensen, og du trenger ikke å overholde dens
+          vilkår og betingelser.
+
+       3. Varighet. Varigheten av denne Offentlige Lisensen er
+          spesifisert i Seksjon 6(a).
+
+       4. Medier og formater; tekniske modifikasjoner tillatt.
+          Lisensgiveren autoriserer deg til å utøve de lisensierte
+          rettighetene i alle medier og formater, enten kjent nå eller
+          opprettet senere, og til å gjøre tekniske modifikasjoner som
+          er nødvendige for å gjøre det. Lisensgiveren fraskriver seg
+          og/eller samtykker i å ikke hevde noen rett eller myndighet
+          til å forby deg fra å gjøre tekniske modifikasjoner som er
+          nødvendige for å utøve de lisensierte rettighetene, inkludert
+          tekniske modifikasjoner som er nødvendige for å omgå
+          effektive teknologiske tiltak. For formålene med denne
+          Offentlige Lisensen, produserer det å gjøre modifikasjoner
+          autorisert av denne Seksjon 2(a)(4) aldri bearbeidet
+          materiale.
+
+       5. Mottakere nedstrøms.
+
+            a. Tilbud fra lisensgiveren – Lisensiert materiale. Hver
+               mottaker av det lisensierte materialet mottar
+               automatisk et tilbud fra lisensgiveren om å utøve de
+               lisensierte rettighetene under vilkårene og betingelsene
+               i denne Offentlige Lisensen.
+
+            b. Ekstra tilbud fra lisensgiveren – Bearbeidet materiale.
+               Hver mottaker av bearbeidet materiale fra deg mottar
+               automatisk et tilbud fra lisensgiveren om å utøve de
+               lisensierte rettighetene i det bearbeidede materialet
+               under betingelsene i adapterens lisens du anvender.
+
+            c. Ingen restriksjoner nedstrøms. Du kan ikke tilby eller
+               pålegge noen ekstra eller forskjellige vilkår eller
+               betingelser på, eller anvende noen effektive
+               teknologiske tiltak på, det lisensierte materialet hvis
+               det begrenser utøvelsen av de lisensierte rettighetene
+               av noen mottaker av det lisensierte materialet.
+
+       6. Ingen godkjenning. Ingenting i denne Offentlige Lisensen
+          utgjør eller kan tolkes som tillatelse til å hevde eller
+          antyde at du er, eller at din bruk av det lisensierte
+          materialet er, tilknyttet, sponset, godkjent eller gitt
+          offisiell status av lisensgiveren eller andre utpekt til å
+          motta attribusjon som angitt i Seksjon 3(a)(1)(A)(i).
+
+  b. Andre rettigheter.
+
+       1. Ideelle rettigheter, som retten til integritet, er ikke
+          lisensiert under denne Offentlige Lisensen, heller ikke
+          publisitet, personvern og/eller andre lignende
+          personlighetsrettigheter; imidlertid, i den grad det er
+          mulig, fraskriver lisensgiveren seg og/eller samtykker i å
+          ikke hevde slike rettigheter holdt av lisensgiveren i den
+          begrensede grad som er nødvendig for å tillate deg å utøve
+          de lisensierte rettighetene, men ikke utover det.
+
+       2. Patent- og varemerkerettigheter er ikke lisensiert under
+          denne Offentlige Lisensen.
+
+       3. I den grad det er mulig, fraskriver lisensgiveren seg enhver
+          rett til å samle inn royalties fra deg for utøvelsen av de
+          lisensierte rettighetene, enten direkte eller gjennom en
+          innsamlerorganisasjon under en frivillig eller fraskrivbar
+          lovbestemt eller obligatorisk lisensordning. I alle andre
+          tilfeller forbeholder lisensgiveren seg uttrykkelig enhver
+          rett til å samle inn slike royalties.
+
+Seksjon 3 – Lisensbetingelser.
+
+Din utøvelse av de lisensierte rettighetene er uttrykkelig underlagt
+følgende betingelser.
+
+  a. Attribusjon.
+
+       1. Hvis du deler det lisensierte materialet (inkludert i
+          modifisert form), må du:
+
+            a. beholde følgende hvis det er levert av lisensgiveren
+               med det lisensierte materialet:
+
+                 i. identifikasjon av skaperen(e) av det lisensierte
+                    materialet og andre utpekt til å motta
+                    attribusjon, på en rimelig måte forespurt av
+                    lisensgiveren (inkludert ved pseudonym hvis
+                    utpekt);
+
+                ii. en opphavsrettsmerknad;
+
+               iii. en merknad som refererer til denne Offentlige
+                    Lisensen;
+
+                iv. en merknad som refererer til ansvarsfraskrivelsen
+                    for garantier;
+
+                 v. en URI eller hyperlink til det lisensierte
+                    materialet i den grad det er rimelig praktisk;
+
+            b. indikere hvis du har modifisert det lisensierte
+               materialet og beholde en indikasjon på eventuelle
+               tidligere modifikasjoner; og
+
+            c. indikere at det lisensierte materialet er lisensiert
+               under denne Offentlige Lisensen, og inkludere teksten
+               til, eller URI eller hyperlink til, denne Offentlige
+               Lisensen.
+
+       2. Du kan oppfylle betingelsene i Seksjon 3(a)(1) på en hvilken
+          som helst rimelig måte basert på mediet, midlene og
+          konteksten der du deler det lisensierte materialet. For
+          eksempel kan det være rimelig å oppfylle betingelsene ved å
+          gi en URI eller hyperlink til en ressurs som inkluderer den
+          nødvendige informasjonen.
+
+       3. Hvis lisensgiveren ber om det, må du fjerne noe av
+          informasjonen som kreves av Seksjon 3(a)(1)(A) i den grad det
+          er rimelig praktisk.
+
+  b. ShareAlike.
+
+     I tillegg til betingelsene i Seksjon 3(a), hvis du deler bearbeidet
+     materiale du produserer, gjelder følgende betingelser også.
+
+       1. Adapterens lisens du anvender må være en Creative Commons
+          lisens med de samme lisenselementene, denne versjonen eller
+          senere, eller en BY-SA kompatibel lisens.
+
+       2. Du må inkludere teksten til, eller URI eller hyperlink til,
+          adapterens lisens du anvender. Du kan oppfylle denne
+          betingelsen på en hvilken som helst rimelig måte basert på
+          mediet, midlene og konteksten der du deler bearbeidet
+          materiale.
+
+       3. Du kan ikke tilby eller pålegge noen ekstra eller forskjellige
+          vilkår eller betingelser på, eller anvende noen effektive
+          teknologiske tiltak på, bearbeidet materiale som begrenser
+          utøvelsen av rettighetene gitt under adapterens lisens du
+          anvender.
+
+Seksjon 4 – Sui generis database rettigheter.
+
+Der de lisensierte rettighetene inkluderer sui generis database
+rettigheter som gjelder for din bruk av det lisensierte materialet:
+
+  a. for å unngå tvil, gir Seksjon 2(a)(1) deg retten til å trekke ut,
+     gjenbruke, reprodusere og dele hele eller en vesentlig del av
+     innholdet i databasen;
+
+  b. hvis du inkluderer hele eller en vesentlig del av databaseinnholdet
+     i en database der du har sui generis database...
+Rettigheter, der databasen som du har Sui Generis Database Rights i (men ikke dens individuelle innhold) er tilpasset materiale,
+
+inkludert for formålene i seksjon 3(b); og  
+c. Du må overholde betingelsene i seksjon 3(a) hvis du deler hele eller en vesentlig del av innholdet i databasen.
+
+For å unngå tvil, supplerer denne seksjonen 4 og erstatter ikke dine forpliktelser under denne offentlige lisensen der lisensierte rettigheter inkluderer andre opphavsrettigheter og lignende rettigheter.
+
+---
+
+Seksjon 5 -- Ansvarsfraskrivelse og begrensning av ansvar.
+
+a. MED MINDRE ANNET ER SEPARAT AVTALT AV LISENSGIVEREN, I DEN GRAD DET ER MULIG, TILBYR LISENSGIVEREN DET LISENSIERTE MATERIALET SOM DET ER OG SOM TILGJENGELIG, OG GIR INGEN REPRESENTASJONER ELLER GARANTIER AV NOE SLAG ANGÅENDE DET LISENSIERTE MATERIALET, ENTEN UTTRYKT, IMPLISERT, LOVBESTEMT ELLER ANNET. DETTE INKLUDERER, UTEN BEGRENSNING, GARANTIER FOR EIENDOMSRETT, SALGBARHET, EGNETHET FOR ET SPESIFIKT FORMÅL, IKKE-KRENKELSE, FRAVÆR AV SKJULTE ELLER ANDRE DEFEKTER, NØYAKTIGHET, ELLER TILSTEDEVÆRELSE ELLER FRAVÆR AV FEIL, ENTEN KJENT ELLER OPPDAGBAR. DER ANSVARSFRASKRIVELSER AV GARANTIER IKKE ER TILLATT FULLSTENDIG ELLER DELVIS, KAN DENNE ANSVARSFRASKRIVELSEN IKKE GJELDE FOR DEG.
+
+b. I DEN GRAD DET ER MULIG, VIL LISENSGIVEREN UNDER INGEN OMSTENDIGHETER VÆRE ANSVARLIG OVERFOR DEG UNDER NOEN JURIDISK TEORI (INKLUDERT, UTEN BEGRENSNING, UAKTSOMHET) ELLER ANNET FOR NOEN DIREKTE, SPESIELLE, INDIREKTE, TILFELDIGE, FØLGESKADER, STRAFFENDE, EKSEMPLARISKE ELLER ANDRE TAP, KOSTNADER, UTGIFTER ELLER SKADER SOM OPPSTÅR FRA DENNE OFFENTLIGE LISENSEN ELLER BRUKEN AV DET LISENSIERTE MATERIALET, SELV OM LISENSGIVEREN HAR BLITT INFORMERT OM MULIGHETEN FOR SLIKE TAP, KOSTNADER, UTGIFTER ELLER SKADER. DER BEGRENSNING AV ANSVAR IKKE ER TILLATT FULLSTENDIG ELLER DELVIS, KAN DENNE BEGRENSNINGEN IKKE GJELDE FOR DEG.
+
+c. Ansvarsfraskrivelsen og begrensningen av ansvar som er gitt ovenfor skal tolkes på en måte som, i den grad det er mulig, mest mulig ligner en absolutt ansvarsfraskrivelse og fraskrivelse av alt ansvar.
+
+---
+
+Seksjon 6 -- Varighet og opphør.
+
+a. Denne offentlige lisensen gjelder for varigheten av opphavsretten og lignende rettigheter som er lisensiert her. Imidlertid, hvis du ikke overholder denne offentlige lisensen, opphører dine rettigheter under denne offentlige lisensen automatisk.
+
+b. Der din rett til å bruke det lisensierte materialet har opphørt under seksjon 6(a), gjenopprettes den:
+
+1. automatisk fra datoen bruddet er rettet, forutsatt at det rettes innen 30 dager etter at du oppdaget bruddet; eller  
+2. ved uttrykkelig gjenoppretting av lisensgiveren.
+
+For å unngå tvil, påvirker ikke denne seksjonen 6(b) noen rett lisensgiveren kan ha til å søke rettsmidler for dine brudd på denne offentlige lisensen.
+
+c. For å unngå tvil, kan lisensgiveren også tilby det lisensierte materialet under separate vilkår eller betingelser eller slutte å distribuere det lisensierte materialet når som helst; imidlertid vil dette ikke avslutte denne offentlige lisensen.
+
+d. Seksjonene 1, 5, 6, 7 og 8 overlever opphør av denne offentlige lisensen.
+
+---
+
+Seksjon 7 -- Andre vilkår og betingelser.
+
+a. Lisensgiveren skal ikke være bundet av noen tilleggsvilkår eller betingelser kommunisert av deg med mindre det er uttrykkelig avtalt.
+
+b. Eventuelle ordninger, forståelser eller avtaler angående det lisensierte materialet som ikke er angitt her, er separate fra og uavhengige av vilkårene og betingelsene i denne offentlige lisensen.
+
+---
+
+Seksjon 8 -- Tolkning.
+
+a. For å unngå tvil, reduserer, begrenser, begrenser eller pålegger ikke denne offentlige lisensen noen betingelser for bruk av det lisensierte materialet som lovlig kan gjøres uten tillatelse under denne offentlige lisensen.
+
+b. I den grad det er mulig, hvis noen bestemmelse i denne offentlige lisensen anses som ikke håndhevbar, skal den automatisk reformeres til det minimum som er nødvendig for å gjøre den håndhevbar. Hvis bestemmelsen ikke kan reformeres, skal den skilles fra denne offentlige lisensen uten å påvirke håndhevelsen av de gjenværende vilkårene og betingelsene.
+
+c. Ingen vilkår eller betingelser i denne offentlige lisensen vil bli frafalt, og ingen unnlatelse av å overholde vil bli samtykket til med mindre det uttrykkelig er avtalt av lisensgiveren.
+
+d. Ingenting i denne offentlige lisensen utgjør eller kan tolkes som en begrensning på, eller fraskrivelse av, noen privilegier og immuniteter som gjelder for lisensgiveren eller deg, inkludert fra de juridiske prosessene til enhver jurisdiksjon eller myndighet.
+
+---
+
+=======================================================================
+
+Creative Commons er ikke en part i sine offentlige lisenser. Uavhengig av dette kan Creative Commons velge å anvende en av sine offentlige lisenser på materiale det publiserer, og i de tilfellene vil det bli ansett som "lisensgiveren." Teksten til Creative Commons offentlige lisenser er dedikert til allmennheten under CC0 Public Domain Dedication. Bortsett fra det begrensede formålet med å indikere at materiale deles under en Creative Commons offentlig lisens eller som ellers tillatt av Creative Commons' retningslinjer publisert på creativecommons.org/policies, autoriserer ikke Creative Commons bruken av varemerket "Creative Commons" eller noe annet varemerke eller logo tilhørende Creative Commons uten forhåndsskriftlig samtykke, inkludert, uten begrensning, i forbindelse med uautoriserte modifikasjoner av noen av sine offentlige lisenser eller andre ordninger, forståelser eller avtaler angående bruk av lisensiert materiale. For å unngå tvil, utgjør ikke dette avsnittet en del av de offentlige lisensene.
+
+Creative Commons kan kontaktes på creativecommons.org.
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi tilstreber nøyaktighet, vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/no/sketchnotes/README.md

@@ -0,0 +1,21 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "a88d5918c1b9da69a40d917a0840c497",
+  "translation_date": "2025-09-05T21:56:51+00:00",
+  "source_file": "sketchnotes/README.md",
+  "language_code": "no"
+}
+-->
+Alle sketchnotes for pensum kan lastes ned her.
+
+🖨 For utskrift i høy oppløsning er TIFF-versjonene tilgjengelige på [dette repoet](https://github.com/girliemac/a-picture-is-worth-a-1000-words/tree/main/ml/tiff).
+
+🎨 Laget av: [Tomomi Imura](https://github.com/girliemac) (Twitter: [@girlie_mac](https://twitter.com/girlie_mac))
+
+[![CC BY-SA 4.0](https://img.shields.io/badge/License-CC%20BY--SA%204.0-lightgrey.svg)](https://creativecommons.org/licenses/by-sa/4.0/)
+
+---
+
+**Ansvarsfraskrivelse**:  
+Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten [Co-op Translator](https://github.com/Azure/co-op-translator). Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

translations/sv/1-Introduction/1-intro-to-ML/README.md

@@ -0,0 +1,159 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "69389392fa6346e0dfa30f664b7b6fec",
+  "translation_date": "2025-09-05T21:42:42+00:00",
+  "source_file": "1-Introduction/1-intro-to-ML/README.md",
+  "language_code": "sv"
+}
+-->
+# Introduktion till maskininlärning
+
+## [Quiz före föreläsning](https://ff-quizzes.netlify.app/en/ml/)
+
+---
+
+[![ML för nybörjare - Introduktion till maskininlärning för nybörjare](https://img.youtube.com/vi/6mSx_KJxcHI/0.jpg)](https://youtu.be/6mSx_KJxcHI "ML för nybörjare - Introduktion till maskininlärning för nybörjare")
+
+> 🎥 Klicka på bilden ovan för en kort video som går igenom denna lektion.
+
+Välkommen till denna kurs om klassisk maskininlärning för nybörjare! Oavsett om du är helt ny inom detta ämne eller en erfaren ML-praktiker som vill fräscha upp dina kunskaper, är vi glada att ha dig med! Vi vill skapa en vänlig startpunkt för dina studier i maskininlärning och välkomnar gärna din [feedback](https://github.com/microsoft/ML-For-Beginners/discussions).
+
+[![Introduktion till ML](https://img.youtube.com/vi/h0e2HAPTGF4/0.jpg)](https://youtu.be/h0e2HAPTGF4 "Introduktion till ML")
+
+> 🎥 Klicka på bilden ovan för en video: MIT:s John Guttag introducerar maskininlärning
+
+---
+## Komma igång med maskininlärning
+
+Innan du börjar med detta kursmaterial behöver du ha din dator konfigurerad och redo att köra notebooks lokalt.
+
+- **Konfigurera din dator med dessa videor**. Använd följande länkar för att lära dig [hur du installerar Python](https://youtu.be/CXZYvNRIAKM) på ditt system och [ställer in en textredigerare](https://youtu.be/EU8eayHWoZg) för utveckling.
+- **Lär dig Python**. Det rekommenderas också att ha en grundläggande förståelse för [Python](https://docs.microsoft.com/learn/paths/python-language/?WT.mc_id=academic-77952-leestott), ett programmeringsspråk som är användbart för dataforskare och som vi använder i denna kurs.
+- **Lär dig Node.js och JavaScript**. Vi använder också JavaScript några gånger i denna kurs när vi bygger webbappar, så du behöver ha [node](https://nodejs.org) och [npm](https://www.npmjs.com/) installerade, samt [Visual Studio Code](https://code.visualstudio.com/) tillgängligt för både Python- och JavaScript-utveckling.
+- **Skapa ett GitHub-konto**. Eftersom du hittade oss här på [GitHub](https://github.com), har du kanske redan ett konto, men om inte, skapa ett och fork:a sedan detta kursmaterial för att använda det själv. (Ge oss gärna en stjärna också 😊)
+- **Utforska Scikit-learn**. Bekanta dig med [Scikit-learn](https://scikit-learn.org/stable/user_guide.html), en uppsättning ML-bibliotek som vi refererar till i dessa lektioner.
+
+---
+## Vad är maskininlärning?
+
+Begreppet 'maskininlärning' är ett av de mest populära och frekvent använda termerna idag. Det är inte osannolikt att du har hört detta begrepp åtminstone en gång om du har någon form av bekantskap med teknik, oavsett vilket område du arbetar inom. Mekaniken bakom maskininlärning är dock ett mysterium för de flesta. För en nybörjare inom maskininlärning kan ämnet ibland kännas överväldigande. Därför är det viktigt att förstå vad maskininlärning faktiskt är och att lära sig om det steg för steg, genom praktiska exempel.
+
+---
+## Hypekurvan
+
+![ml hype curve](../../../../1-Introduction/1-intro-to-ML/images/hype.png)
+
+> Google Trends visar den senaste 'hypekurvan' för termen 'maskininlärning'
+
+---
+## Ett mystiskt universum
+
+Vi lever i ett universum fullt av fascinerande mysterier. Stora vetenskapsmän som Stephen Hawking, Albert Einstein och många fler har ägnat sina liv åt att söka meningsfull information som avslöjar mysterierna i världen omkring oss. Detta är människans lärandevillkor: ett barn lär sig nya saker och upptäcker strukturen i sin värld år för år när det växer upp.
+
+---
+## Barnets hjärna
+
+Ett barns hjärna och sinnen uppfattar fakta från sin omgivning och lär sig gradvis de dolda mönstren i livet, vilket hjälper barnet att skapa logiska regler för att identifiera inlärda mönster. Den mänskliga hjärnans inlärningsprocess gör människor till världens mest sofistikerade levande varelse. Att kontinuerligt lära sig genom att upptäcka dolda mönster och sedan innovera på dessa mönster gör att vi kan bli bättre och bättre under hela vår livstid. Denna inlärningsförmåga och utvecklingskapacitet är relaterad till ett koncept som kallas [hjärnplasticitet](https://www.simplypsychology.org/brain-plasticity.html). Ytligt sett kan vi dra vissa motiverande likheter mellan den mänskliga hjärnans inlärningsprocess och koncepten inom maskininlärning.
+
+---
+## Den mänskliga hjärnan
+
+Den [mänskliga hjärnan](https://www.livescience.com/29365-human-brain.html) uppfattar saker från den verkliga världen, bearbetar den uppfattade informationen, fattar rationella beslut och utför vissa handlingar baserat på omständigheterna. Detta är vad vi kallar att bete sig intelligent. När vi programmerar en kopia av den intelligenta beteendeprocessen till en maskin kallas det artificiell intelligens (AI).
+
+---
+## Några termer
+
+Även om termerna kan förväxlas är maskininlärning (ML) en viktig delmängd av artificiell intelligens. **ML handlar om att använda specialiserade algoritmer för att upptäcka meningsfull information och hitta dolda mönster från uppfattad data för att stödja den rationella beslutsprocessen**.
+
+---
+## AI, ML, djupinlärning
+
+![AI, ML, deep learning, data science](../../../../1-Introduction/1-intro-to-ML/images/ai-ml-ds.png)
+
+> En diagram som visar relationerna mellan AI, ML, djupinlärning och data science. Infografik av [Jen Looper](https://twitter.com/jenlooper) inspirerad av [denna grafik](https://softwareengineering.stackexchange.com/questions/366996/distinction-between-ai-ml-neural-networks-deep-learning-and-data-mining)
+
+---
+## Koncept att täcka
+
+I detta kursmaterial kommer vi att täcka endast kärnkoncepten inom maskininlärning som en nybörjare måste känna till. Vi täcker det vi kallar 'klassisk maskininlärning' främst med hjälp av Scikit-learn, ett utmärkt bibliotek som många studenter använder för att lära sig grunderna. För att förstå bredare koncept inom artificiell intelligens eller djupinlärning är en stark grundläggande kunskap om maskininlärning oumbärlig, och därför vill vi erbjuda det här.
+
+---
+## I denna kurs kommer du att lära dig:
+
+- kärnkoncept inom maskininlärning
+- maskininlärningens historia
+- ML och rättvisa
+- regressionstekniker inom ML
+- klassificeringstekniker inom ML
+- klustringstekniker inom ML
+- tekniker för naturlig språkbehandling inom ML
+- tekniker för tidsserieprognoser inom ML
+- förstärkningsinlärning
+- verkliga tillämpningar av ML
+
+---
+## Vad vi inte kommer att täcka
+
+- djupinlärning
+- neurala nätverk
+- AI
+
+För att skapa en bättre inlärningsupplevelse kommer vi att undvika komplexiteten i neurala nätverk, 'djupinlärning' - flerskiktad modellbyggnad med neurala nätverk - och AI, som vi kommer att diskutera i ett annat kursmaterial. Vi kommer också att erbjuda ett kommande kursmaterial om data science för att fokusera på den aspekten av detta större område.
+
+---
+## Varför studera maskininlärning?
+
+Maskininlärning, ur ett systemperspektiv, definieras som skapandet av automatiserade system som kan lära sig dolda mönster från data för att hjälpa till att fatta intelligenta beslut.
+
+Denna motivation är löst inspirerad av hur den mänskliga hjärnan lär sig vissa saker baserat på data den uppfattar från omvärlden.
+
+✅ Fundera en stund på varför ett företag skulle vilja använda strategier för maskininlärning istället för att skapa en hårdkodad regelbaserad motor.
+
+---
+## Tillämpningar av maskininlärning
+
+Tillämpningar av maskininlärning finns nu nästan överallt och är lika allestädes närvarande som den data som flödar runt i våra samhällen, genererad av våra smartphones, uppkopplade enheter och andra system. Med tanke på den enorma potentialen hos moderna maskininlärningsalgoritmer har forskare utforskat deras förmåga att lösa multidimensionella och tvärvetenskapliga verkliga problem med stora positiva resultat.
+
+---
+## Exempel på tillämpad ML
+
+**Du kan använda maskininlärning på många sätt**:
+
+- För att förutsäga sannolikheten för sjukdom utifrån en patients medicinska historia eller rapporter.
+- För att använda väderdata för att förutsäga väderhändelser.
+- För att förstå känslan i en text.
+- För att upptäcka falska nyheter och stoppa spridningen av propaganda.
+
+Finans, ekonomi, geovetenskap, rymdforskning, biomedicinsk teknik, kognitiv vetenskap och till och med humaniora har anpassat maskininlärning för att lösa de arbetskrävande, databehandlingsintensiva problemen inom sina områden.
+
+---
+## Slutsats
+
+Maskininlärning automatiserar processen att upptäcka mönster genom att hitta meningsfulla insikter från verklig eller genererad data. Det har visat sig vara mycket värdefullt inom affärs-, hälso- och finansiella tillämpningar, bland andra.
+
+I en nära framtid kommer förståelsen av grunderna i maskininlärning att bli ett måste för människor inom alla områden på grund av dess utbredda användning.
+
+---
+# 🚀 Utmaning
+
+Skissa, på papper eller med hjälp av en onlineapp som [Excalidraw](https://excalidraw.com/), din förståelse av skillnaderna mellan AI, ML, djupinlärning och data science. Lägg till några idéer om problem som var och en av dessa tekniker är bra på att lösa.
+
+# [Quiz efter föreläsning](https://ff-quizzes.netlify.app/en/ml/)
+
+---
+# Granskning & Självstudier
+
+För att lära dig mer om hur du kan arbeta med ML-algoritmer i molnet, följ denna [Lärväg](https://docs.microsoft.com/learn/paths/create-no-code-predictive-models-azure-machine-learning/?WT.mc_id=academic-77952-leestott).
+
+Ta en [Lärväg](https://docs.microsoft.com/learn/modules/introduction-to-machine-learning/?WT.mc_id=academic-77952-leestott) om grunderna i ML.
+
+---
+# Uppgift
+
+[Kom igång](assignment.md)
+
+---
+
+**Ansvarsfriskrivning**:  
+Detta dokument har översatts med hjälp av AI-översättningstjänsten [Co-op Translator](https://github.com/Azure/co-op-translator). Även om vi strävar efter noggrannhet, vänligen notera att automatiska översättningar kan innehålla fel eller felaktigheter. Det ursprungliga dokumentet på sitt ursprungliga språk bör betraktas som den auktoritativa källan. För kritisk information rekommenderas professionell mänsklig översättning. Vi ansvarar inte för eventuella missförstånd eller feltolkningar som uppstår vid användning av denna översättning.

translations/sv/1-Introduction/1-intro-to-ML/assignment.md

@@ -0,0 +1,23 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "4c4698044bb8af52cfb6388a4ee0e53b",
+  "translation_date": "2025-09-05T21:43:40+00:00",
+  "source_file": "1-Introduction/1-intro-to-ML/assignment.md",
+  "language_code": "sv"
+}
+-->
+# Kom igång
+
+## Instruktioner
+
+I denna uppgift utan betyg ska du fräscha upp dina kunskaper i Python och få din miljö igång så att du kan köra notebooks.
+
+Ta denna [Python Learning Path](https://docs.microsoft.com/learn/paths/python-language/?WT.mc_id=academic-77952-leestott), och sätt sedan upp dina system genom att gå igenom dessa introduktionsvideor:
+
+https://www.youtube.com/playlist?list=PLlrxD0HtieHhS8VzuMCfQD4uJ9yne1mE6
+
+---
+
+**Ansvarsfriskrivning**:  
+Detta dokument har översatts med hjälp av AI-översättningstjänsten [Co-op Translator](https://github.com/Azure/co-op-translator). Även om vi strävar efter noggrannhet, bör du vara medveten om att automatiserade översättningar kan innehålla fel eller brister. Det ursprungliga dokumentet på dess originalspråk bör betraktas som den auktoritativa källan. För kritisk information rekommenderas professionell mänsklig översättning. Vi ansvarar inte för eventuella missförstånd eller feltolkningar som uppstår vid användning av denna översättning.

translations/sv/1-Introduction/2-history-of-ML/README.md

@@ -0,0 +1,164 @@
+<!--
+CO_OP_TRANSLATOR_METADATA:
+{
+  "original_hash": "6a05fec147e734c3e6bfa54505648e2b",
+  "translation_date": "2025-09-05T21:44:44+00:00",
+  "source_file": "1-Introduction/2-history-of-ML/README.md",
+  "language_code": "sv"
+}
+-->
+# Historien om maskininlärning
+
+![Sammanfattning av historien om maskininlärning i en sketchnote](../../../../sketchnotes/ml-history.png)
+> Sketchnote av [Tomomi Imura](https://www.twitter.com/girlie_mac)
+
+## [Quiz före föreläsningen](https://ff-quizzes.netlify.app/en/ml/)
+
+---
+
+[![ML för nybörjare - Historien om maskininlärning](https://img.youtube.com/vi/N6wxM4wZ7V0/0.jpg)](https://youtu.be/N6wxM4wZ7V0 "ML för nybörjare - Historien om maskininlärning")
+
+> 🎥 Klicka på bilden ovan för en kort video som går igenom denna lektion.
+
+I denna lektion kommer vi att gå igenom de viktigaste milstolparna i historien om maskininlärning och artificiell intelligens.
+
+Historien om artificiell intelligens (AI) som forskningsområde är nära sammanflätad med historien om maskininlärning, eftersom de algoritmer och tekniska framsteg som ligger till grund för ML bidrog till utvecklingen av AI. Det är bra att komma ihåg att även om dessa områden som separata forskningsfält började ta form på 1950-talet, föregicks och överlappades denna era av viktiga [algoritmiska, statistiska, matematiska, beräkningsmässiga och tekniska upptäckter](https://wikipedia.org/wiki/Timeline_of_machine_learning). Faktum är att människor har funderat på dessa frågor i [hundratals år](https://wikipedia.org/wiki/History_of_artificial_intelligence): denna artikel diskuterar de historiska intellektuella grunderna för idén om en "tänkande maskin."
+
+---
+## Viktiga upptäckter
+
+- 1763, 1812 [Bayes sats](https://wikipedia.org/wiki/Bayes%27_theorem) och dess föregångare. Denna sats och dess tillämpningar ligger till grund för inferens och beskriver sannolikheten för att en händelse inträffar baserat på tidigare kunskap.
+- 1805 [Minsta kvadratmetoden](https://wikipedia.org/wiki/Least_squares) av den franske matematikern Adrien-Marie Legendre. Denna teori, som du kommer att lära dig om i vår Regression-enhet, hjälper till med dataanpassning.
+- 1913 [Markovkedjor](https://wikipedia.org/wiki/Markov_chain), uppkallad efter den ryske matematikern Andrey Markov, används för att beskriva en sekvens av möjliga händelser baserat på ett tidigare tillstånd.
+- 1957 [Perceptron](https://wikipedia.org/wiki/Perceptron) är en typ av linjär klassificerare uppfunnen av den amerikanske psykologen Frank Rosenblatt som ligger till grund för framsteg inom djupinlärning.
+
+---
+
+- 1967 [Närmaste granne](https://wikipedia.org/wiki/Nearest_neighbor) är en algoritm som ursprungligen designades för att kartlägga rutter. Inom ML används den för att upptäcka mönster.
+- 1970 [Backpropagation](https://wikipedia.org/wiki/Backpropagation) används för att träna [feedforward-nätverk](https://wikipedia.org/wiki/Feedforward_neural_network).
+- 1982 [Recurrent Neural Networks](https://wikipedia.org/wiki/Recurrent_neural_network) är artificiella neurala nätverk som härstammar från feedforward-nätverk och skapar temporala grafer.
+
+✅ Gör lite research. Vilka andra datum sticker ut som avgörande i historien om ML och AI?
+
+---
+## 1950: Maskiner som tänker
+
+Alan Turing, en verkligen enastående person som [av allmänheten 2019](https://wikipedia.org/wiki/Icons:_The_Greatest_Person_of_the_20th_Century) röstades fram som 1900-talets största vetenskapsman, anses ha hjälpt till att lägga grunden för konceptet "en maskin som kan tänka." Han brottades med skeptiker och sitt eget behov av empiriska bevis för detta koncept, bland annat genom att skapa [Turingtestet](https://www.bbc.com/news/technology-18475646), som du kommer att utforska i våra NLP-lektioner.
+
+---
+## 1956: Dartmouth Summer Research Project
+
+"Dartmouth Summer Research Project on artificial intelligence var en avgörande händelse för artificiell intelligens som forskningsområde," och det var här termen "artificiell intelligens" myntades ([källa](https://250.dartmouth.edu/highlights/artificial-intelligence-ai-coined-dartmouth)).
+
+> Varje aspekt av lärande eller någon annan egenskap hos intelligens kan i princip beskrivas så exakt att en maskin kan göras för att simulera den.
+
+---
+
+Huvudforskaren, matematikprofessorn John McCarthy, hoppades "att gå vidare på grundval av hypotesen att varje aspekt av lärande eller någon annan egenskap hos intelligens i princip kan beskrivas så exakt att en maskin kan göras för att simulera den." Deltagarna inkluderade en annan framstående person inom området, Marvin Minsky.
+
+Workshoppen anses ha initierat och uppmuntrat flera diskussioner, inklusive "framväxten av symboliska metoder, system fokuserade på begränsade domäner (tidiga expertsystem) och deduktiva system kontra induktiva system." ([källa](https://wikipedia.org/wiki/Dartmouth_workshop)).
+
+---
+## 1956 - 1974: "De gyllene åren"
+
+Från 1950-talet till mitten av 70-talet var optimismen hög kring hoppet att AI kunde lösa många problem. 1967 uttalade Marvin Minsky självsäkert att "Inom en generation ... kommer problemet med att skapa 'artificiell intelligens' i stort sett att vara löst." (Minsky, Marvin (1967), Computation: Finite and Infinite Machines, Englewood Cliffs, N.J.: Prentice-Hall)
+
+Forskning inom naturlig språkbehandling blomstrade, sökning förfinades och blev mer kraftfull, och konceptet "mikrovärldar" skapades, där enkla uppgifter utfördes med hjälp av instruktioner på vanligt språk.
+
+---
+
+Forskningen finansierades väl av statliga organ, framsteg gjordes inom beräkning och algoritmer, och prototyper av intelligenta maskiner byggdes. Några av dessa maskiner inkluderar:
+
+* [Shakey the robot](https://wikipedia.org/wiki/Shakey_the_robot), som kunde manövrera och besluta hur uppgifter skulle utföras "intelligent".
+
+    ![Shakey, en intelligent robot](../../../../1-Introduction/2-history-of-ML/images/shakey.jpg)
+    > Shakey år 1972
+
+---
+
+* Eliza, en tidig "chatterbot", kunde samtala med människor och fungera som en primitiv "terapeut". Du kommer att lära dig mer om Eliza i NLP-lektionerna.
+
+    ![Eliza, en bot](../../../../1-Introduction/2-history-of-ML/images/eliza.png)
+    > En version av Eliza, en chatbot
+
+---
+
+* "Blocks world" var ett exempel på en mikrovärld där block kunde staplas och sorteras, och experiment i att lära maskiner att fatta beslut kunde testas. Framsteg byggda med bibliotek som [SHRDLU](https://wikipedia.org/wiki/SHRDLU) hjälpte till att driva språkbehandling framåt.
+
+    [![blocks world med SHRDLU](https://img.youtube.com/vi/QAJz4YKUwqw/0.jpg)](https://www.youtube.com/watch?v=QAJz4YKUwqw "blocks world med SHRDLU")
+
+    > 🎥 Klicka på bilden ovan för en video: Blocks world med SHRDLU
+
+---
+## 1974 - 1980: "AI-vintern"
+
+I mitten av 1970-talet blev det uppenbart att komplexiteten i att skapa "intelligenta maskiner" hade underskattats och att dess löften, givet den tillgängliga beräkningskraften, hade överdrivits. Finansieringen torkade upp och förtroendet för området minskade. Några problem som påverkade förtroendet inkluderade:
+---
+- **Begränsningar**. Beräkningskraften var för begränsad.
+- **Kombinatorisk explosion**. Antalet parametrar som behövde tränas växte exponentiellt när mer krävdes av datorer, utan en parallell utveckling av beräkningskraft och kapacitet.
+- **Brist på data**. Det fanns en brist på data som hindrade processen att testa, utveckla och förfina algoritmer.
+- **Ställer vi rätt frågor?**. Själva frågorna som ställdes började ifrågasättas. Forskare började möta kritik kring sina tillvägagångssätt:
+  - Turingtestet ifrågasattes bland annat genom teorin om "den kinesiska rummet", som hävdade att "programmering av en digital dator kan få den att verka förstå språk men kan inte producera verklig förståelse." ([källa](https://plato.stanford.edu/entries/chinese-room/))
+  - Etiken kring att introducera artificiella intelligenser som "terapeuten" ELIZA i samhället utmanades.
+
+---
+
+Samtidigt började olika AI-skolor bildas. En dikotomi etablerades mellan ["scruffy" vs. "neat AI"](https://wikipedia.org/wiki/Neats_and_scruffies) metoder. _Scruffy_-labb justerade program i timmar tills de fick önskade resultat. _Neat_-labb "fokuserade på logik och formell problemlösning". ELIZA och SHRDLU var välkända _scruffy_-system. På 1980-talet, när efterfrågan på att göra ML-system reproducerbara ökade, tog _neat_-metoden gradvis ledningen eftersom dess resultat är mer förklarbara.
+
+---
+## 1980-talets expertsystem
+
+När området växte blev dess nytta för företag tydligare, och på 1980-talet ökade också spridningen av "expertsystem". "Expertsystem var bland de första verkligt framgångsrika formerna av artificiell intelligens (AI)-programvara." ([källa](https://wikipedia.org/wiki/Expert_system)).
+
+Denna typ av system är faktiskt _hybrid_, bestående delvis av en regelmotor som definierar affärskrav och en inferensmotor som utnyttjar regelsystemet för att härleda nya fakta.
+
+Denna era såg också ökat fokus på neurala nätverk.
+
+---
+## 1987 - 1993: AI "kyla"
+
+Spridningen av specialiserad hårdvara för expertsystem hade den olyckliga effekten att bli för specialiserad. Framväxten av persondatorer konkurrerade också med dessa stora, specialiserade, centraliserade system. Demokratiseringen av databehandling hade börjat, och den banade så småningom väg för den moderna explosionen av big data.
+
+---
+## 1993 - 2011
+
+Denna epok såg en ny era för ML och AI att kunna lösa några av de problem som tidigare orsakats av bristen på data och beräkningskraft. Mängden data började snabbt öka och bli mer tillgänglig, på gott och ont, särskilt med framväxten av smarttelefonen runt 2007. Beräkningskraften expanderade exponentiellt, och algoritmer utvecklades parallellt. Fältet började mogna när de fria dagarna från det förflutna började kristalliseras till en verklig disciplin.
+
+---
+## Nu
+
+Idag berör maskininlärning och AI nästan alla delar av våra liv. Denna era kräver noggrann förståelse för riskerna och de potentiella effekterna av dessa algoritmer på människors liv. Som Microsofts Brad Smith har sagt, "Informationsteknologi väcker frågor som går till kärnan av grundläggande mänskliga rättigheter som integritet och yttrandefrihet. Dessa frågor ökar ansvaret för teknikföretag som skapar dessa produkter. Enligt vår uppfattning kräver de också genomtänkt statlig reglering och utveckling av normer kring acceptabla användningar" ([källa](https://www.technologyreview.com/2019/12/18/102365/the-future-of-ais-impact-on-society/)).
+
+---
+
+Det återstår att se vad framtiden har att erbjuda, men det är viktigt att förstå dessa datorsystem och den programvara och de algoritmer de kör. Vi hoppas att denna kursplan hjälper dig att få en bättre förståelse så att du kan bestämma själv.
+
+[![Historien om djupinlärning](https://img.youtube.com/vi/mTtDfKgLm54/0.jpg)](https://www.youtube.com/watch?v=mTtDfKgLm54 "Historien om djupinlärning")
+> 🎥 Klicka på bilden ovan för en video: Yann LeCun diskuterar historien om djupinlärning i denna föreläsning
+
+---
+## 🚀Utmaning
+
+Gräv djupare i ett av dessa historiska ögonblick och lär dig mer om personerna bakom dem. Det finns fascinerande karaktärer, och ingen vetenskaplig upptäckt har någonsin skapats i ett kulturellt vakuum. Vad upptäcker du?
+
+## [Quiz efter föreläsningen](https://ff-quizzes.netlify.app/en/ml/)
+
+---
+## Granskning & Självstudier
+
+Här är saker att titta på och lyssna på:
+
+[Denna podcast där Amy Boyd diskuterar AI:s utveckling](http://runasradio.com/Shows/Show/739)
+
+[![Historien om AI av Amy Boyd](https://img.youtube.com/vi/EJt3_bFYKss/0.jpg)](https://www.youtube.com/watch?v=EJt3_bFYKss "Historien om AI av Amy Boyd")
+
+---
+
+## Uppgift
+
+[Skapa en tidslinje](assignment.md)
+
+---
+
+**Ansvarsfriskrivning**:  
+Detta dokument har översatts med hjälp av AI-översättningstjänsten [Co-op Translator](https://github.com/Azure/co-op-translator). Även om vi strävar efter noggrannhet, bör det noteras att automatiska översättningar kan innehålla fel eller felaktigheter. Det ursprungliga dokumentet på dess originalspråk bör betraktas som den auktoritativa källan. För kritisk information rekommenderas professionell mänsklig översättning. Vi ansvarar inte för eventuella missförstånd eller feltolkningar som uppstår vid användning av denna översättning.