Julia 1.3 Showcase Image

]up; dev VegaLite; add VegaDatasets

43.0s

Julia 1.3 Showcase (Julia)

apt-get update
apt-get install npm libpixman-1-dev libcairo2-dev libpango1.0-dev libjpeg-dev build-essential -y
cd /root/.julia/dev/VegaLite/deps
npm install canvas --build-from-source --production --no-package-lock --no-optional -y
npm install --scripts-prepend-node-path=true --production --no-package-lock --no-optional -y

81.0s

Julia 1.3 Showcase (Bash in Julia)

pkg"up; add Query FileIO PyCall Cassette CuArrays Flux JSServe#master GeometryTypes https://github.com/SimonDanisch/ReactiveRuntime.jl.git Observables#sd-extensions https://github.com/JuliaPlots/WGLMakie.jl#sd-jsserve AbstractPlotting CUDAnative CSV DataFrames Plots GR StatsPlots StatsBase BenchmarkTools Cxx"
using PyCall
pip = joinpath(dirname(PyCall.current_python()), "pip3")
run(`$pip install scipy numpy`)

69.1s

Julia 1.3 Showcase (Julia)

Process(`/usr/bin/pip3 install scipy numpy`, ProcessExited(0))

# CuArrays is compiled at precompile time, so lets use it here
using CuArrays
A = cu(rand(100))
B = cu(rand(100))
A .+ B;

71.5s

Julia 1.3 Showcase (Julia)

2.9s

Julia 1.3 Showcase (Julia)

using Mimi, MimiDICE2013
using Observables, Hyperscript, JSServe, AbstractPlotting, WGLMakie, Markdown
using JSServe: with_session, Slider
using JSServe.DOM
set_theme!(markersize = 5, font = "Dejavu Sans", resolution = (500, 400))
baseline = MimiDICE2013.get_model()
run(baseline) # run baseline one time
interacted = MimiDICE2013.get_model()
with_session() do session
  time_tatm = getdataframe(baseline, :climatedynamics, :TATM)
  time = time_tatm.time
  control_rate_s = JSServe.Slider(LinRange(0, 1, 100))
  control_rate = map(control_rate_s) do r
    round(r, digits = 3)
  end
  year = JSServe.Slider(1:length(time))
  data = map(control_rate) do control
    set_param!(interacted, :emissions, :MIU, fill(control, 60))
		run(interacted)
    something.(interacted[:climatedynamics, :TATM], 0.0)
  end
  scene = scatter(time, something.(time_tatm.TATM, 0.0))
  scatter!(time, data, color = :red)
  scene[Axis].names.axisnames = ("Year", "Temperature Increase")
  scene[Axis].names.textsize = (8, 8)
  
  dmg_estimated = map(year, control_rate) do year_idx, _
    round(interacted[:damages, :DAMAGES][year_idx], digits = 4)
  end
	selected_year = map(i-> time[i], year)
  b = DOM.font("● baseline", color = :black)
  ec = DOM.font("● with emission control", color = :red)
  md"""
    # Explore Climate

    Set amount of emission control: $(control_rate_s) $(control_rate)
    # Temperature Increase

    $b | $ec

    $(scene)

    # Estimated damage in year $(selected_year)

    $(year)


    $(dmg_estimated) trillion USD per year.
  """
end

2.9s

Julia 1.3 Showcase (Julia)

using CSV, DataFrames, Plots, StatsPlots
Plots.theme(:wong)
data = CSV.read(emissions.csv
)
data.co2 = data.co2 ./ 10^9;
co2max = by(data, :country, :co2 => maximum)
sort!(co2max, :co2_maximum, rev = true)
bad_countries = co2max.country[1:10]
the_worst = filter(data) do row
  row.country in bad_countries
end
@df the_worst Plots.plot(
  :Year, :co2, group = :country, legend = :topleft, linewidth = 4, 
  title = "Total Accumulative Emission", 
)

30.8s

Julia 1.3 Showcase (Julia)

Why Julia

What is Julia

Python at the speed of C, with elegant syntax for math like Matlab
Multi purpose
Multi paradigm (functional, object inheritance)

Noteworthy Features

Best of lisp inheritance (macros, code as datastructure, functional programming)
threading
multiple dispatch
optional type system
introspection
cross platform
as fast as C

