Comment utiliser le langage Go pour le développement du machine learning ?

Avec l'application généralisée de l'apprentissage automatique dans divers domaines, les programmeurs accordent de plus en plus d'attention à la manière de développer des modèles d'apprentissage automatique rapidement et efficacement. Les langages d'apprentissage automatique traditionnels comme Python et R sont devenus des outils standards dans le domaine de l'apprentissage automatique, mais de plus en plus de programmeurs sont fascinés par la concurrence et les performances du langage Go. Dans cet article, nous verrons comment utiliser le langage Go pour le développement de l'apprentissage automatique.

1. Installation de Go

Tout d'abord, vous devez installer Go sur votre système d'exploitation. Vous pouvez télécharger le programme d'installation depuis le site officiel de Go et l'installer. Une fois l'installation terminée, exécutez la commande go version sur la ligne de commande pour vérifier si Go est correctement installé.

2. Installer la bibliothèque d'apprentissage automatique

Il n'y a pas de bibliothèque d'apprentissage automatique intégrée dans Go, mais il existe de nombreux frameworks d'apprentissage automatique tiers , comme tensorflow , gorgonia, goml, etc. Ici, nous prendrons la gorgonia comme exemple pour présenter comment utiliser Go pour l'apprentissage automatique.

Exécutez la commande suivante dans la ligne de commande pour installer gorgonia :

go get gorgonia.org/gorgonia

Une fois l'installation terminée, vous pouvez vérifier s'il est correctement installé en exécutant la commande suivante : # 🎜🎜#

package main

import "gorgonia.org/gorgonia"

func main() {
    gorgonia.NewGraph()
}

Si aucune erreur n'est signalée, cela signifie que vous avez installé gorgonia avec succès.

Utilisation de Gorgonia

Ensuite, nous utiliserons Gorgonia pour construire un réseau neuronal de base permettant de classer des images de chiffres manuscrits. Tout d’abord, nous devons préparer les données. Il existe un package mnist dans gorgonia qui peut être utilisé pour télécharger et décompresser l'ensemble de données mnist.

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())
}

Les résultats de sortie sont les suivants :

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

Les données d'entraînement contiennent 60 000 images en niveaux de gris 28x28 et les données de test contiennent 10 000 images de la même forme. Chaque étiquette est un vecteur à 10 dimensions représentant le numéro auquel appartient l'image.

Ensuite, nous définirons l'architecture du réseau de neurones. Nous utiliserons un réseau de neurones profond avec deux couches cachées. Chaque couche cachée possède 128 neurones. Nous utiliserons la fonction d'activation relu et la fonction d'activation softmax sur la couche de sortie pour classer l'image.

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))

Nous utilisons la méthode de descente de gradient stochastique (SGD) pour entraîner le modèle. À chaque époque, nous divisons les données d'entraînement en lots, calculons les gradients et mettons à jour les paramètres de chaque lot.

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))))
}

Nous avons terminé le développement d'un modèle simple d'apprentissage automatique. Vous pouvez l'étendre et l'optimiser en fonction de vos besoins, comme en ajoutant davantage de couches cachées, en utilisant différents optimiseurs, etc.

Summary

Dans cet article, nous avons expliqué comment utiliser le langage Go pour le développement de l'apprentissage automatique, en prenant comme exemples les ensembles de données Gorgonia et mnist. , montre comment construire un réseau neuronal de base pour classer des images de chiffres manuscrits. Bien que Go ne soit peut-être pas le langage de choix dans le domaine de l’apprentissage automatique, il présente de bons avantages en termes de concurrence et de performances et peut constituer un bon choix dans certains scénarios.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!