基于 Julia 的深度学习入门

搬运自我的知乎： https://zhuanlan.zhihu.com/p/142667683

这段时间计算机视觉领域出现了一些使用 Julia 开源的相关工作，要科学合理地对比这些相关工作，储备新的炼丹技巧，笔者不得不开始熟悉 Julia。笔者从周一拿到 Julia 文档开始，这周的试验都是使用 Julia 完成的。这里，打算先说一说笔者的几个感受，帮助大家判断一下自己是否需要着手入坑这门语言：

实用性：★★★★☆

两三年前研究运筹学的时候用 Julia 做最优化问题，感觉比 Cplex 、Matlab 好用。近两年 Julia 开源的深度学习工作逐渐增多，研究的一般是基本问题，在 toy 数据集上跑试验。近期也出现了一些 CV 领域的项目。

生态：★★★☆☆

深度学习库 Flux 和 GPU 计算库 CuArray 基本稳定下来，周边项目更新迅速，比如常用的预训练模型也都可以在 Julia 社区中找到靠谱的库了（如 MetalHead ）。当然，周边项目的快速迭代也会导致一些库动不动就报错（甚至在安装时都要费一番功夫）。另外比较有特点的是，大部分常用的 Python 库都有 PyCall 封装的跟进，实在不行自己用 PyCall 、JavaCall 、Clang 写个胶水层也能用。

易用性：★★★★★

Julia 的语法真的很简单，混合了 Python 和 Matlab，30 分钟入门后续查漏补缺即可。Julia 内置了大量的科学计算方法（符号），确实比 Python 直观和好写了很多。美中不足的是社区现有的代码和官方最佳实践比较少，笔者正在试图在这方面贡献一些工作。

运行速度：★★☆☆☆

运行速度比 PyThon 稍有提高，但是第一次运行需要编译因此调试时体验稍差于 Python。多线程跑崩过系统，GPU 的分布式框架还不太完善。

一、装机必备

在开始之前推荐一些装机必备。考虑到同学们比较熟悉 Python 因此使用 Python 中的 toolbox 进行类比，懒癌患者可以直接装推荐安装的部分：

• Julia 对应 Python
• Pkg3 对应 pip3
• JuliaPro 对应 Anaconda （推荐直接安装这个）
• IJulia + Jupyter 对应 IPython + Jupyter （推荐使用）
• VSCode Julia 插件 对应 VSCode Python 插件
• PkgMirrors + 浙大源 对应 清华源（推荐使用）

二、炼丹示例

Julia 的语言 Feature 较多，但都比较通俗。因此笔者比较推荐同学们在使用过程中慢慢熟悉（就算你想先慢慢学一个月再去做实验老板也不同意是吧）。如果你实在想先浏览一下基础语法，笔者总结了一个 Notebook，帮助你在 15 分钟内看完并有一个大概印象。

下面笔者总结了 Julia 版的常用 Pipeline，可以帮助同学们理解如何像用 Python + PyTorch 一样简单地使用 Julia 完成深度学习项目。在做实验的时候同学们可以简单复制粘贴，修修改改先跑上。（逃

1. MLP + MNIST 实现一个最小用例

首先，我们先完成一个最小用例，实现在 GPU 上训练一个多层感知器拟合 MNIST，了解基本操作。由于篇幅限制，完整代码请参考并运行 MLP+MNIST。

Flux 是 Julia 中的深度学习库，其完全由 Julia 实现，结构轻量化，是 Julia 中的 PyTorch 。因此首先导入 Flux 备用模型定义和反向传播（训练）。

# 从 Flux 中引入所需组件 using Flux, Flux.Data.MNIST, Statistics using Flux: onehotbatch, onecold, crossentropy, throttle, params 

尽管 Flux 中目前已经实现了 gpu() 方法，但功能有限。所幸 Flux 在 GPU 上的功能基于 CuArrays 实现，可以使用 CUDAapi, CUDAdrv, CUDAnative 来设置 Flux 使用哪个 GPU，或是只使用 CPU 。

using CUDAapi, CUDAdrv, CUDAnative gpu_id = 1 ## set < 0 for no cuda, >= 0 for using a specific device (if available) if has_cuda_gpu() && gpu_id >=0 device!(gpu_id) device = Flux.gpu @info "Training on GPU-$(gpu_id)" else device = Flux.cpu @info "Training on CPU" end 

