Bagaimana untuk menggunakan bahasa Go untuk pembangunan pembelajaran mesin?

Dengan aplikasi pembelajaran mesin yang meluas dalam pelbagai bidang, pengaturcara semakin memberi perhatian kepada cara membangunkan model pembelajaran mesin dengan cepat dan berkesan. Bahasa pembelajaran mesin tradisional seperti Python dan R telah menjadi alat standard dalam bidang pembelajaran mesin, tetapi semakin ramai pengaturcara terpesona dengan keselarasan dan prestasi bahasa Go. Dalam artikel ini, kita akan membincangkan cara menggunakan bahasa Go untuk pembangunan pembelajaran mesin.

1. Memasang Go

Mula-mula, anda perlu memasang Go pada sistem pengendalian anda. Anda boleh memuat turun pemasang dari tapak web rasmi Go dan memasangnya. Selepas pemasangan selesai, jalankan arahan go version pada baris arahan untuk menyemak sama ada Go dipasang dengan betul.

2. Pasang pustaka pembelajaran mesin

Tiada perpustakaan pembelajaran mesin terbina dalam dalam Go, tetapi terdapat banyak rangka kerja pembelajaran mesin pihak ketiga, seperti aliran tensor, gorgonia, goml, dll. Di sini, kami akan mengambil gorgonia sebagai contoh untuk memperkenalkan cara menggunakan Go untuk pembelajaran mesin.

Jalankan arahan berikut dalam baris arahan untuk memasang gorgonia:

go get gorgonia.org/gorgonia

Selepas pemasangan selesai, anda boleh menyemak sama ada ia dipasang dengan betul dengan menjalankan arahan berikut:

package main

import "gorgonia.org/gorgonia"

func main() {
    gorgonia.NewGraph()
}

Jika tiada ralat dilaporkan, sila jelaskan Anda telah berjaya memasang gorgonia.

3. Menggunakan Gorgonia

Seterusnya, kami akan menggunakan gorgonia untuk membina rangkaian saraf asas untuk mengklasifikasikan imej digit tulisan tangan. Pertama, kita perlu menyediakan data. Terdapat pakej mnist dalam gorgonia yang boleh digunakan untuk memuat turun dan membongkar dataset 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())
}

Keputusan output adalah seperti berikut:

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

Data latihan mengandungi 60,000 imej skala kelabu 28x28, dan data ujian mengandungi 10,000 imej bentuk yang sama. Setiap label ialah vektor 10 dimensi yang mewakili nombor kepunyaan imej itu.

Seterusnya, kami akan mentakrifkan seni bina rangkaian saraf. Kami akan menggunakan rangkaian neural dalam dengan dua lapisan tersembunyi. Setiap lapisan tersembunyi mempunyai 128 neuron. Kami akan menggunakan fungsi pengaktifan relu dan fungsi pengaktifan softmax pada lapisan output untuk mengklasifikasikan imej.

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

Kami menggunakan kaedah keturunan kecerunan stokastik (SGD) untuk melatih model. Dalam setiap zaman, kami membahagikan data latihan kepada kelompok dan mengira kecerunan dan mengemas kini parameter pada setiap kelompok.

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

Kami telah menyelesaikan pembangunan model pembelajaran mesin mudah. Anda boleh memanjangkan dan mengoptimumkannya mengikut keperluan anda, seperti menambah lebih banyak lapisan tersembunyi, menggunakan pengoptimum yang berbeza, dsb.

4. Ringkasan

Dalam artikel ini, kami membincangkan cara menggunakan bahasa Go untuk pembangunan pembelajaran mesin, dan mengambil set data gorgonia dan mnist sebagai contoh untuk menunjukkan cara membina rangkaian saraf asas untuk mengklasifikasikan imej digit tulisan tangan. Walaupun Go mungkin bukan bahasa pilihan dalam bidang pembelajaran mesin, ia mempunyai kelebihan keselarasan dan prestasi yang baik serta boleh menjadi pilihan yang baik dalam beberapa senario.

Atas ialah kandungan terperinci Bagaimana untuk menggunakan bahasa Go untuk pembangunan pembelajaran mesin?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!