Go语言深度学习：卷积神经网络与计算机视觉

左手厨刀右手茼蒿

171人浏览 · 2026-05-29 11:51:08

左手厨刀右手茼蒿 · 2026-05-29 11:51:08 发布

Go语言深度学习：卷积神经网络与计算机视觉

卷积神经网络（CNN）是深度学习领域最重要的模型之一，特别适用于计算机视觉任务。本文将深入探讨如何使用Go语言实现CNN，并构建实用的图像处理应用。

文章总体概览信息图

一、卷积神经网络概述

CNN是一种专门处理网格状数据（如图像）的深度学习模型，其核心特点包括：

局部感受野：每个神经元只感受输入的局部区域
权值共享：同一卷积核在整个输入上共享权重
池化层：降低特征图维度，增加平移不变性

二、卷积运算实现

2.1 二维卷积

package main

import (
    "fmt"
    "math"
)

func Convolve2D(input [][]float64, kernel [][]float64) [][]float64 {
    inputHeight := len(input)
    inputWidth := len(input[0])
    kernelSize := len(kernel)
    padding := kernelSize / 2
    
    outputHeight := inputHeight
    outputWidth := inputWidth
    
    output := make([][]float64, outputHeight)
    for i := range output {
        output[i] = make([]float64, outputWidth)
    }
    
    for i := 0; i < outputHeight; i++ {
        for j := 0; j < outputWidth; j++ {
            var sum float64
            for ki := 0; ki < kernelSize; ki++ {
                for kj := 0; kj < kernelSize; kj++ {
                    inputI := i + ki - padding
                    inputJ := j + kj - padding
                    if inputI >= 0 && inputI < inputHeight && inputJ >= 0 && inputJ < inputWidth {
                        sum += input[inputI][inputJ] * kernel[ki][kj]
                    }
                }
            }
            output[i][j] = sum
        }
    }
    
    return output
}

func main() {
    input := [][]float64{
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12},
        {13, 14, 15, 16},
    }
    
    kernel := [][]float64{
        {1, 0, -1},
        {1, 0, -1},
        {1, 0, -1},
    }
    
    result := Convolve2D(input, kernel)
    fmt.Println("卷积结果：")
    for _, row := range result {
        fmt.Println(row)
    }
}

2.2 多通道卷积

func ConvolveMultiChannel(input [][][]float64, kernels [][][][]float64) [][][]float64 {
    numChannels := len(input)
    inputHeight := len(input[0])
    inputWidth := len(input[0][0])
    numKernels := len(kernels)
    kernelSize := len(kernels[0][0])
    padding := kernelSize / 2
    
    output := make([][][]float64, numKernels)
    for k := range output {
        output[k] = make([][]float64, inputHeight)
        for i := range output[k] {
            output[k][i] = make([]float64, inputWidth)
        }
    }
    
    for k := 0; k < numKernels; k++ {
        for i := 0; i < inputHeight; i++ {
            for j := 0; j < inputWidth; j++ {
                var sum float64
                for c := 0; c < numChannels; c++ {
                    for ki := 0; ki < kernelSize; ki++ {
                        for kj := 0; kj < kernelSize; kj++ {
                            inputI := i + ki - padding
                            inputJ := j + kj - padding
                            if inputI >= 0 && inputI < inputHeight && inputJ >= 0 && inputJ < inputWidth {
                                sum += input[c][inputI][inputJ] * kernels[k][c][ki][kj]
                            }
                        }
                    }
                }
                output[k][i][j] = sum
            }
        }
    }
    
    return output
}

三、池化层实现

func MaxPool2D(input [][]float64, poolSize, stride int) [][]float64 {
    inputHeight := len(input)
    inputWidth := len(input[0])
    
    outputHeight := (inputHeight - poolSize) / stride + 1
    outputWidth := (inputWidth - poolSize) / stride + 1
    
    output := make([][]float64, outputHeight)
    for i := range output {
        output[i] = make([]float64, outputWidth)
    }
    
    for i := 0; i < outputHeight; i++ {
        for j := 0; j < outputWidth; j++ {
            maxVal := math.Inf(-1)
            for pi := 0; pi < poolSize; pi++ {
                for pj := 0; pj < poolSize; pj++ {
                    val := input[i*stride+pi][j*stride+pj]
                    if val > maxVal {
                        maxVal = val
                    }
                }
            }
            output[i][j] = maxVal
        }
    }
    
    return output
}