When to use Julia

When performance is key

But I don’t need performance!

Python performance is good enough for me

When you need performance, it is too late
You don’t want to learn a new language at the same time that you are solving your first truly difficult computational problem

I'll just call out to C

rely on mature external libraries, operating on large blocks of data, for performance-critical code

Someone has to write those libraries.
Eventually that person will be you.
some problems are impossible or just very awkward to vectorize

Catchy Examples

Threading

using BenchmarkTools
function map_threaded!(f, a, b)
  Threads.@threads for i in eachindex(a, b)
    @inbounds a[i] = f(b[i])
  end
  return a
end

0.5s

Julia

map_threaded! (generic function with 1 method)

c = copy(a)
map_threaded!(sin, c, b);

0.6s

Julia

d = copy(a)
map!(sin, d, b);
d == c

0.7s

Julia

true

a, b = rand(10^7), rand(10^7);

0.5s

Julia

using CuArrays

52.6s

Julia

@btime map!($sin, $a, $b)
@btime map_threaded!($sin, $a, $b);

13.0s

Julia

acu, bcu = cu(a), cu(b)
@btime CuArrays.@sync(map!($sin, $acu, $bcu));

12.2s

Julia

GPU

Hard mode:

using CUDAnative
function gpu_map!(f, y, x)
    index = (blockIdx().x - 1) * blockDim().x + threadIdx().x
    stride = blockDim().x * gridDim().x
    for i = index:stride:length(y)
        @inbounds y[i] += x[i]
    end
    return nothing
end
N = length(a)
@cuda threads=256 blocks=numblocks gpu_kernel!(A, B)
@assert all(Array(A) .== 3.0f0)

5.4s

Julia 1.3 Showcase (Julia)

Impossible mode:

# using C++ :P

0.2s

Julia 1.3 Showcase (Julia)

Data Science

emissions.csv

using CSV, DataFrames, Plots, StatsPlots
theme(:wong)
data = CSV.read(emissions.csv
)
data.co2 = data.co2 ./ 10^9;
co2max = by(data, :country, :co2 => maximum)
sort!(co2max, :co2_maximum, rev = true)
bad_countries = co2max.country[1:10]
the_worst = filter(data) do row
  row.country in bad_countries
end
@df the_worst plot(
  :Year, :co2, group = :country, legend = :topleft, linewidth = 4, 
  title = "Total Accumulative Emission", 
)

190.5s

Julia 1.3 Showcase (Julia)

using FileIO, Query, VegaLite, Dates
data |>
  @mutate(co2 = _.co2 / 10^9, year = Date(_.Year)) |>
  @groupby({_.country}) |>
  @orderby_descending(maximum(_.co2)) |>
  @take(5) |>
  @mapmany(_, __) |>  # This is essentially ungroup
  DataFrame |>
  @vlplot(
    :line, x=:year, y=:co2, color=:country, title="Emissions", 
    width = 500, height = 300, linewidth = 4
  )

5.3s

Julia 1.3 Showcase (Julia)

Flux

Classify MNIST digits with a simple multi-layer-perceptron

input.txt

using Flux
using Flux: crossentropy, normalise, onecold, onehotbatch
using Statistics: mean
labels = Flux.Data.Iris.labels()
features = Flux.Data.Iris.features()
normed_features = normalise(features, dims=2)
klasses = sort(unique(labels))
onehot_labels = onehotbatch(labels, klasses)
train_indices = [1:3:150 ; 2:3:150]
X_train = normed_features[:, train_indices]
y_train = onehot_labels[:, train_indices]

X_test = normed_features[:, 3:3:150]
y_test = onehot_labels[:, 3:3:150]
model = Chain(
    Dense(4, 3),
    softmax
)
loss(x, y) = crossentropy(model(x), y)
accuracy(x, y) = mean(onecold(model(x)) .== onecold(y))
optimiser = Descent(0.5)
data_iterator = Iterators.repeated((X_train, y_train), 110)
Flux.train!(loss, params(model), data_iterator, optimiser)

0.3s

Julia

accuracy_score = accuracy(X_test, y_test)
accuracy_score > 0.8

0.4s

Julia

true

Cassette

