How to use Go language for machine learning development?

With the widespread application of machine learning in various fields, programmers are increasingly paying attention to how to develop machine learning models quickly and effectively. Traditional machine learning languages ​​like Python and R have become standard tools in the field of machine learning, but more and more programmers are fascinated by the concurrency and performance of Go language. In this article, we will discuss how to use Go language for machine learning development.

1. Installing Go

First, you need to install Go on your operating system. You can download the installer from the Go official website and install it. After the installation is complete, run the go version command on the command line to check whether Go is installed correctly.

2. Install the machine learning library

There is no built-in machine learning library in Go, but there are many third-party machine learning frameworks, such as tensorflow, gorgonia, goml, etc. Here, we will take gorgonia as an example to introduce how to use Go for machine learning.

Run the following command in the command line to install gorgonia:

go get gorgonia.org/gorgonia

After the installation is completed, you can check whether it is installed correctly by running the following command:

package main

import "gorgonia.org/gorgonia"

func main() {
    gorgonia.NewGraph()
}

If no error is reported, please explain You have successfully installed gorgonia.

3. Using Gorgonia

Next, we will use gorgonia to build a basic neural network for classifying images of handwritten digits. First, we need to prepare the data. There is a mnist package in gorgonia that can be used to download and unpack the mnist dataset.

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

The output results are as follows:

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

The training data contains 60,000 28x28 grayscale images, and the test data contains 10,000 images of the same shape. Each label is a 10-dimensional vector representing the number to which the image belongs.

Next, we will define the architecture of the neural network. We will use a deep neural network with two hidden layers. Each hidden layer has 128 neurons. We will use the relu activation function and the softmax activation function on the output layer to classify the 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))

We use the stochastic gradient descent (SGD) method to train the model. In each epoch, we divide the training data into batches and compute gradients and update parameters on each batch.

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

We have completed the development of a simple machine learning model. You can extend and optimize it according to your needs, such as adding more hidden layers, using different optimizers, etc.

4. Summary

In this article, we discussed how to use the Go language for machine learning development, and took the gorgonia and mnist data sets as examples to demonstrate how to build a Basic neural network to classify images of handwritten digits. Although Go may not be the language of choice in the field of machine learning, it has good concurrency and performance advantages and can be a good choice in some scenarios.

The above is the detailed content of How to use Go language for machine learning development?. For more information, please follow other related articles on the PHP Chinese website!