func AvgPool2D(input [][]float64, poolSize, stride int) [][]float64 {
    inputHeight := len(input)
    inputWidth := len(input[0])
    
    outputHeight := (inputHeight - poolSize) / stride + 1
    outputWidth := (inputWidth - poolSize) / stride + 1
    
    output := make([][]float64, outputHeight)
    for i := range output {
        output[i] = make([]float64, outputWidth)
    }
    
    for i := 0; i < outputHeight; i++ {
        for j := 0; j < outputWidth; j++ {
            var sum float64
            count := 0
            for pi := 0; pi < poolSize; pi++ {
                for pj := 0; pj < poolSize; pj++ {
                    inputI := i*stride + pi
                    inputJ := j*stride + pj
                    if inputI < inputHeight && inputJ < inputWidth {
                        sum += input[inputI][inputJ]
                        count++
                    }
                }
            }
            output[i][j] = sum / float64(count)
        }
    }
    
    return output
}

四、完整CNN模型实现

type CNN struct {
    layers []Layer
}

type Layer interface {
    Forward(input [][][]float64) [][][]float64
    Backward(gradient [][][]float64, learningRate float64) [][][]float64
}

type ConvLayer struct {
    kernels    [][][][]float64
    biases     []float64
    input      [][][]float64
}

func NewConvLayer(numChannels, numKernels, kernelSize int) *ConvLayer {
    kernels := make([][][][]float64, numKernels)
    for k := range kernels {
        kernels[k] = make([][][]float64, numChannels)
        for c := range kernels[k] {
            kernels[k][c] = make([][]float64, kernelSize)
            for i := range kernels[k][c] {
                kernels[k][c][i] = make([]float64, kernelSize)
                for j := range kernels[k][c][i] {
                    kernels[k][c][i][j] = (rand.Float64() - 0.5) * 2
                }
            }
        }
    }
    
    biases := make([]float64, numKernels)
    for i := range biases {
        biases[i] = rand.Float64() - 0.5
    }
    
    return &ConvLayer{
        kernels: kernels,
        biases:  biases,
    }
}

func (cl *ConvLayer) Forward(input [][][]float64) [][][]float64 {
    cl.input = input
    output := ConvolveMultiChannel(input, cl.kernels)
    
    for k := range output {
        for i := range output[k] {
            for j := range output[k][i] {
                output[k][i][j] += cl.biases[k]
            }
        }
    }
    
    return output
}

type PoolingLayer struct {
    poolSize int
    stride   int
    poolType string
    input    [][][]float64
}

func NewPoolingLayer(poolSize, stride int, poolType string) *PoolingLayer {
    return &PoolingLayer{
        poolSize: poolSize,
        stride:   stride,
        poolType: poolType,
    }
}

func (pl *PoolingLayer) Forward(input [][][]float64) [][][]float64 {
    pl.input = input
    numChannels := len(input)
    inputHeight := len(input[0])
    inputWidth := len(input[0][0])
    
    outputHeight := (inputHeight - pl.poolSize) / pl.stride + 1
    outputWidth := (inputWidth - pl.poolSize) / pl.stride + 1
    
    output := make([][][]float64, numChannels)
    for c := range output {
        output[c] = make([][]float64, outputHeight)
        for i := range output[c] {
            output[c][i] = make([]float64, outputWidth)
        }
    }
    
    for c := 0; c < numChannels; c++ {
        if pl.poolType == "max" {
            output[c] = MaxPool2D(input[c], pl.poolSize, pl.stride)
        } else {
            output[c] = AvgPool2D(input[c], pl.poolSize, pl.stride)
        }
    }
    
    return output
}

type ActivationLayer struct {
    activation string
    input      [][][]float64
}

func NewActivationLayer(activation string) *ActivationLayer {
    return &ActivationLayer{activation: activation}
}

