Julia Flux Environment

# Encode MNIST images as compressed vectors that can later be decoded back into

# images.

using Flux, Flux.Data.MNIST

using Flux: @epochs, onehotbatch, mse, throttle

using Base.Iterators: partition

using Parameters: @with_kw

using CUDA

if has_cuda()

    @info "CUDA is on"

    import CUDA

    CUDA.allowscalar(false)

end

@with_kw mutable struct Args

    lr::Float64 = 1e-3		# Learning rate

    epochs::Int = 10		# Number of epochs

    N::Int = 32			# Size of the encoding

    batchsize::Int = 1000	# Batch size for training

    sample_len::Int = 20 	# Number of random digits in the sample image

    throttle::Int = 5		# Throttle timeout

end

function get_processed_data(args)

    # Loading Images

    imgs = MNIST.images()

    #Converting image of type RGB to float 

    imgs = channelview.(imgs)

    # Partition into batches of size 1000

    train_data = [float(hcat(vec.(imgs)...)) for imgs in partition(imgs, args.batchsize)]

    train_data = gpu.(train_data)

    return train_data

end

function train(; kws...)

    args = Args(; kws...)	

    train_data = get_processed_data(args)

    @info("Constructing model......")

    # You can try to make the encoder/decoder network larger

    # Also, the output of encoder is a coding of the given input.

    # In this case, the input dimension is 28^2 and the output dimension of

    # encoder is 32. This implies that the coding is a compressed representation.

    # We can make lossy compression via this `encoder`.

    encoder = Dense(28^2, args.N, leakyrelu) |> gpu

    decoder = Dense(args.N, 28^2, leakyrelu) |> gpu 

    # Defining main model as a Chain of encoder and decoder models

    m = Chain(encoder, decoder)

    @info("Training model.....")

    loss(x) = mse(m(x), x)

    ## Training

    evalcb = throttle(() -> @show(loss(train_data[1])), args.throttle)

    opt = ADAM(args.lr)

    @epochs args.epochs Flux.train!(loss, Flux.params(m), zip(train_data), opt, cb = evalcb)

    return m, args

end

using Images

img(x::Vector) = Gray.(reshape(clamp.(x, 0, 1), 28, 28))

function sample(m, args)

    imgs = MNIST.images()

    #Converting image of type RGB to float 

    imgs = channelview.(imgs)

    # `args.sample_len` random digits

    before = [imgs[i] for i in rand(1:length(imgs), args.sample_len)]

    # Before and after images

    after = img.(map(x -> cpu(m)(float(vec(x))), before))

    # Stack them all together

    hcat(vcat.(before, after)...)

end

cd(@__DIR__)

m, args= train()

# Sample output

@info("Saving image sample as sample_ae.png")

save("/results/sample_ae.png", sample(m, args))

]up

]add Flux NNlib FFTW Adapt Images ImageFiltering GPUArrays CUDA

]build

]precompile

using Flux

# download data, to make sure they persist in the file system

for Mod in (Flux.Data.FashionMNIST, Flux.Data.MNIST)

  Mod.images(:train)

  Mod.labels(:train)

end;

using Flux, NNlib, FFTW, DataFrames, StatsBase, CSV, BSON, Unitful, Adapt, Parameters, GR, Plots, StatsPlots, WGLMakie, Images, ImageCore, ImageShow, ImageFiltering, Colors, ProgressMeter, BenchmarkTools, GPUArrays, CUDA

using PackageCompiler

pc_pkgs = "Flux, NNlib, FFTW, GPUArrays, Adapt, GR, Plots, StatsBase, StatsPlots, WGLMakie"

#

#DataFrames, CSV, BSON, Unitful, Parameters, Colors, ProgressMeter, BenchmarkTools, GPUArrays, Adapt, Images, ImageCore, ImageShow, ImageFiltering

#CUDA?

create_sysimage([Symbol(String(strip(pkg))) for pkg in split(pc_pkgs, ",")],

  replace_default=true,

  precompile_execution_file="/root/precompile.jl",

  cpu_target="broadwell")

julia -v

julia -g 2 -e 'print("Hello, whirled.\n")'

du -hsx /

"$VERSION"

"$VERSION"

using Flux, BSON, ImageFiltering, Unitful, Adapt, BenchmarkTools, Colors, FileIO, ImageShow, Plots, GR, ProgressMeter, GPUArrays, CUDA, NNlib