另外，Flux 目前仍不支持分布式 GPU 训练，要想实现该功能也需要利用上述库写 scatter 和 gather 手动实现。

与 PyTorch 相同，Flux 定义了一个开箱即用的数据集 MNIST 。这里我们调用 MNIST.images() 和 MNIST.labels() 加载数据集和对应的 label，并使用 Flux 中提供的 onehotbatch 对 label 进行 onehot 编码。

imgs = MNIST.images() labels = onehotbatch(MNIST.labels(), 0:9) 

目前，Flux 没有提供数据集切分的函数，因此我们需要手动进行该过程。具体而言，我们使用 partition 对加载进来的数据集进行切分，将每 1000 张图像分为一个 batch，并使用 |> device （遍历每个元素分别执行上文中定义的 device()）全部图像迁移到 GPU 中。

train = [(cat(float.(imgs[i])..., dims = 4), labels[:,i]) for i in partition(1:60_000, 1000)] |> device 

同样，我们选择数据集中前 1000 张图片作为测试数据集，也迁移到 GPU 中。

test_X = cat(float.(MNIST.images(:test)[1:1000])..., dims = 4) |> device test_y = onehotbatch(MNIST.labels(:test)[1:1000], 0:9) |> device 

Flux 中的模型定义与 PyTorch 相似，Chain 取代了 nn.Sequential，Conv/MaxPool/Dense 等 layer 也已经封装好（封装的 cuDNN ）可以直接调用。如下所示，定义模型、损失函数和评估方法只需要三段代码。

model = Chain( Conv((2,2), 1=>16, relu), MaxPool((2, 2)), Conv((2,2), 16=>8, relu), MaxPool((2, 2)), x -> reshape(x, :, size(x, 4)), Dense(288, 10), softmax ) |> device loss(x, y) = crossentropy(model(x), y) accuracy(x, y) = mean(onecold(model(x)) .== onecold(y)) 

Flux 为使用者提供了 Adam 优化器，相比于 PyTorch 的版本，该 Adam 优化器似乎对学习旅更为敏感。如果遇到不收敛的情况可以尝试降低 LR 。后续打算对其 FLux 和 PyTorch 的优化器。和 PyTorch 相似，我们直接使用 ADAM(LR)，定义优化器，使用 train!() 进行训练。

opt = ADAM(0.01) evalcb() = @show(accuracy(test_X, test_y)) epochs = 5 for i = 1:epochs Flux.train!(loss, Flux.params(model), train, opt) end 

值得注意的是 Flux 中构建的图也为动态图，无需考虑计算图的构建，直接定义所需的计算操作就可以了。

进行推断时也如同 Pytorch，可以直接调用模型。如下，从测试集中选择一张图片放入模型，预测所属类别。

using Colors, FileIO, ImageShow img = test_X[:, :, 1:1, 7:7] println("Predicted: ", Flux.onecold(model(img |> device)) .- 1) save("outputs.jpg", collect(test_X[:, :, 1, 7])) 

2. VGG + Cifar 封装常用方法 Finetune 模型

在试验和竞赛中，我们通常要对读入图像进行增广；模型也通常是基于某个 pretrained 的模型 Finetune 的，因此接下来我们看如何对这些内容进行封装。由于篇幅限制，这里只说明重要部分，完整代码请参考并运行 VGG+Cifar10。

目前 Flex 和周边的生态还不太完善，图像增强部分的实现实属有限。这里我们参照 pytorch 实现最基本的图像增广的预处理过程。更为丰富的预处理恐怕只能自己编写或是等待官方更新，当然，这也是重新造轮子的好机会～

function resize_smallest_dimension(im, len) reduction_factor = len/minimum(size(im)[1:2]) new_size = size(im) new_size = ( round(Int, size(im,1)*reduction_factor), round(Int, size(im,2)*reduction_factor), ) if reduction_factor < 1.0 # Images.jl's imresize() needs to first lowpass the image, it won't do it for us im = imfilter(im, KernelFactors.gaussian(0.75/reduction_factor), Inner()) end return imresize(im, new_size) end # Take the len-by-len square of pixels at the center of image `im` function center_crop(im, len) l2 = div(len,2) adjust = len % 2 == 0 ? 1 : 0 return im[div(end,2)-l2:div(end,2)+l2-adjust,div(end,2)-l2:div(end,2)+l2-adjust] end function preprocess(im) # Resize such that smallest edge is 256 pixels long im = resize_smallest_dimension(im, 256) # Center-crop to 224x224 im = center_crop(im, 224) # Convert to channel view and normalize (these coefficients taken # from PyTorch's ImageNet normalization code) μ = [0.485, 0.456, 0.406] # the sigma numbers are suspect: they cause the image to go outside of 0..1 # 1/0.225 = 4.4 effective scale σ = [0.229, 0.224, 0.225] #im = (channelview(im) .- μ)./σ im = (channelview(im) .- μ) # Convert from CHW (Image.jl's channel ordering) to WHCN (Flux.jl's ordering) # and enforce Float32, as that seems important to Flux # result is (224, 224, 3, 1) #return Float32.(permutedims(im, (3, 2, 1))[:,:,:,:].*255) # why return Float32.(permutedims(im, (3, 2, 1))[:,:,:,:]) end 

