Flux.jl深度学习60分钟快速入门教程-优快云博客

本文链接：https://blog.youkuaiyun.com/gitblog_00099/article/details/148523837

Flux.jl深度学习60分钟快速入门教程

Flux.jl Relax! Flux is the ML library that doesn't make you tensor 项目地址: https://gitcode.com/gh_mirrors/fl/Flux.jl

前言

本文将带您快速了解如何使用Julia语言的Flux.jl库进行深度学习开发。Flux.jl是一个纯Julia实现的深度学习框架，具有简洁直观的语法和强大的自动微分能力。本教程将引导您从基础开始，逐步构建一个完整的图像分类器。

数组基础

在Flux.jl中，数组（Array）是构建模型的基础数据结构，类似于其他框架中的张量（Tensor）。

创建数组

# 创建一维数组
x = [1, 2, 3]

# 创建二维数组（矩阵）
x = [1 2; 3 4]

# 创建随机数组
x = rand(5, 3)  # 5行3列的随机矩阵

Flux.jl支持多种数值类型：

x = rand(Float32, 5, 3)  # 32位浮点数
x = rand(BigFloat, 5, 3) # 高精度浮点数

数组操作

# 获取数组信息
length(x)  # 元素总数
size(x)    # 数组维度

# 数组索引
x[2, 3]    # 获取第2行第3列元素
x[:, 3]    # 获取第3列所有元素

# 基本运算
x + x      # 逐元素相加
x - x      # 逐元素相减

广播机制

Julia的广播语法非常强大：

x .+ 1     # 每个元素加1
(1:5) .* (1:5)'  # 创建乘法表

矩阵运算

W = randn(5, 10)  # 权重矩阵
x = rand(10)      # 输入向量
W * x            # 矩阵乘法

自动微分

Flux.jl的核心特性之一是自动微分（AD），通过Zygote实现。

基础微分

using Flux: gradient

f(x) = 3x^2 + 2x + 1
df(x) = gradient(f, x)[1]  # 一阶导数
ddf(x) = gradient(df, x)[1] # 二阶导数

复杂函数微分

# 泰勒展开近似sin函数
mysin(x) = sum((-1)^k*x^(1+2k)/factorial(1+2k) for k in 0:5)
gradient(mysin, 0.5)[1] ≈ cos(0.5)  # 应与cos(0.5)接近

多参数函数微分

myloss(W, b, x) = sum(W * x .+ b)
gradient(myloss, randn(3,5), zeros(3), rand(5))

构建神经网络

Flux.jl提供了高级API来构建神经网络。

全连接层

using Flux

m = Dense(10 => 5)  # 10输入,5输出的全连接层
x = rand(Float32, 10)
m(x)  # 前向传播

多层网络

model = Chain(
    Dense(10 => 5, relu),  # 带ReLU激活
    Dense(5 => 2)          # 输出层
)

获取和更新参数

# 获取可训练参数
params = Flux.trainables(model)

# 手动梯度更新
η = 0.1  # 学习率
for (k, p) in Flux.trainables(model, path=true)
    p .+= -η * getkeypath(grad, k)
end

使用优化器

opt_state = Flux.setup(Descent(0.1), model)  # 梯度下降优化器

# 训练循环
data, labels = rand(10,100), fill(0.5,2,100)
Flux.train!(loss, model, [(data,labels)], opt_state)

实战：CIFAR10图像分类

让我们构建一个完整的CNN分类器来处理CIFAR10数据集。

数据准备

using MLDatasets: CIFAR10
using Flux: onehotbatch

# 加载数据
train_x, train_y = CIFAR10(:train)[:]
labels = onehotbatch(train_y, 0:9)

# 创建数据加载器
trainloader = DataLoader((train_x, labels), batchsize=1000, shuffle=true)

定义CNN模型

model = Chain(
    Conv((5,5), 3 => 16, relu),  # 输入3通道(RGB),输出16通道
    MaxPool((2,2)),
    Conv((5,5), 16 => 8, relu),
    MaxPool((2,2)),
    flatten,  # 展平为向量
    Dense(200 => 120),
    Dense(120 => 84),
    Dense(84 => 10)  # 10类输出
) |> gpu  # 使用GPU加速

训练配置

using Flux: logitcrossentropy, Momentum

# 损失函数
loss(m, x, y) = logitcrossentropy(m(x), y)

# 优化器(带动量的SGD)
opt_state = Flux.setup(Momentum(0.01), model)

训练循环

epochs = 10

for epoch in 1:epochs
    for batch in trainloader
        x, y = batch |> gpu
        g = gradient(model) do m 
            loss(m, x, y)
        end[1]
        Flux.update!(opt_state, model, g)
    end
    @show accuracy(model, valloader)
end

模型评估

# 测试集准确率
test_accuracy = accuracy(model, testloader)

# 混淆矩阵
confusion_matrix = zeros(Int, 10, 10)
for batch in testloader
    x, y = batch
    preds = model(x)
    ŷ = onecold(preds)
    y = onecold(y)
    for (yi, ŷi) in zip(y, ŷ)
        confusion_matrix[yi, ŷi] += 1
    end
end