使用go-deep实现功能丰富的神经网络开发

go-deep是一个用Go语言编写的神经网络库，它提供了构建、训练和评估各种神经网络模型的功能。下面我将介绍如何使用go-deep库实现不同类型的神经网络。

安装go-deep

首先安装go-deep库：

go get github.com/patrikeh/go-deep

基本神经网络示例

1. 创建简单的前馈神经网络

package main

import (
	"fmt"
	"github.com/patrikeh/go-deep"
	"github.com/patrikeh/go-deep/training"
)

func main() {
	// 创建神经网络: 2输入, 2隐藏层(每层4个神经元), 1输出
	n := deep.NewNeural(&deep.Config{
		Inputs:     2,
		Layout:     []int{4, 4, 1}, // 网络结构
		Activation: deep.ActivationTanh,
		Mode:       deep.ModeBinary,
		Weight:     deep.NewNormal(0.5, 0.1),
		Bias:       true,
	})

	// 训练数据: XOR问题
	inputs := [][]float64{
		{0, 0},
		{0, 1},
		{1, 0},
		{1, 1},
	}
	targets := [][]float64{
		{0},
		{1},
		{1},
		{0},
	}

	// 训练器配置
	trainer := training.NewTrainer(
		training.NewSGD(0.1, 0.1, 1e-6, true),
		training.OnBatchDone(func(batch training.Batch) {
			fmt.Printf("Epoch: %d, Loss: %.5f\n", batch.Epoch, batch.Loss)
		}),
	)
	
	// 训练网络
	trainer.Train(n, inputs, targets, 1000, 4) // epochs=1000, batchSize=4

	// 测试网络
	for _, input := range inputs {
		fmt.Printf("%.1f XOR %.1f => %.5f\n", input[0], input[1], n.Predict(input)[0])
	}
}

2. 实现回归问题

func regressionExample() {
	// 创建回归网络
	n := deep.NewNeural(&deep.Config{
		Inputs:     1,
		Layout:     []int{10, 10, 1}, // 2个隐藏层
		Activation: deep.ActivationReLU,
		Mode:       deep.ModeRegression,
		Weight:     deep.NewNormal(0.5, 0.1),
		Bias:       true,
	})

	// 生成训练数据 (y = x^2)
	var inputs, targets [][]float64
	for i := 0.0; i < 1.0; i += 0.01 {
		inputs = append(inputs, []float64{i})
		targets = append(targets, []float64{i * i})
	}

	// 使用Adam优化器
	trainer := training.NewTrainer(
		training.NewAdam(0.01, 0.9, 0.999, 1e-8),
		training.OnEpochDone(func(epoch int, loss float64) {
			if epoch%100 == 0 {
				fmt.Printf("Epoch: %d, Loss: %.5f\n", epoch, loss)
			}
		}),
	)

	trainer.Train(n, inputs, targets, 500, 10)

	// 测试
	testInput := 0.7
	fmt.Printf("%.1f^2 => %.5f (expected %.2f)\n", 
		testInput, n.Predict([]float64{testInput})[0], testInput*testInput)
}

3. 实现分类问题

func classificationExample() {
	// 创建分类网络 (3类)
	n := deep.NewNeural(&deep.Config{
		Inputs:     4, // 鸢尾花数据集特征数
		Layout:     []int{6, 3}, // 1个隐藏层(6神经元), 输出层(3神经元)
		Activation: deep.ActivationSigmoid,
		Mode:       deep.ModeMultiClass,
		Weight:     deep.NewNormal(0.5, 0.1),
		Bias:       true,
	})

	// 加载鸢尾花数据集 (简化版)
	inputs := [][]float64{
		{5.1, 3.5, 1.4, 0.2}, // setosa
		{7.0, 3.2, 4.7, 1.4}, // versicolor
		{6.3, 3.3, 6.0, 2.5}, // virginica
		// 更多数据...
	}
	targets := [][]float64{
		{1, 0, 0}, // setosa
		{0, 1, 0}, // versicolor
		{0, 0, 1}, // virginica
		// 更多数据...
	}

	trainer := training.NewTrainer(
		training.NewAdam(0.01, 0.9, 0.999, 1e-8),
		training.OnEpochDone(func(epoch int, loss float64) {
			if epoch%100 == 0 {
				fmt.Printf("Epoch: %d, Loss: %.5f\n", epoch, loss)
			}
		}),
	)

	trainer.Train(n, inputs, targets, 1000, 4)

	// 测试
	testInput := []float64{5.9, 3.0, 5.1, 1.8} // 预期virginica
	prediction := n.Predict(testInput)
	fmt.Printf("预测结果: %.2f (setosa, versicolor, virginica)\n", prediction)
}