这里将 NIST 的数据集切分方法进行封装，使用 get_processed_data 和 get_test_data 构建训练集合、验证集合和测试集合。

using Metalhead: trainimgs using Images, ImageMagick function get_processed_data(args) # Fetching the train and validation data and getting them into proper shape X = trainimgs(CIFAR10) imgs = [preprocess(X[i].img) for i in 1:40000] #onehot encode labels of batch labels = onehotbatch([X[i].ground_truth.class for i in 1:40000],1:10) train_pop = Int((1-args.splitr_)* 40000) train = device.([(cat(imgs[i]..., dims = 4), labels[:,i]) for i in partition(1:train_pop, args.batchsize)]) valset = collect(train_pop+1:40000) valX = cat(imgs[valset]..., dims = 4) |> device valY = labels[:, valset] |> device val = (valX,valY) return train, val end function get_test_data() # Fetch the test data from Metalhead and get it into proper shape. test = valimgs(CIFAR10) # CIFAR-10 does not specify a validation set so valimgs fetch the testdata instead of testimgs testimgs = [preprocess(test[i].img) for i in 1:1000] testY = onehotbatch([test[i].ground_truth.class for i in 1:1000], 1:10) |> device testX = cat(testimgs..., dims = 4) |> device test = (testX,testY) return test end 

Julia 中预训练模型库正蓬勃发展，比较成熟的有 Metalhead （类似于 Torchvision ）等。这里我们使用 Metalhead 中提供的模型结构和预训练参数构建 VGG19，并替换后面的层完成当前任务。值得一提的是，目前 EfficientNet 还没有较为优雅的 Julia 封装，实属一大遗憾。

using Metalhead vgg = VGG19() model = Chain(vgg.layers[1:end-6], Dense(512, 4096, relu), Dropout(0.5), Dense(4096, 4096, relu), Dropout(0.5), Dense(4096, 10)) |> device Flux.trainmode!(model, true) 

为了方便试验和记录，我们参照官方实现封装超参数和训练过程。在训练过程中，我们可以定义一个回调函数打印验证集的损失函数：throttle(() -> @show(loss(val...)), args.throttle)。

using Parameters: @with_kw @with_kw mutable struct Args batchsize::Int = 128 throttle::Int = 10 lr::Float64 = 5e-5 epochs::Int = 10 splitr_::Float64 = 0.1 end function train(model; kws...) # Initialize the hyperparameters args = Args(; kws...) # Load the train, validation data train, val = get_processed_data(args) @info("Constructing Model") # Defining the loss and accuracy functions loss(x, y) = logitcrossentropy(model(x), y) ## Training # Defining the callback and the optimizer evalcb = throttle(() -> @show(loss(val...)), args.throttle) opt = ADAM(args.lr) @info("Training....") # Starting to train models Flux.@epochs args.epochs Flux.train!(loss, params(model), train, opt, cb=evalcb) end 

3. ResNet + ImageNet 大型数据集上的标准训练过程

在学会在中小型数据集上完成试验后，我们往往要将试验迁移到大型数据集上。训练过程也会增加很多读取、存储、日志等内容。由于篇幅限制，这里只说明重要部分，完整代码请参考并运行 ResNet+ImageNet。

不同于 PyTorch，目前 Flux 对 Dataset 和 Dataloader 的支持十分有限。官方目前正着力于添加相关功能，不久后可能有相关实现。这里我们模仿 PyTorch 多线程读取数据集并生成 Dataloader 。

