Wie verwende ich die Go-Sprache für die Entwicklung maschinellen Lernens?

Angesichts der weit verbreiteten Anwendung von maschinellem Lernen in verschiedenen Bereichen achten Programmierer zunehmend darauf, wie sie Modelle für maschinelles Lernen schnell und effektiv entwickeln können. Traditionelle Sprachen für maschinelles Lernen wie Python und R sind zu Standardwerkzeugen im Bereich des maschinellen Lernens geworden, aber immer mehr Programmierer sind von der Parallelität und Leistung der Go-Sprache fasziniert. In diesem Artikel besprechen wir, wie man die Go-Sprache für die Entwicklung maschinellen Lernens verwendet.

1. Go installieren

Zuerst müssen Sie Go auf Ihrem Betriebssystem installieren. Sie können das Installationsprogramm von der offiziellen Go-Website herunterladen und installieren. Führen Sie nach Abschluss der Installation den Befehl go version in der Befehlszeile aus, um zu überprüfen, ob Go korrekt installiert ist.

2. Installieren Sie die Bibliothek für maschinelles Lernen.

In Go gibt es keine integrierte Bibliothek für maschinelles Lernen, aber es gibt viele Frameworks für maschinelles Lernen von Drittanbietern wie Tensorflow, Gorgonia, Goml usw. Hier nehmen wir Gorgonien als Beispiel, um die Verwendung von Go für maschinelles Lernen vorzustellen.

Führen Sie den folgenden Befehl in der Befehlszeile aus, um Gorgonia zu installieren:

go get gorgonia.org/gorgonia

Nachdem die Installation abgeschlossen ist, können Sie überprüfen, ob sie korrekt installiert wurde, indem Sie den folgenden Befehl ausführen:

package main

import "gorgonia.org/gorgonia"

func main() {
    gorgonia.NewGraph()
}

Wenn kein Fehler gemeldet wird, bedeutet dies, dass dies der Fall ist Gorgonie erfolgreich installiert.

3. Mit Gorgonia

Als nächstes werden wir Gorgonia verwenden, um ein grundlegendes neuronales Netzwerk zur Klassifizierung von Bildern handgeschriebener Ziffern aufzubauen. Zuerst müssen wir die Daten vorbereiten. In Gorgonia gibt es ein Mnist-Paket, mit dem der Mnist-Datensatz heruntergeladen und entpackt werden kann.

package main

import (
    "fmt"
    "gorgonia.org/datasets/mnist"
    "gorgonia.org/gorgonia"
)

