Summary  
This chapter explains how to implement a single-neuron model by initializing its weights and bias, computing the weighted sum via a dot product and bias addition, and applying activation functions like sigmoid or ReLU.  

General domain of usage  
Spam detection

En **nevron** er den grunnleggende beregningsenheten i et nevralt nettverk. Den behandler **flere innganger** og genererer en **enkel utgang**, noe som gjør det mulig for nettverket å lære og gjøre prediksjoner.

Definisjon

I dette eksemplet bygger vi et nevralt nettverk med **én nevron** for en **binær klassifiseringsoppgave** (f.eks. spamdeteksjon).
Nevronen mottar **numeriske egenskaper** og gir en verdi mellom **0 og 1**, som representerer **sannsynligheten** for at en e-post er spam (**1**) eller ham (**0**).

Trinnvis:

1. Multipliser hver input med sin **vekt**;
2. Summer alle vektede input;
3. Legg til en **bias** for å forskyve utdataen;
4. Send resultatet gjennom en **sigmoid**-aktivering, som konverterer det til området ((0,1)) for sannsynlighetsutdata.

**Bias** til nevronet er også en trenbar parameter.

Merk

## Nevronklasse

En nevron må lagre sine **vekter** og **bias**, noe som gjør en klasse til en naturlig måte å gruppere disse relaterte egenskapene på.

Selv om denne klassen ikke vil være en del av den endelige implementasjonen av nevrale nettverk, illustrerer den effektivt viktige prinsipper.

```python
class Neuron:
    def __init__(self, n_inputs):
        self.weights = ...
        self.bias = ...
```

* `weights`: tilfeldig initierte verdier (én per input);
* `bias`: én tilfeldig verdi.
  Begge trekkes fra en **uniform fordeling** i ([-1, 1]) ved bruk av `np.random.uniform()` for å bryte symmetri.

## Fremoverpropagering

Neuronets `activate()`-metode beregner **vektet sum** og anvender **sigmoid**.
Den vektede summen bruker **prikkproduktet** av vektene og inputene:

```python
input_sum_with_bias = np.dot(self.weights, inputs) + self.bias
```

Deretter anvendes aktiveringsfunksjonen for å få neuronets endelige output.

Bruk av `np.dot()` unngår løkker og beregner hele den vektede summen på én linje.
Sigmoid-funksjonen omformer deretter denne råverdien til en sannsynlighet:

```python
def activate(self, inputs):
    input_sum_with_bias = ...
    output = ...
    return output
```

## Sigmoid-aktivering

Gitt råutgang (z), er sigmoid:

$$
\sigma(z) = \frac{1}{1 + e^{-z}}
$$

Den kartlegger ethvert tall til ((0,1)), noe som gjør den ideell for **binær klassifisering**, der nevronets utgang må representere en sannsynlighet.

Ved å bruke denne formelen kan sigmoid implementeres som en enkel funksjon i Python:

```python
def sigmoid(z):
    return 1 / (1 + np.exp(-z))
```

Formelen for **ReLU**-funksjonen er som følger, som i hovedsak setter utgangen lik $$z$$ hvis den er positiv og **0** ellers:
$$
ReLU(z) = max(0, z)
$$

```python
def relu(z):
    return np.maximum(0, z)
```

Hva er rollen til bias-termen i et enkelt nevron?

Hvorfor initialiserer vi vekter med små tilfeldige verdier i stedet for null?

Nevrale nettverk er kraftige algoritmer inspirert av strukturen til den menneskelige hjernen, og brukes til å løse komplekse maskinlæringsproblemer. Du vil bygge ditt eget nevrale nettverk fra bunnen av for å forstå hvordan det fungerer. Etter dette kurset vil du kunne lage nevrale nettverk for å løse klassifikasjons- og regresjonsproblemer ved hjelp av scikit-learn-biblioteket.

Først skal vi diskutere hva et nevralt nettverk er og hvordan det fungerer. Vi vil også vurdere anvendelsesområdet.

Deretter skal vi forsøke å bygge vårt eget nevrale nettverk og se hvor effektivt det håndterer læring. Vi vil også vurdere en ferdig løsning fra scikit-learn-biblioteket.

Til slutt vil vi gi deg tilleggsinformasjon om hvordan du kan forstå hvilken modell som bør brukes og hvilke typer nevrale nettverk som finnes. For å fullføre kurset vil du bli testet på den tilegnede kunnskapen din.

Implementering av Enkeltnevron

Nevronklasse

Fremoverpropagering

Sigmoid-aktivering

1. Hva er rollen til bias-termen i et enkelt nevron?

2. Hvorfor initialiserer vi vekter med små tilfeldige verdier i stedet for null?