struct ImagenetDataset # Data we're initialized with dataset_root::String batch_size::Int data_loader::Function # Data we calculate once, at startup filenames::Vector{String} queue_pool::QueuePool function ImagenetDataset(dataset_root::String, num_workers::Int, batch_size::Int, data_loader::Function = imagenet_val_data_loader) # Scan dataset_root for files filenames = filter(f -> endswith(f, ".JPEG"), recursive_readdir(dataset_root)) @assert !isempty(filenames) "Empty dataset folder!" @assert num_workers >= 1 "Must have nonnegative integer number of workers!" @assert batch_size >= 1 "Must have nonnegative integer batch size!" # Start our worker pool @info("Adding $(num_workers) new data workers...") queue_pool = QueuePool(num_workers, data_loader, quote # The workers need to be able to load images and preprocess them via Metalhead using Flux, Images, Metalhead include($(@__FILE__)) end) return new(dataset_root, batch_size, data_loader, filenames, queue_pool) end end # Serialize the arguments needed to recreate this ImagenetDataset function freeze_args(id::ImagenetDataset) return (id.dataset_root, length(id.queue_pool.workers), id.batch_size, id.data_loader) end Base.length(id::ImagenetDataset) = div(length(id.filenames),id.batch_size) mutable struct ImagenetIteratorState batch_idx::Int job_offset::Int function ImagenetIteratorState(id::ImagenetDataset) @info("Creating IIS with $(length(id.filenames)) images") # Build permutation for this iteration permutation = shuffle(1:length(id.filenames)) # Push first job, save value to get job_offset (we know that all jobs # within this iteration will be consequtive, so we only save the offset # of the first one, and can use that to determine the job ids of every # subsequent job: filename = joinpath(id.dataset_root, id.filenames[permutation[1]]) job_offset = push_job!(id.queue_pool, filename) # Next, push every other job for pidx in permutation[2:end] filename = joinpath(id.dataset_root, id.filenames[pidx]) push_job!(id.queue_pool, filename) end return new( 0, job_offset, ) end end function Base.iterate(id::ImagenetDataset, state=ImagenetIteratorState(id)) # If we're at the end of this epoch, give up the ghost if state.batch_idx > length(id) return nothing end # Otherwise, wait for the next batch worth of jobs to finish on our queue pool next_batch_job_ids = state.job_offset .+ (0:(id.batch_size-1)) .+ id.batch_size*state.batch_idx # Next, wait for the currently-being-worked-on batch to be done. pairs = fetch_result.(Ref(id.queue_pool), next_batch_job_ids) state.batch_idx += 1 # Collate X's and Y's into big tensors: X = cat((p[1] for p in pairs)...; dims=ndims(pairs[1][1])) Y = cat((p[2] for p in pairs)...; dims=ndims(pairs[1][2])) # Return the fruit of our labor return (X, Y), state end 

Julia 使用 BSON 实现模型的持久化和读取，速度令人满意。对模型保存和读取进行封装的相关实现如下：

using BSON using Tracker using Statistics, Printf using Flux.Optimise function save_model(model, filename) model_state = Dict( :weights => Tracker.data.(params(model)) ) open(filename, "w") do io BSON.bson(io, model_state) end end function load_model!(model, filename) weights = BSON.load(filename)[:weights] Flux.loadparams!(model, weights) return model end 

4. DCGAN+Fashion/GCN+Cora 其他网络结构与数据集

近年来 GAN 和 GCN 方兴未艾，只实用 Julia 完成图像分类任务还远远不够。因此笔者正尽可能复现多种类的网络结构和任务。以 GAN 和 GCN 为例，Julia 已经能很好地完成试验目标了。由于篇幅限制，这里只说明重要部分，完整代码请参考并运行 DCGAN+Fashion 和 GCN+Cora。

与 CNN 相同，使用 Flux 可以轻松实现对 DCGAN 的定义。

function Discriminator() return Chain( Conv((4, 4), 1 => 64; stride = 2, pad = 1), x->leakyrelu.(x, 0.2f0), Dropout(0.25), Conv((4, 4), 64 => 128; stride = 2, pad = 1), x->leakyrelu.(x, 0.2f0), Dropout(0.25), x->reshape(x, 7 * 7 * 128, :), Dense(7 * 7 * 128, 1)) end function Generator(latent_dim) return Chain( Dense(latent_dim, 7 * 7 * 256), BatchNorm(7 * 7 * 256, relu), x->reshape(x, 7, 7, 256, :), ConvTranspose((5, 5), 256 => 128; stride = 1, pad = 2), BatchNorm(128, relu), ConvTranspose((4, 4), 128 => 64; stride = 2, pad = 1), BatchNorm(64, relu), ConvTranspose((4, 4), 64 => 1, tanh; stride = 2, pad = 1), ) end 