高级功能

1. 保存和加载模型

func saveAndLoadModel() {
	// 创建并训练网络...
	n := deep.NewNeural(&deep.Config{
		Inputs:     2,
		Layout:     []int{4, 1},
		Activation: deep.ActivationTanh,
		Mode:       deep.ModeBinary,
	})
	
	// 保存模型到文件
	err := n.Save("model.gob")
	if err != nil {
		panic(err)
	}

	// 从文件加载模型
	loadedModel, err := deep.Load("model.gob")
	if err != nil {
		panic(err)
	}

	// 使用加载的模型进行预测
	fmt.Println(loadedModel.Predict([]float64{0, 1}))
}

2. 自定义激活函数

func customActivation() {
	// 定义自定义激活函数
	myActivation := func(x float64) float64 {
		return x / (1 + math.Abs(x)) // 自定义S形函数
	}

	// 创建使用自定义激活函数的网络
	n := deep.NewNeural(&deep.Config{
		Inputs:     2,
		Layout:     []int{4, 1},
		Activation: myActivation,
		Mode:       deep.ModeBinary,
	})
	
	// 训练和使用网络...
}

3. 使用Dropout防止过拟合

func withDropout() {
	n := deep.NewNeural(&deep.Config{
		Inputs:     10,
		Layout:     []int{20, 20, 5}, // 2个隐藏层
		Activation: deep.ActivationReLU,
		Mode:       deep.ModeMultiClass,
		Weight:     deep.NewNormal(0.5, 0.1),
		Bias:       true,
		Dropout:    0.2, // 20%的dropout率
	})
	
	// 训练和使用网络...
}

性能优化技巧

1. 批量大小调整：较大的批量可以提高训练速度，但可能影响模型质量
2. 学习率调度：训练过程中动态调整学习率
3. 提前停止：监控验证集性能，在性能不再提升时停止训练

func advancedTraining() {
	n := deep.NewNeural(&deep.Config{
		Inputs:     8,
		Layout:     []int{32, 32, 1},
		Activation: deep.ActivationLeakyReLU,
		Mode:       deep.ModeRegression,
	})
	
	// 创建学习率调度器
	scheduler := training.NewRateScheduler(
		0.01, // 初始学习率
		training.RateSchedule{
			{Epoch: 100, Rate: 0.005},
			{Epoch: 200, Rate: 0.001},
		},
	)
	
	trainer := training.NewTrainer(
		training.NewAdam(0.01, 0.9, 0.999, 1e-8),
		training.WithLearnable(scheduler),
		training.WithBatchSize(64),
		training.WithEarlyStop(20, 0.01), // 20轮无改善，最小改善0.01
		training.OnEpochDone(func(epoch int, loss float64) {
			fmt.Printf("Epoch: %d, LR: %.5f, Loss: %.5f\n", 
				epoch, scheduler.GetRate(), loss)
		}),
	)
	
	// 训练网络...
}

go-deep库提供了丰富的功能来构建各种神经网络模型，通过合理配置网络结构、激活函数和训练参数，可以解决多种机器学习问题。根据具体任务需求调整网络深度、宽度和训练策略，通常能获得良好的性能。