func (al *ActivationLayer) Forward(input [][][]float64) [][][]float64 {
    al.input = input
    output := make([][][]float64, len(input))
    
    for c := range input {
        output[c] = make([][]float64, len(input[c]))
        for i := range input[c] {
            output[c][i] = make([]float64, len(input[c][i]))
            for j := range input[c][i] {
                output[c][i][j] = al.activate(input[c][i][j])
            }
        }
    }
    
    return output
}

func (al *ActivationLayer) activate(x float64) float64 {
    switch al.activation {
    case "relu":
        return math.Max(0, x)
    case "sigmoid":
        return 1 / (1 + math.Exp(-x))
    case "tanh":
        return math.Tanh(x)
    default:
        return x
    }
}

五、全连接层与分类

type FullyConnectedLayer struct {
    weights [][]float64
    biases  []float64
    input   []float64
}

func NewFullyConnectedLayer(inputSize, outputSize int) *FullyConnectedLayer {
    weights := make([][]float64, outputSize)
    for i := range weights {
        weights[i] = make([]float64, inputSize)
        for j := range weights[i] {
            weights[i][j] = (rand.Float64() - 0.5) * 2 / math.Sqrt(float64(inputSize))
        }
    }
    
    biases := make([]float64, outputSize)
    for i := range biases {
        biases[i] = 0
    }
    
    return &FullyConnectedLayer{
        weights: weights,
        biases:  biases,
    }
}

func (fcl *FullyConnectedLayer) Forward(input []float64) []float64 {
    fcl.input = input
    output := make([]float64, len(fcl.weights))
    
    for i := range output {
        var sum float64
        for j := range input {
            sum += fcl.weights[i][j] * input[j]
        }
        output[i] = sum + fcl.biases[i]
    }
    
    return output
}

func Softmax(logits []float64) []float64 {
    maxVal := math.Inf(-1)
    for _, v := range logits {
        if v > maxVal {
            maxVal = v
        }
    }
    
    exp := make([]float64, len(logits))
    var sum float64
    for i, v := range logits {
        exp[i] = math.Exp(v - maxVal)
        sum += exp[i]
    }
    
    output := make([]float64, len(logits))
    for i := range output {
        output[i] = exp[i] / sum
    }
    
    return output
}

六、完整CNN训练示例

func main() {
    cnn := &CNN{
        layers: []Layer{
            NewConvLayer(1, 32, 3),
            NewActivationLayer("relu"),
            NewPoolingLayer(2, 2, "max"),
            NewConvLayer(32, 64, 3),
            NewActivationLayer("relu"),
            NewPoolingLayer(2, 2, "max"),
        },
    }
    
    fc := NewFullyConnectedLayer(64*7*7, 10)
    
    // 模拟训练数据
    input := make([][][]float64, 1)
    input[0] = make([][]float64, 28)
    for i := range input[0] {
        input[0][i] = make([]float64, 28)
        for j := range input[0][i] {
            input[0][i][j] = rand.Float64()
        }
    }
    
    // 前向传播
    output := input
    for _, layer := range cnn.layers {
        output = layer.Forward(output)
    }
    
    // 展平
    flattened := make([]float64, 0)
    for _, channel := range output {
        for _, row := range channel {
            flattened = append(flattened, row...)
        }
    }
    
    logits := fc.Forward(flattened)
    probabilities := Softmax(logits)
    
    fmt.Println("预测概率分布：")
    for i, prob := range probabilities {
        fmt.Printf("类别%d: %.4f\n", i, prob)
    }
}

七、图像分类实战

func LoadImage(path string) ([][][]float64, error) {
    file, err := os.Open(path)
    if err != nil {
        return nil, err
    }
    defer file.Close()
    
    img, _, err := image.Decode(file)
    if err != nil {
        return nil, err
    }
    
    bounds := img.Bounds()
    width, height := bounds.Max.X, bounds.Max.Y
    
    channels := 3
    result := make([][][]float64, channels)
    for c := range result {
        result[c] = make([][]float64, height)
        for i := range result[c] {
            result[c][i] = make([]float64, width)
        }
    }
    
    for y := 0; y < height; y++ {
        for x := 0; x < width; x++ {
            r, g, b, _ := img.At(x, y).RGBA()
            result[0][y][x] = float64(r) / 65535.0
            result[1][y][x] = float64(g) / 65535.0
            result[2][y][x] = float64(b) / 65535.0
        }
    }
    
    return result, nil
}