Neuronale Netze in Go: Eine vollständige Anleitung zum Aufbau von Grund auf

Dieser Artikel zeigt, wie man mit der Programmiersprache Go ein einfaches neuronales Netzwerk von Grund auf aufbaut und seinen Arbeitsablauf anhand der Iris-Klassifizierungsaufgabe demonstriert. Er kombiniert Prinzipienerklärungen, Code-Implementierungen und visuelle Strukturdarstellungen, um den Lesern das Verständnis der Kernmechanismen neuronaler Netze zu erleichtern.

Aufbau eines neuronalen Netzes von Grund auf mit Go: Prinzipien, Struktur und Implementierung

Ⅰ. Grundlegende Prinzipien und Struktur neuronaler Netze

Ein neuronales Netzwerk ist ein Berechnungsmodell, das biologische Neuronen simuliert und durch Verbindungen von Knoten über mehrere Schichten hinweg eine nichtlineare Abbildung erreicht. Eine typische dreischichtige neuronale Netzwerkstruktur umfasst eine Eingabeschicht, eine verborgene Schicht und eine Ausgabeschicht. Die Knoten in jeder Schicht sind über Gewichte und Voreingenommenheiten verbunden, und die Übertragung zwischen den Schichten erfolgt über Aktivierungsfunktionen. Nachfolgend finden Sie ein schematisches Diagramm einer einfachen dreischichtigen neuronalen Netzwerkstruktur (gezeichnet mit ASCII-Zeichen):

+-----------+     +-----------+     +-----------+
| Input Layer |     | Hidden Layer |     | Output Layer |
|   4 Nodes   |     |     3 Nodes     |     |     3 Nodes     |
+-----------+     +-----------+     +-----------+
    ↑              ↑              ↑
    │    Weights    │    Weights    │    Weights    │
    ├───────────────┼───────────────┼───────────────┤
    ↓              ↓              ↓
+-----------+  +-----------+  +-----------+
|   Bias    |  |   Bias    |  |   Bias    |
+-----------+  +-----------+  +-----------+
    ↓              ↓              ↓
+-----------+  +-----------+  +-----------+
| Activation|  | Activation|  | Activation|
|  Function  |  |  Function  |  |  Function  |
+-----------+  +-----------+  +-----------+

Kernkonzepte:

Vorwärtsausbreitung Eingabedaten werden einer linearen Transformation durch Gewichtsmatrizen (input × weights + bias) unterzogen und führen dann über Aktivierungsfunktionen eine Nichtlinearität ein, die sich Schicht für Schicht zur Ausgabeschicht ausbreitet. Formelbeispiele:
- Eingabe der verborgenen Schicht: ( Z_1 = X \cdot W_1 + b_1 )
- Ausgabe der verborgenen Schicht: ( A_1 = \sigma(Z_1) ) ((\sigma) ist die Sigmoid-Funktion)
- Eingabe der Ausgabeschicht: ( Z_2 = A_1 \cdot W_2 + b_2 )
- Ausgabe der Ausgabeschicht: ( A_2 = \sigma(Z_2) )
Rückausbreitung Durch die Berechnung des Fehlers zwischen vorhergesagten und tatsächlichen Werten (z. B. mittlerer quadratischer Fehler) werden Gewichte und Voreingenommenheiten in jeder Schicht umgekehrt mithilfe der Kettenregel aktualisiert, um Modellparameter zu optimieren. Hauptschritte:
- Berechnen des Ausgabefehlers: ( \delta_2 = A_2 - Y )
- Fehler der verborgenen Schicht: ( \delta_1 = \delta_2 \cdot W_2^T \odot \sigma'(Z_1) ) ((\odot) bezeichnet die elementweise Multiplikation)
- Aktualisieren der Gewichte: ( W_2 \leftarrow W_2 - \eta \cdot A_1^T \cdot \delta_2 ), ( W_1 \leftarrow W_1 - \eta \cdot X^T \cdot \delta_1 )
- Aktualisieren der Voreingenommenheiten: ( b_2 \leftarrow b_2 - \eta \cdot \sum \delta_2 ), ( b_1 \leftarrow b_1 - \eta \cdot \sum \delta_1 ) ((\eta) ist die Lernrate, (\sigma') ist die Ableitung der Aktivierungsfunktion)

Ⅱ. Wichtigste Designaspekte der neuronalen Netzimplementierung in Go

1. Datendefinition

Verwenden Sie das Paket gonum.org/v1/gonum/mat in Go für Matrixoperationen, um Netzwerkstrukturen und Parameter zu definieren:

// neuralNet stores trained neural network parameters
type neuralNet struct {
    config   neuralNetConfig // Network configuration
    wHidden  *mat.Dense       // Hidden layer weight matrix
    bHidden  *mat.Dense       // Hidden layer bias vector
    wOut     *mat.Dense       // Output layer weight matrix
    bOut     *mat.Dense       // Output layer bias vector
}

// neuralNetConfig defines network architecture and training parameters
type neuralNetConfig struct {
    inputNeurons  int     // Number of input layer nodes (e.g., 4 features of Iris)
    outputNeurons int     // Number of output layer nodes (e.g., 3 Iris species)
    hiddenNeurons int     // Number of hidden layer nodes (tunable hyperparameter)
    numEpochs     int     // Number of training epochs
    learningRate  float64 // Learning rate
}

2. Aktivierungsfunktion und ihre Ableitung

Wählen Sie die Sigmoid-Funktion als Aktivierungsfunktion aus, deren Ableitung schnell anhand des Funktionswerts berechnet werden kann und die sich für die Rückausbreitung eignet:

// sigmoid Sigmoid activation function
func sigmoid(x float64) float64 {
    return 1.0 / (1.0 + math.Exp(-x))
}

// sigmoidPrime Derivative of the Sigmoid function
func sigmoidPrime(x float64) float64 {
    s := sigmoid(x)
    return s * (1.0 - s)
}

3. Backpropagation Training Logic

Parameterinitialisierung

Initialisieren Sie Gewichte und Voreingenommenheiten mit Zufallszahlen, um sicherzustellen, dass das Netzwerk lernen kann:

func (nn *neuralNet) train(x, y *mat.Dense) error {
    randGen := rand.New(rand.NewSource(time.Now().UnixNano())) // Random number generator
    
    // Initialize weights and biases for hidden and output layers
    wHidden := mat.NewDense(nn.config.inputNeurons, nn.config.hiddenNeurons, nil)
    bHidden := mat.NewDense(1, nn.config.hiddenNeurons, nil)
    wOut := mat.NewDense(nn.config.hiddenNeurons, nn.config.outputNeurons, nil)
    bOut := mat.NewDense(1, nn.config.outputNeurons, nil)
    
    // Fill parameter matrices with random numbers
    for _, param := range [][]*mat.Dense{{wHidden, bHidden}, {wOut, bOut}} {
        for _, m := range param {
            raw := m.RawMatrix().Data
            for i := range raw {
                raw[i] = randGen.Float64() // Random values in [0, 1)
            }
        }
    }
    
    // Invoke backpropagation for training
    return nn.backpropagate(x, y, wHidden, bHidden, wOut, bOut)
}

Core Backpropagation Logic

Implementieren Sie die Fehlerrückausbreitung und Parameteraktualisierungen durch Matrixoperationen. Der Code verwendet die Methode Apply, um Aktivierungsfunktionen und Ableitungen stapelweise zu verarbeiten:

func (nn *neuralNet) backpropagate(x, y, wHidden, bHidden, wOut, bOut *mat.Dense) error {
    for epoch := 0; epoch < nn.config.numEpochs; epoch++ {
        // Forward propagation to calculate outputs of each layer
        hiddenInput := new(mat.Dense).Mul(x, wHidden)          // Hidden layer linear input: X·W_hidden
        hiddenInput.Apply(func(_, col int, v float64) float64 { // Add bias term
            return v + bHidden.At(0, col)
        }, hiddenInput)
        hiddenAct := new(mat.Dense).Apply(sigmoid, hiddenInput) // Hidden layer activated output
        
        outputInput := new(mat.Dense).Mul(hiddenAct, wOut)      // Output layer linear input: A_hidden·W_out
        outputInput.Apply(func(_, col int, v float64) float64 { // Add bias term
            return v + bOut.At(0, col)
        }, outputInput)
        output := new(mat.Dense).Apply(sigmoid, outputInput)    // Output layer activated output
        
        // Backpropagation to calculate errors and gradients
        error := new(mat.Dense).Sub(y, output)                  // Output error: Y - A_out
        
        // Calculate output layer gradients
        outputSlope := new(mat.Dense).Apply(sigmoidPrime, outputInput) // σ'(Z_out)
        dOutput := new(mat.Dense).MulElem(error, outputSlope)           // δ_out = error * σ'(Z_out)
        
        // Calculate hidden layer gradients
        hiddenError := new(mat.Dense).Mul(dOutput, wOut.T()) // Error backpropagation: δ_out·W_out^T
        hiddenSlope := new(mat.Dense).Apply(sigmoidPrime, hiddenInput) // σ'(Z_hidden)
        dHidden := new(mat.Dense).MulElem(hiddenError, hiddenSlope)     // δ_hidden = δ_out·W_out^T * σ'(Z_hidden)
        
        // Update weights and biases (stochastic gradient descent)
        wOut.Add(wOut, new(mat.Dense).Scale(nn.config.learningRate, new(mat.Dense).Mul(hiddenAct.T(), dOutput)))
        bOut.Add(bOut, new(mat.Dense).Scale(nn.config.learningRate, sumAlongAxis(0, dOutput)))
        wHidden.Add(wHidden, new(mat.Dense).Scale(nn.config.learningRate, new(mat.Dense).Mul(x.T(), dHidden)))
        bHidden.Add(bHidden, new(mat.Dense).Scale(nn.config.learningRate, sumAlongAxis(0, dHidden)))
    }
    
    // Save trained parameters
    nn.wHidden, nn.bHidden, nn.wOut, nn.bOut = wHidden, bHidden, wOut, bOut
    return nil
}

4. Vorhersagefunktion

Verwenden Sie nach dem Training trainierte Gewichte und Voreingenommenheiten für die Vorwärtsausbreitung, um Vorhersagen auszugeben:

func (nn *neuralNet) predict(x *mat.Dense) (*mat.Dense, error) {
    // Check if parameters exist
    if nn.wHidden == nil || nn.wOut == nil {
        return nil, errors.New("neural network not trained")
    }
    
    hiddenAct := new(mat.Dense).Mul(x, nn.wHidden).Apply(func(_, col int, v float64) float64 {
        return v + nn.bHidden.At(0, col)
    }, nil).Apply(sigmoid, nil)
    
    output := new(mat.Dense).Mul(hiddenAct, nn.wOut).Apply(func(_, col int, v float64) float64 {
        return v + nn.bOut.At(0, col)
    }, nil).Apply(sigmoid, nil)
    
    return output, nil
}

Ⅲ. Datenverarbeitung und experimentelle Validierung

1. Dataset Vorbereitung

Verwenden Sie das klassische Iris Dataset, das 4 Merkmale (Kelchblattlänge, Kelchblattbreite, Blütenblattlänge, Blütenblattbreite) und 3 Arten (Setosa, Versicolor, Virginica) enthält. Schritte zur Datenvorverarbeitung:

Konvertieren Sie Artenbezeichnungen in One-Hot-Encoding, z. B. entspricht Setosa [1, 0, 0], Versicolor [0, 0, 1].
Teilen Sie 80 % der Daten in den Trainingssatz und 20 % in den Testsatz auf und fügen Sie kleines zufälliges Rauschen hinzu, um die Trainingsschwierigkeit zu erhöhen.

Beispieldaten (Auszug aus train.csv):

sepal_length,sepal_width,petal_length,petal_width,setosa,virginica,versicolor
0.0873,0.6687,0.0,0.0417,1.0,0.0,0.0
0.7232,0.4533,0.6949,0.967,0.0,1.0,0.0
0.6617,0.4567,0.6580,0.6567,0.0,0.0,1.0

2. Hauptprogrammablauf

Daten lesen und in Matrizen konvertieren

func main() {
    // Read training data file
    f, err := os.Open("data/train.csv")
    if err != nil {
        log.Fatalf("failed to open file: %v", err)
    }
    defer f.Close()
    
    reader := csv.NewReader(f)
    reader.FieldsPerRecord = 7 // 4 features + 3 labels
    rawData, err := reader.ReadAll()
    if err != nil {
        log.Fatalf("failed to read CSV: %v", err)
    }
    
    // Parse data into input features (X) and labels (Y)
    numSamples := len(rawData) - 1 // Skip header
    inputsData := make([]float64, 4*numSamples)
    labelsData := make([]float64, 3*numSamples)
    
    for i, record := range rawData {
        if i == 0 {
            continue // Skip header
        }
        for j, val := range record {
            fVal, err := strconv.ParseFloat(val, 64)
            if err != nil {
                log.Fatalf("invalid value: %v", val)
            }
            if j < 4 {
                inputsData[(i-1)*4+j] = fVal // First 4 columns are features
            } else {
                labelsData[(i-1)*3+(j-4)] = fVal // Last 3 columns are labels
            }
        }
    }
    
    inputs := mat.NewDense(numSamples, 4, inputsData)
    labels := mat.NewDense(numSamples, 3, labelsData)
}

Netzwerkparameter konfigurieren und trainieren

// Define network structure: 4 inputs, 3 hidden nodes, 3 outputs
config := neuralNetConfig{
    inputNeurons:  4,
    outputNeurons: 3,
    hiddenNeurons: 5,
    numEpochs:     8000, // Train for 5000 epochs
    learningRate:  0.2,  // Learning rate
}

network := newNetwork(config)
if err := network.train(inputs, labels); err != nil {
    log.Fatalf("training failed: %v", err)
}

Modellgenauigkeit testen

// Read test data and predict
predictions, err := network.predict(testInputs)
if err != nil {
    log.Fatalf("prediction failed: %v", err)
}

// Calculate classification accuracy
trueCount := 0
numPreds, _ := predictions.Dims()
for i := 0; i < numPreds; i++ {
    // Get true label (one-hot to index)
    trueLabel := mat.Row(nil, i, testLabels)
    trueClass := -1
    for j, val := range trueLabel {
        if val == 1.0 {
            trueClass = j
            break
        }
    }
    
    // Get class with highest probability in predictions
    predRow := mat.Row(nil, i, predictions)
    maxVal := floats.Min(predRow)
    predClass := -1
    for j, val := range predRow {
        if val > maxVal {
            maxVal = val
            predClass = j
        }
    }
    
    if trueClass == predClass {
        trueCount++
    }
}

fmt.Printf("Accuracy: %.2f%%\n", float64(trueCount)/float64(numPreds)*100)

Ⅳ. Experimentelle Ergebnisse und Zusammenfassung

Nach 8000 Trainings-Epochen erreicht das Modell eine Klassifizierungsgenauigkeit von ca. 98 % im Testsatz (die Ergebnisse können aufgrund der zufälligen Initialisierung leicht variieren). Dies zeigt, dass selbst ein einfaches dreischichtiges neuronales Netzwerk nichtlineare Klassifizierungsprobleme effektiv lösen kann.

Kernvorteile:

Reine Go-Implementierung: Keine Abhängigkeit von C-Erweiterungen (kein cgo), kann in statische Binärdateien kompiliert werden, geeignet für die plattformübergreifende Bereitstellung.
Matrixabstraktion: Numerische Berechnungen basierend auf dem Paket gonum/mat, mit klarer Codestruktur und einfacher Erweiterbarkeit.

Verbesserungsrichtungen:

Experimentieren Sie mit verschiedenen Aktivierungsfunktionen (z. B. ReLU) oder Optimierern (z. B. Adam).
Fügen Sie eine Regularisierung (z. B. L2-Regularisierung) hinzu, um eine Überanpassung zu verhindern.
Unterstützen Sie mehrere verborgene Schichten, um tiefere neuronale Netze aufzubauen.