Kaji cara melaksanakan CNN menggunakan Golang

Golang melaksanakan CNN

Pembelajaran mendalam memainkan peranan penting dalam bidang sains komputer. Dalam bidang penglihatan komputer, rangkaian neural convolutional (CNN) adalah teknologi yang sangat popular. Dalam artikel ini, kita akan mengkaji bagaimana untuk melaksanakan CNN menggunakan Golang.

Untuk memahami CNN, kita perlu memahami operasi konvolusi terlebih dahulu. Operasi lilitan ialah operasi teras CNN Data input boleh didarab dengan kernel dengan meluncurkan kernel untuk menjana peta ciri output. Di Golang, kita boleh menggunakan GoCV untuk memproses imej. GoCV ialah perpustakaan Golang yang ditulis oleh perpustakaan OpenCV C++, khusus untuk penglihatan komputer dan pemprosesan imej.

Dalam GoCV, kami boleh menggunakan jenis Mat untuk mewakili imej dan peta ciri. Jenis Mat ialah matriks multidimensi yang boleh menyimpan nilai satu atau lebih saluran. Dalam CNN, tiga lapisan Mat biasanya digunakan: Mat input, Mat kernel convolution dan Mat output. Kita boleh melaksanakan operasi lilitan dengan mendarabkan Mat input dan Mat kernel lilitan, dan kemudian mengumpulkan hasilnya ke dalam Mat output.

Berikut ialah fungsi lilitan mudah yang dilaksanakan menggunakan Golang:

func convolve(input, kernel *gocv.Mat, stride int) *gocv.Mat {
    out := gocv.NewMatWithSize((input.Rows()-kernel.Rows())/stride+1, (input.Cols()-kernel.Cols())/stride+1, gocv.MatTypeCV32F)
    for row := 0; row < out.Rows(); row++ {
        for col := 0; col < out.Cols(); col++ {
            sum := float32(0)
            for i := 0; i < kernel.Rows(); i++ {
                for j := 0; j < kernel.Cols(); j++ {
                    inputRow := row*stride + i
                    inputCol := col*stride + j
                    value := input.GetFloatAt(inputRow, inputCol, 0)
                    kernelValue := kernel.GetFloatAt(i, j, 0)
                    sum += value * kernelValue
                }
            }
            out.SetFloatAt(row, col, 0, sum)
        }
    }
    return out
}

Dalam fungsi lilitan mudah ini, kami akan memasukkan Mat dan kernel lilitan Mat sebagai parameter input, Dan menentukan saiz langkah bergerak . Kami mengulangi setiap elemen Mat keluaran, mendarabkan Mat input dan Mat kernel lilitan dan mengumpulnya ke dalam Mat output. Akhirnya, kami akan mengeluarkan Mat sebagai nilai pulangan fungsi.

Sekarang mari kita lihat cara menggunakan fungsi lilitan untuk melaksanakan CNN. Kami akan menggunakan Golang untuk melaksanakan CNN dua lapisan mudah untuk mengklasifikasikan digit tulisan tangan.

Rangkaian kami akan terdiri daripada dua lapisan konvolusi dan dua lapisan bersambung sepenuhnya. Selepas lapisan konvolusi pertama, kami akan menggunakan lapisan pengumpulan maksimum untuk mengurangkan saiz data. Selepas lapisan konvolusi kedua, kami melakukan pengumpulan purata pada data untuk mengurangkan lagi saiz data. Akhir sekali, kami akan menggunakan dua lapisan bersambung sepenuhnya untuk mengklasifikasikan data ciri.

Berikut ialah kod untuk CNN ringkas yang dilaksanakan menggunakan Golang:

func main() {
    inputSize := image.Point{28, 28}
    batchSize := 32
    trainData, trainLabels, testData, testLabels := loadData()

    batchCount := len(trainData) / batchSize

    conv1 := newConvLayer(inputSize, 5, 20, 1)
    pool1 := newMaxPoolLayer(conv1.outSize, 2)
    conv2 := newConvLayer(pool1.outSize, 5, 50, 1)
    pool2 := newAvgPoolLayer(conv2.outSize, 2)
    fc1 := newFcLayer(pool2.totalSize(), 500)
    fc2 := newFcLayer(500, 10)

    for i := 0; i < 10; i++ {
        for j := 0; j < batchCount; j++ {
            start := j * batchSize
            end := start + batchSize

            inputs := make([]*gocv.Mat, batchSize)
            for k := start; k < end; k++ {
                inputs[k-start] = preprocess(trainData[k])
            }
            labels := trainLabels[start:end]

            conv1Out := convolveBatch(inputs, conv1)
            relu(conv1Out)
            pool1Out := maxPool(conv1Out, pool1)

            conv2Out := convolveBatch(pool1Out, conv2)
            relu(conv2Out)
            pool2Out := avgPool(conv2Out, pool2)

            fc1Out := fc(pool2Out, fc1)
            relu(fc1Out)
            fc2Out := fc(fc1Out, fc2)

            softmax(fc2Out)
            costGradient := costDerivative(fc2Out, labels)
            fcBackward(fc1, costGradient, fc2Out)
            fcBackward(pool2, fc1.gradient, fc1.out)
            reluBackward(conv2.gradient, pool2.gradient, conv2.out)
            convBackward(pool1, conv2.gradient, conv2.kernels, conv2.out, pool1.out)
            maxPoolBackward(conv1.gradient, pool1.gradient, conv1.out)
            convBackward(inputs, conv1.gradient, conv1.kernels, nil, conv1.out)

            updateParameters([]*layer{conv1, conv2, fc1, fc2})
        }

        accuracy := evaluate(testData, testLabels, conv1, pool1, conv2, pool2, fc1, fc2)
        fmt.Printf("Epoch %d, Accuracy: %f\n", i+1, accuracy)
    }
}

Dalam pelaksanaan CNN mudah ini, kami menggunakan operasi Mat asas untuk melaksanakannya. Kami mula-mula memanggil fungsi loadData untuk memuatkan data latihan dan ujian. Kemudian kami mentakrifkan struktur lapisan konvolusi, lapisan penyatuan dan lapisan bersambung sepenuhnya. Kami mengulangi semua kumpulan data dan memasukkannya ke dalam rangkaian menggunakan fungsi prapemprosesan baharu. Akhir sekali, kami menggunakan algoritma perambatan belakang untuk mengira kecerunan dan mengemas kini berat dan berat sebelah.

Ringkasan:

Dalam artikel ini, kami mempelajari tentang prinsip asas operasi belitan dan CNN, dan melaksanakan CNN mudah menggunakan Golang. Kami menggunakan operasi Mat asas untuk mengira operasi lilitan dan pengumpulan, dan menggunakan algoritma perambatan belakang untuk mengemas kini pemberat dan berat sebelah. Dengan melaksanakan CNN mudah ini, kami boleh memahami rangkaian saraf dengan lebih baik dan mula meneroka CNN yang lebih maju.

Atas ialah kandungan terperinci Kaji cara melaksanakan CNN menggunakan Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!