using Cassette
Cassette.@context Ctx
# this prehook implements simple trace logging for overdubbed functions
Cassette.prehook(::Ctx, f, args...) = println(f, args)
Cassette.overdub(Ctx(), *, 1, 2.0)

5.7s

Julia

2.0

Cassette.overdub(::Ctx, ::typeof(convert), ::Type{Float64}, x::Float64) = x * 3.0

0.2s

Julia

Cassette.overdub(Ctx(), *, 1, 2.0)

0.4s

Julia

6.0

Interactive Graphics & Mimis

https://nextjournal.com/sdanisch/reactive-mimi-demo

Oceanigans

PyCall/JavaCall/Ccall/Cxx/Rcall/Matlab

Shift+Enter to run

Julia

using Mimi, MimiDICE2013
using AbstractPlotting, WGLMakie, Markdown
using Observables, Hyperscript, JSServe
using JSServe: with_session, Slider
using JSServe.DOM
set_theme!(markersize = 5,font = "Dejavu Sans", resolution = (500, 400))
baseline = MimiDICE2013.get_model()
run(baseline)
interacted = MimiDICE2013.get_model()
function run_model(control)
	set_param!(interacted, :emissions, :MIU, fill(control, 60))
	run(interacted)
  return something.(interacted[:climatedynamics, :TATM], 0.0)
end
with_session() do session
  time_tatm = getdataframe(baseline, :climatedynamics, :TATM)
  time = time_tatm.time
  control_rate_s = JSServe.Slider(LinRange(0, 1, 100))
  control_rate = map(control_rate_s) do r
    round(r, digits = 3)
  end
  year = JSServe.Slider(1:length(time))
  data = map(run_model, control_rate)
  scene = scatter(time, something.(time_tatm.TATM, 0.0))
  scatter!(time, data, color = :red)
  scene[Axis].names.axisnames = ("Year", "Temperature Increase")
  scene[Axis].names.textsize = (8, 8)
  dmg_estimated = map(year, control_rate) do year_idx, _
    round(interacted[:damages, :DAMAGES][year_idx], digits = 4)
  end
	selected_year = map(i-> time[i], year)
  b = DOM.font("● baseline", color = :black)
  ec = DOM.font("● with emission control", color = :red)
  return md"""
    # Explore Climate

    Set amount of emission control: $(control_rate_s) $(control_rate)
    # Temperature Increase

    $b | $ec

    $(scene)

    # Estimated damage in year $(selected_year)

    $(year)

    $(dmg_estimated) trillion USD per year.
  """
end

Shift+Enter to run

Julia

Ccall

# void * memcpy ( void * destination, const void * source, size_t num );
function memcpy(dest, source, num)
  # if library already loaded by julia, you can leave it out, otherwise
  # ccall((:function_name, "library_name"), ...)
  ccall(
    :memcpy, Ptr{Cvoid}, 
    (Ptr{Cvoid}, Ptr{Cvoid}, Csize_t), 
    dest, source, num
  )
end
a = [1, 2, 3]
b = [0, 0, 0]
memcpy(b, a, sizeof(b))
b

0.9s

Julia

3-element Array{Int64,1}: 1 2 3

Cxx

using Cxx
cxx"""
#include <iostream>
class Hello
{
	public:
		void hello_world(const char *now){
		  std::string snow = now;
		  std::cout << "Hello World! Now is " << snow << std::endl;
		}
};"""

hello_class = @cxxnew Hello()
tstamp = string(Dates.now())
@cxx hello_class->hello_world(pointer(tstamp))

1.3s

Julia

PyCall

Passing functions:

using PyCall
so = pyimport("scipy.optimize")
so.newton(x -> cos(x) - x, 1)

4.8s

Julia

0.739085

Inherit from Python classes:

P = pyimport("numpy.polynomial")
@pydef mutable struct Doubler <: P.Polynomial
    function __init__(self, x=10)
        self.x = x
    end
    my_method(self, arg1::Number) = arg1 + 20
    x2.get(self) = self.x * 2
    function x2.set!(self, new_val)
        self.x = new_val / 2
    end
end
Doubler().x2

6.1s

Julia

What's bad

compile times

deploying julia
some dev tools are missing

Julia in Python

https://nextjournal.com/sdanisch/wglmakie-in-python/edit

Ahead of time Compilation

Deploy

via travis