The Iris data set

begin

    import Pkg;

    packages = ["CSV","DataFrames","PlutoUI","Plots","Combinatorics"]   

    Pkg.add(packages)

    using CSV, DataFrames, PlutoUI, Plots, Combinatorics

​

    plotly()

    theme(:solarized_light)

end

begin

    path = "iris/iris.data"

    csv_data = CSV.File(path, header=false)

    iris_names = ["sepal_len", "sepal_wid", "petal_len", "petal_wid", "class"]

    df = DataFrame(csv_data.columns, Symbol.(iris_names))

    dropmissing!(df)

    md"""

    **Column names:** $(join(iris_names, ", "))

    $(describe(df, cols=1:4))

    """

end

begin

    df_species = groupby(df, :class)

    md"""**Class sizes:** $(size(df_species[1])), $(size(df_species[2])) $(size(df_species[3]))"""

end

begin

    scatter(title="len vs wid", xlabel = "length", ylabel="width",

             df.sepal_len, df.sepal_wid, color="blue", label="sepal")

    scatter!(df.petal_len, df.petal_wid, color="red", label="petal")

end

begin

    # Get all combinations of colums

    combins = collect(combinations(1:4,2))

    combos = [(df[x][1], df[x][2]) for x in combins]

    # Plot all combinations in sub-plots

    scatter(combos, layout=(2,3))

end

begin

    setosa, versicolor, virginica = df_species

    scatter(setosa[1], setosa[2], setosa[3], label="Setosa", xlabel="d")

    scatter!(versicolor[1], versicolor[2], versicolor[3], label="versicolor")

    scatter!(virginica[1], virginica[2], virginica[3], label="virginica")

end

begin

    Pkg.add("Flux")

    Pkg.add("CUDA")

    Pkg.add("IterTools")

    using Flux

    using Flux: Data.DataLoader

    using Flux: @epochs

    using CUDA

    using Random

    using IterTools: ncycle

    Random.seed!(123);

​

#   CUDA.allowscalar(false)

end

begin   

    # Convert df to array

    data = convert(Array, df)

    # Shuffle

    data = data[shuffle(1:end), :]

​

    # train/test split

    train_test_ratio = .7

    idx = Int(floor(size(df, 1) * train_test_ratio))

    data_train = data[1:idx,:]

    data_test = data[idx+1:end, :]

​

    # Get feature vectors

    get_feat(d) = transpose(convert(Array{Float32},d[:, 1:end-1]))

    x_train = get_feat(data_train)

    x_test = get_feat(data_test)

    # One hot labels

    #   onehot(d) = [Flux.onehot(v, unique(df.class)) for v in d[:,end]]

    onehot(d) = Flux.onehotbatch(d[:,end], unique(df.class))

    y_train = onehot(data_train)

    y_test = onehot(data_test)

​

    # Push data onto the GPU    

#   x_train = cu(x_train)

#   x_test = cu(x_test)

#   y_train = cu(y_train)

#   y_test = cu(y_test)

    md"""

    Formating data for training (including onehot conversion and (NOT) moving to gpu)

    """

end

begin

    batch_size= 1

    train_dl = DataLoader((x_train, y_train), batchsize=batch_size, shuffle=true)

    test_dl = DataLoader((x_test, y_test), batchsize=batch_size)

    md"""#### Creating DataLoaders for batches"""

end

begin

    ### Model ------------------------------

    function get_model()

        c = Chain(

            Dense(4,8,relu),

            Dense(8,3),

            softmax

        )

#       c = cu(c)

    end

    model = get_model()

​

    ### Loss ------------------------------

    loss(x,y) = Flux.Losses.logitbinarycrossentropy(model(x), y)

    train_losses = []

    test_losses = []

    train_acces = []

    test_acces = []

    ### Optimiser ------------------------------

    lr = 0.001

    opt = ADAM(lr, (0.9, 0.999))

​

    ### Callbacks ------------------------------

    function loss_all(data_loader)

        sum([loss(x, y) for (x,y) in data_loader]) / length(data_loader) 

    end

    function acc(data_loader)

        f(x) = Flux.onecold(cpu(x))

        acces = [sum(f(model(x)) .== f(y)) / size(x,2)  for (x,y) in data_loader]

        sum(acces) / length(data_loader)

    end

    callbacks = [

        () -> push!(train_losses, loss_all(train_dl)),

        () -> push!(test_losses, loss_all(test_dl)),

        () -> push!(train_acces, acc(train_dl)),

        () -> push!(test_acces, acc(test_dl)),

    ]

​

    # Training ------------------------------

    epochs = 30

    ps = Flux.params(model)

    @epochs epochs Flux.train!(loss, ps, train_dl, opt, cb = callbacks)

    @show train_loss = loss_all(train_dl)

    @show test_loss = loss_all(test_dl)

    @show train_acc = acc(train_dl)

    @show test_acc = acc(test_dl)

    md"""

    ### Training!

    **Train**   

      acc: $(train_acc)

      loss: $(train_loss)

    **Test**

      acc: $(test_acc)

      loss: $(test_loss)

    """

end

begin

    x_axis = 1:epochs * size(y_train,2)

    plot(x_axis, train_losses, label="Training loss",

        title="Loss", xaxis="epochs * data size")

    plot!(x_axis, test_losses, label="Testing loss")

end

begin

    plot(x_axis, train_acces, label="Training acc",

        title="Accuracy", xaxis="epochs * data size")

    plot!(x_axis, test_acces, label="Testing acc")

end

begin

    preds = round.(model(x_test))

    truths = y_test

    un_onehot(v) = v[1] == true ? 1 : v[2] == true ? 2 : 3

​

    preds = [un_onehot(v) for v in eachcol(preds)]

    truths = [un_onehot(v) for v in eachcol(truths)]

    conf_mat = zeros(3,3)

    for (y′, y) in zip(preds, truths)   

        if y == 1

            if y′ == 1

                conf_mat[1,1] += 1

            elseif y′ == 2

                conf_mat[1,2] += 1

            else

                conf_mat[1,3] += 1

            end

        elseif y == 2

            if y′ == 1

                conf_mat[2,1] += 1

            elseif y′ == 2

                conf_mat[2,2] += 1

            else

                conf_mat[2,3] += 1

            end

        else

            if y′ == 1

                conf_mat[3,1] += 1

            elseif y′ == 2

                conf_mat[3,2] += 1

            else

                conf_mat[3,3] += 1

            end

        end

    end

​

#   conf_mat = conf_mat ./ sum(conf_mat) # normalize

    label = "setosa \t:\t versicolor \t:\t virginica"

    heatmap(conf_mat, color=:plasma, aspect_ratio=1, xaxis=label, axis = nothing)

end