Een basale Perceptron neuraal netwerk trainen met Python: Stap-voor-stap gids

Een basale Perceptron neuraal netwerk trainen met Python

Deze gids leidt u door een volledig gecommentarieerde Python-implementatie die automatisch de gewichten leert voor een eenlaags perceptron. De code is klaar om te kopiëren, plakken, uit te voeren, en aan te passen aan uw eigen data.

De AAC Perceptron Reeks verkennen

Voor diepere context of om in geavanceerde onderwerpen te springen, bekijk de rest van onze artikelen:

1. Hoe classificatie uit te voeren met een neuraal netwerk: Wat is de Perceptron?
2. Hoe een simpele Perceptron-neuraal netwerk voorbeeld te gebruiken om data te classificeren
3. Hoe een basale Perceptron-neuraal netwerk te trainen
4. Eenvoudige neuraal netwerk training begrijpen
5. Inleiding tot trainings theorie voor neurale netwerken
6. Leer snelheid in neurale netwerken begrijpen
7. Geavanceerde machine learning met de Multilayer Perceptron
8. De Sigmoid-activeringsfunctie: Activering in Multilayer Perceptron neurale netwerken
9. Hoe een Multilayer Perceptron neuraal netwerk te trainen
10. Trainingsformules en Backpropagation voor Multilayer Perceptrons begrijpen
11. Neuraal netwerk architectuur voor een Python-implementatie
12. Hoe een Multilayer Perceptron neuraal netwerk in Python te maken
13. Signaalverwerking met neurale netwerken: Validatie in neuraal netwerk ontwerp
14. Trainingsdatasets voor neurale netwerken: Hoe een Python neuraal netwerk te trainen en valideren

Classificatie met een eenlaags Perceptron

We beginnen met een klassiek binaire classificatieprobleem in 3-D ruimte. De netwerkarchitectuur is een enkele verborgen laag met drie invoerknooppunten en één uitvoerknooppunt dat een unit-step activeringsfunctie gebruikt.

Het uitvoerknooppunt past de volgende unit-step functie toe:

\[f(x)=\begin{cases}0 & x < 0\\1 & x \ge 0\end{cases}\]

Om leren te illustreren, breiden we de architectuur uit om de gewichten automatisch aan te passen via een eenvoudige trainingslus:

Een Python-implementatie

Het volgende script leest trainingsdata uit een Excel-bestand, initialiseert gewichten willekeurig, en werkt ze iteratief bij met de perceptron-leerregel.

 import pandas
import numpy as np
# Dimensionaliteit van invoerruimte (x, y, z)
input_dim = 3
# Leersnelheid controleert gewichtsanpassingsgrootte
learning_rate = 0.01
# Willekeurige initiële gewichten; u kunt vaste waarden instellen voor reproduceerbaarheid
Weights = np.random.rand(input_dim)
# Weights = np.array([0.5, 0.5, 0.5])
# Dataset laden: een blad met kolommen voor elk kenmerk en een 'output' kolom
Training_Data = pandas.read_excel("3D_data.xlsx")
# Verwachte uitvoeren scheiden van de kenmerkmatrix
Expected_Output = Training_Data.output
Training_Data = Training_Data.drop(["output"], axis=1)
# Converteren naar NumPy array voor vectorisatie
Training_Data = np.asarray(Training_Data)
training_count = len(Training_Data[:, 0])
# Trainen over meerdere epochs
for epoch in range(5):
    for datum in range(training_count):
        # Gewogen som van invoeren
        Output_Sum = np.sum(np.multiply(Training_Data[datum, :], Weights))
        # Unit-step activering toepassen
        Output_Value = 0 if Output_Sum < 0 else 1
        # Fout berekenen tussen verwachte en werkelijke uitvoer
        error = Expected_Output[datum] - Output_Value
        # Elk gewicht bijwerken volgens de leerregel
        for n in range(input_dim):
            Weights[n] += learning_rate * error * Training_Data[datum, n]
print(f"w_0 = {Weights[0]:.3f}")
print(f"w_1 = {Weights[1]:.3f}")
print(f"w_2 = {Weights[2]:.3f}")

Kernconcepten uitgelegd

Het netwerk configureren en data organiseren

Het netwerk heeft drie invoerknooppunten om de 3-D coördinaten te matchen. De leersnelheid van 0.01 is een standaard startpunt; u kunt deze na experimenteren aanpassen. Gewichten worden willekeurig geseed om symmetrie te vermijden, maar u kunt ze op een vaste waarde zetten als u deterministisch gedrag wilt.

Trainingsdata wordt uit een Excel-bestand gelezen, gesplitst in invoeren en verwachte uitvoeren, en vervolgens geconverteerd naar een NumPy-array voor efficiënte berekening.

Uitvoerwaarden berekenen

Elke epoch itereert over alle trainingsmonsters. Voor elk monster wordt de gewogen som van de invoeren berekend. De unit-step functie mappt deze som dan naar een binaire uitvoer: 0 als de som negatief is, 1 anders.

Gewichten bijwerken

Wanneer de voorspelde uitvoer afwijkt van de verwachte uitvoer, past de perceptron-leerregel elk gewicht evenredig aan aan de invoerwaarde, de fout, en de leersnelheid:

\[w_{new} = w + (\alpha \times \delta \times input)\]

waar \(\delta = \text{output}_{expected} - \text{output}_{calculated}\) en \(\alpha\) de leersnelheid is.

Conclusie

U heeft nu een complete, geannoteerde implementatie van een eenlaags perceptron in Python gezien. De code is een stevige basis voor experimenten met verschillende datasets, leersnelheden, of zelfs het uitbreiden van het netwerk naar meerdere uitgangen in toekomstige projecten.