func main() {
    // 下载和解压缩 mnist 数据集
    trainData, testData, err := mnist.Load(root)
    if err != nil {
        panic(err)
    }

    // 打印训练和测试数据及标签的形状
    fmt.Printf("train data shape: %v
", trainData.X.Shape())
    fmt.Printf("train labels shape: %v
", trainData.Y.Shape())
    fmt.Printf("test data shape: %v
", testData.X.Shape())
    fmt.Printf("test labels shape: %v
", testData.Y.Shape())
}

Die Ausgabeergebnisse lauten wie folgt:

train data shape: (60000, 28, 28, 1)
train labels shape: (60000, 10)
test data shape: (10000, 28, 28, 1)
test labels shape: (10000, 10)

Die Trainingsdaten enthalten 60.000 28x28-Graustufenbilder und die Testdaten enthalten 10.000 Bilder derselben Form. Jede Beschriftung ist ein 10-dimensionaler Vektor, der die Nummer darstellt, zu der das Bild gehört.

Als nächstes definieren wir die Architektur des neuronalen Netzwerks. Wir werden ein tiefes neuronales Netzwerk mit zwei verborgenen Schichten verwenden. Jede verborgene Schicht hat 128 Neuronen. Wir werden die Relu-Aktivierungsfunktion und die Softmax-Aktivierungsfunktion auf der Ausgabeebene verwenden, um das Bild zu klassifizieren.

dataShape := trainData.X.Shape()
dataSize := dataShape[0]
inputSize := dataShape[1] * dataShape[2] * dataShape[3]
outputSize := testData.Y.Shape()[1]

// 构建神经网络
g := gorgonia.NewGraph()
x := gorgonia.NewTensor(g, tensor.Float32, 4, gorgonia.WithShape(dataSize, dataShape[1], dataShape[2], dataShape[3]), gorgonia.WithName("x"))
y := gorgonia.NewMatrix(g, tensor.Float32, gorgonia.WithShape(dataSize, outputSize), gorgonia.WithName("y"))

hiddenSize := 128
hidden1 := gorgonia.Must(gorgonia.NodeFromAny(g, tensor.Zero(tensor.Float32, hiddenSize), gorgonia.WithName("hidden1")))
hidden2 := gorgonia.Must(gorgonia.NodeFromAny(g, tensor.Zero(tensor.Float32, hiddenSize), gorgonia.WithName("hidden2")))

w1 := gorgonia.NewMatrix(g, tensor.Float32, gorgonia.WithShape(inputSize, hiddenSize), gorgonia.WithName("w1"))
w2 := gorgonia.NewMatrix(g, tensor.Float32, gorgonia.WithShape(hiddenSize, hiddenSize), gorgonia.WithName("w2"))
w3 := gorgonia.NewMatrix(g, tensor.Float32, gorgonia.WithShape(hiddenSize, outputSize), gorgonia.WithName("w3"))

b1 := gorgonia.NewVector(g, tensor.Float32, gorgonia.WithShape(hiddenSize), gorgonia.WithName("b1"))
b2 := gorgonia.NewVector(g, tensor.Float32, gorgonia.WithShape(hiddenSize), gorgonia.WithName("b2"))
b3 := gorgonia.NewVector(g, tensor.Float32, gorgonia.WithShape(outputSize), gorgonia.WithName("b3"))

hidden1Dot, err1 := gorgonia.Mul(x, w1)
hidden1Add, err2 := gorgonia.BroadcastAdd(hidden1Dot, b1, []byte{0})
hidden1Activate := gorgonia.Must(gorgonia.Rectify(hidden1Add))

hidden2Dot, err3 := gorgonia.Mul(hidden1Activate, w2)
hidden2Add, err4 := gorgonia.BroadcastAdd(hidden2Dot, b2, []byte{0})
hidden2Activate := gorgonia.Must(gorgonia.Rectify(hidden2Add))

yDot, err5 := gorgonia.Mul(hidden2Activate, w3)
yAdd, err6 := gorgonia.BroadcastAdd(yDot, b3, []byte{0})
ySoftMax := gorgonia.Must(gorgonia.SoftMax(yAdd))

Wir verwenden die Methode des stochastischen Gradientenabstiegs (SGD), um das Modell zu trainieren. In jeder Epoche teilen wir die Trainingsdaten in Stapel auf, berechnen Farbverläufe und aktualisieren die Parameter für jeden Stapel.

iterations := 10
batchSize := 32
learningRate := 0.01

// 定义代价函数（交叉熵）
cost := gorgonia.Must(gorgonia.Mean(gorgonia.Must(gorgonia.Neg(gorgonia.Must(gorgonia.HadamardProd(y, gorgonia.Must(gorgonia.Log(ySoftMax)))))))

// 定义优化器
optimizer := gorgonia.NewVanillaSolver(g, gorgonia.WithLearnRate(learningRate))

// 表示模型将进行训练
vm := gorgonia.NewTapeMachine(g)

// 进行训练
for i := 0; i < iterations; i++ {
    fmt.Printf("Epoch %d
", i+1)

    for j := 0; j < dataSize; j += batchSize {
        upperBound := j + batchSize
        if upperBound > dataSize {
            upperBound = dataSize
        }
        xBatch := trainData.X.Slice(s{j, upperBound})
        yBatch := trainData.Y.Slice(s{j, upperBound})

        if err := gorgonia.Let(x, xBatch); err != nil {
            panic(err)
        }
        if err := gorgonia.Let(y, yBatch); err != nil {
            panic(err)
        }

        if err := vm.RunAll(); err != nil {
            panic(err)
        }

        if err := optimizer.Step(gorgonia.NodesToValueGrads(w1, b1, w2, b2, w3, b3)); err != nil {
            panic(err)
        }
    }

    // 测试准确率
    xTest := testData.X
    yTest := testData.Y

    if err := gorgonia.Let(x, xTest); err != nil {
        panic(err)
    }
    if err := gorgonia.Let(y, yTest); err != nil {
        panic(err)
    }

    if err := vm.RunAll(); err != nil {
        panic(err)
    }

    predict := gorgonia.Must(gorgonia.Argmax(ySoftMax, 1))
    label := gorgonia.Must(gorgonia.Argmax(yTest, 1))

    correct := 0
    for i := range label.Data().([]float32) {
        if predict.Data().([]float32)[i] == label.Data().([]float32)[i] {
            correct++
        }
    }

    fmt.Printf("Accuracy: %v
", float32(correct)/float32(len(label.Data().([]float32))))
}

Wir haben die Entwicklung eines einfachen Modells für maschinelles Lernen abgeschlossen. Sie können es entsprechend Ihren Anforderungen erweitern und optimieren, z. B. durch das Hinzufügen weiterer versteckter Ebenen, die Verwendung verschiedener Optimierer usw.

4. Zusammenfassung

In diesem Artikel haben wir die Verwendung der Go-Sprache für die Entwicklung maschinellen Lernens besprochen und anhand der Gorgonia- und Mnist-Datensätze als Beispiele gezeigt, wie ein grundlegendes neuronales Netzwerk zur Klassifizierung handgeschriebener Ziffernbilder aufgebaut werden kann. Obwohl Go im Bereich des maschinellen Lernens möglicherweise nicht die Sprache der Wahl ist, bietet es gute Parallelitäts- und Leistungsvorteile und kann in einigen Szenarien eine gute Wahl sein.

Das obige ist der detaillierte Inhalt vonWie verwende ich die Go-Sprache für die Entwicklung maschinellen Lernens?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!