遵循动态图的反向更新策略，我们只需要像 PyTorch 一样定义对抗损失和对抗训练过程，也较为简单。

function discriminator_loss(real_output, fake_output) real_loss = mean(logitbinarycrossentropy.(real_output, 1f0)) fake_loss = mean(logitbinarycrossentropy.(fake_output, 0f0)) return real_loss + fake_loss end generator_loss(fake_output) = mean(logitbinarycrossentropy.(fake_output, 1f0)) function train_discriminator!(gen, dscr, x, opt_dscr, args) noise = randn!(similar(x, (args.latent_dim, args.batch_size))) fake_input = gen(noise) ps = Flux.params(dscr) # Taking gradient loss, back = Flux.pullback(ps) do discriminator_loss(dscr(x), dscr(fake_input)) end grad = back(1f0) update!(opt_dscr, ps, grad) return loss end function train_generator!(gen, dscr, x, opt_gen, args) noise = randn!(similar(x, (args.latent_dim, args.batch_size))) ps = Flux.params(gen) # Taking gradient loss, back = Flux.pullback(ps) do generator_loss(dscr(gen(noise))) end grad = back(1f0) update!(opt_gen, ps, grad) return loss end for ep in 1:args.epochs @info "Epoch $ep" for x in data loss_dscr = train_discriminator!(g_model, d_model, x, opt_dscr, args) loss_gen = train_generator!(g_model, d_model, x, opt_gen, args) end train_steps += 1 end 

对于其他较为复杂的 CNN 模型，例如 UNet，用户也可以自定义模块的调用过程（类似于 PyTorch 中的 forward ）：

function UNet() conv_block = (block1(1, 32), block2(32, 32*2), block2(32*2, 32*4), block2(32*4, 32*8)) conv_block2 = (block1(32*16, 32*8), block1(32*8, 32*4), block1(32*4, 32*2), block1(32*2, 32)) bottle = block2(32*8, 32*16) upconv_block = (upconv(32*16, 32*8), upconv(32*8, 32*4), upconv(32*4, 32*2), upconv(32*2, 32)) conv_ = conv(32, 1) UNet(conv_block, conv_block2, bottle, upconv_block, conv_) end function (u::UNet)(x) enc1 = u.conv_block[1](x) enc2 = u.conv_block[2](enc1) enc3 = u.conv_block[3](enc2) enc4 = u.conv_block[4](enc3) bn = u.bottle(enc4) dec4 = u.upconv_block[1](bn) dec4 = cat(dims=3, dec4, enc4) dec4 = u.conv_block2[1](dec4) dec3 = u.upconv_block[2](dec4) dec3 = cat(dims=3, dec3, enc3) dec3 = u.conv_block2[2](dec3) dec2 = u.upconv_block[3](dec3) dec2 = cat(dims=3, dec2, enc2) dec2 = u.conv_block2[3](dec2) dec1 = u.upconv_block[4](dec2) dec1 = cat(dims=3, dec1, enc1) dec1 = u.conv_block2[4](dec1) dec1 = u.conv_(dec1) end model = UNet() 

在 GNN 模型方面，目前较为流行的 GNN 库是 GeometricFlux，但是由于刚刚开源不久，数据读取方面的支持有限。实现应当是参考了 DGL，较为优雅且易于扩展。笔者目前也正在试图基于 LightGraphs 开发一个 GNN 库，主要着力于图的构建和分布式训练部分。

using GeometricFlux model = Chain(GCNConv(adj_mat, num_features=>hidden, relu), Dropout(0.5), GCNConv(adj_mat, hidden=>target_catg), softmax) |> gpu 

三、后记

上述示例代码和讲解均来源于笔者的开源项目 Julia-Deeplearning，目前已有的最佳实践包括：

• Julia 教程

• • 基础语法

• 卷积神经网络

• • MLP+MNIST
  • VGG+Cifar10
  • ResNet+ImageNet
  • UNet+ISBI

• 生成对抗网络

• • DCGAN+Fashion

• 图卷积网络

• • GCN+Cora

由于笔者近期试验较多，因此只能在试验之余偶尔更新。如果同学们有相关工作欢迎 PR 和提 Issue，衷心希望能够抛砖引玉对大家有所帮助～