{ "cells": [ { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Visualization and Learning in Julia\n", "\n", "Tom Breloff\n", "\n", "https://github.com/tbreloff" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Outline\n", "- Background\n", "- Julia packages\n", "- Plots.jl\n", "- Fun with data" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## My background\n", "- BA Mathematics and Economics (U. of Rochester)\n", "- MS Mathematics (NYU Courant Institute)\n", "- Trader, researcher, quant, developer at several big banks and hedge funds, including one which I founded\n", "- High speed algorithmic arbitrage trading and market making\n", "- Machine learning and visualization enthusiast\n", "- Lifelong programmer (since learning BASIC in 4th grade)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Before Julia\n", "- Python and C/C++\n", "- MATLAB and Java (so many files!!)\n", "- Throughout the years: Mathematica, Go, R, C#, Javascript, Visual Basic/Excel, Lisp, Erlang, ..." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Things I like\n", "- Python\n", " - Solid packages\n", " - Easy to get stuff done\n", "- C/C++\n", " - Fast (when you put in the effort)\n", "- MATLAB\n", " - Great matrix operations\n", " - Easy visualizations\n", "- Java\n", " - Hmmm... \n", " ```\n", " public static boolean DoTheFunctionNamesReallyNeedToBeLongerThanThatMaryPoppinsSong() {\n", " return true; \n", " }```" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Why Julia?\n", "- Easy to code\n", "- Fast with little effort\n", "- Solid vector/matrix support, but more flexible\n", "- Macros and staged functions\n", "- so much more!\n", "\n", "(Slow clap...)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Julia's Package Ecosystem" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Top packages by stars\n", "Package | Github Stars | 2-week change | Type\n", "------ | -------- | ------------- | --------\n", "Gadfly\t| 732\t| 14 | Plotting\n", "IJulia | 732 | 11 | Workflow\n", "Mocha | 496 | 36 | Learning\n", "DataFrames | 230 | 12 | Data Structures\n", "PyCall | 204 | 4 | Language Wrapper\n", "JuMP | 182 | 5 | Optimization\n", "Escher | 135 | 10 | GUIs\n", "Optim | 131 | 4 | Optimization\n", "Morsel | 128 | -1 | Web (deprecated)\n", "Distributions | 125 | 7 | Statistics\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Recent trends\n", "Package | Github Stars | 2-week change | Type\n", "------ | -------- | ------------- | --------\n", "Mocha | 496 | 36 | Learning\n", "Gadfly | 732 | 14 | Plotting\n", "DataFrames | 230 | 12 | Data Structures\n", "IJulia | 732 | 11 | Workflow\n", "Escher | 135 | 10 | GUIs\n", "Interact| 102 | 8 | GUIs\n", "Distributions| 125 | 7 | Statistics\n", "Plots| 23 | 6 | Plotting\n", "Seismic| 7 | 6 | Plotting\n", "Immerse | 23 | 5 | Plotting\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Statistics and Learning in Julia\n", "- Stats (mostly in JuliaStats)\n", " - StatsBase\n", " - Distributions\n", " - DataFrames, DataArrays, NullableArrays\n", " - MultivariateStats, GLM\n", " - OnlineStats\n", " - many more...\n", " " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Statistics and Learning in Julia\n", "- Optimization (mostly in JuliaOpt)\n", " - MathProgBase\n", " - JuMP\n", " - Optim\n", " - Convex\n", " - NLOpt\n", " " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Statistics and Learning in Julia\n", "- Machine learning\n", " - Mocha\n", " - GeneticAlgorithms\n", " - Orchestra\n", " - TextAnalysis\n", " - Clustering\n", " - OnlineAI\n", " - many more..." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Visualization in Julia\n", "\n", "Lots of packages: Gadfly, PyPlot, Vega, Winston, UnicodePlots, Qwt, Bokeh, Immerse, GLPlot ... \n", "\n", "Strengths:\n", "- Interactive: Immerse, PyPlot, Qwt\n", "- Fast: GLPlot\n", "- Easy/concise: UnicodePlots, Winston, Qwt\n", "- Pretty: Gadfly, Vega, Bokeh\n", "- Native: Gadfly, Winston, UnicodePlots\n", "- Features: PyPlot\n", "\n", "Learning more than one or two packages is time consuming and impractical...\n", "\n", "### Why do I have to choose one?!?" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# What makes good code design?" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Good design: AbstractArray\n", "Many concrete array-types:\n", "- Dense arrays\n", "- Sparse arrays\n", "- Ranges\n", "- Distributed arrays\n", "- Shared arrays\n", "- GPU arrays\n", "- Custom data structures\n", "\n", "Common code is implemented once for AbstractArray, and all concrete types get the benefit." ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "5-element ScaryVec:\n", " 1 \n", " \"BOO!\"\n", " 3 \n", " 4 \n", " 5 " ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type ScaryVec <: AbstractArray{Int,1}\n", " boo::Int\n", " n::Int\n", " ScaryVec(n::Integer) = new(rand(1:n), n)\n", "end\n", "Base.size(sv::ScaryVec) = (sv.n,)\n", "Base.getindex(sv::ScaryVec, i::Integer) = (i == sv.boo ? \"BOO!\" : i)\n", "\n", "sv = ScaryVec(5)" ] }, { "cell_type": "code", "execution_count": 53, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "4-element Array{Int64,1}:\n", " 1\n", " 3\n", " 4\n", " 5" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "filter(x -> isa(x, Number), sv)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Good design: AbstractArray\n", "- Inheriting from AbstractArray gives you a lot \"for free\":\n", " - Iteration (`map`, `for x in ...`, `filter`, ...)\n", " - Operations\n", " - Printing\n", " - etc\n", "- Few methods to implement... only what's needed.\n", "- Abstractions put overlapping functionality in one place\n", " - Easy to code\n", " - Easy to maintain\n", "\n", "\n", "### Imagine if there were no AbstractArray..." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Gadfly : `____________` :: ScaryVector : AbstractArray\n", "\n", "Thinking of graphics packages as concrete types, we see that we have many different types, but no abstraction linking them together. " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Plots.jl\n", "### The AbstractArray of plotting..." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n" ] } ], "source": [ "# setup... choose Gadfly as the backend, set some session defaults\n", "using Plots\n", "gadfly()\n", "default(size=(600,500), legend=false)\n", "\n", "# create parametric functions\n", "fx(u) = 1.6sin(u)^3\n", "fy(u) = 0.3 + 1.5cos(u) - 0.6cos(2u) - 0.25cos(3u) - cos(4u)/8\n", "\n", "# plot and annotate\n", "p = plot(fx, fy, 0, 2π, line=(5,:darkred), xlim=(-2,2), ylim=(-2,2))\n", "annotate!(0, -0.15, text(\" I ♡\\nPlots\", 45, -0.1π, :darkred));" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", " \n", "\n", "\n", " \n", " -2\n", " -1\n", " 0\n", " 1\n", " 2\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " I ♡Plots\n", " \n", " \n", " \n", " \n", " -2\n", " -1\n", " 0\n", " 1\n", " 2\n", " \n", "\n", "\n", "\n", " \n", "\n", "\n" ], "text/html": [ "\n", "\n", "\n", " \n", "\n", "\n", " \n", " -2\n", " -1\n", " 0\n", " 1\n", " 2\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " I ♡Plots\n", " \n", " \n", " \n", " \n", " -2\n", " -1\n", " 0\n", " 1\n", " 2\n", " \n", "\n", "\n", "\n", " \n", "\n", "\n" ], "text/plain": [ "Compose.SVG(158.73015873015876,132.2751322751323,IOBuffer(data=UInt8[...], readable=true, writable=true, seekable=true, append=false, size=15959, maxsize=Inf, ptr=15960, mark=-1),nothing,\"fig-474a105cd7f04be2bee4332cccccbf89\",0,Compose.SVGPropertyFrame[],Dict{Type{T},Union{Compose.Property{P<:Compose.PropertyPrimitive},Void}}(),Dict{Compose.ClipPrimitive{P<:Compose.Point{XM<:Compose.Measure{S,T},YM<:Compose.Measure{S,T}}},AbstractString}(Compose.ClipPrimitive{Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}}([Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(5.506666666666661,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(1.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(157.73015873015876,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(1.0,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(157.73015873015876,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(126.64179894179898,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0)),Compose.Point{Compose.Measure{Compose.MeasureNil,Compose.MeasureNil},Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}}(Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(5.506666666666661,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0),Compose.Measure{Compose.MeasureNil,Compose.MeasureNil}(126.64179894179898,Compose.MeasureNil(),Compose.MeasureNil(),0.0,0.0))])=>\"fig-474a105cd7f04be2bee4332cccccbf89-element-5\"),Set{AbstractString}(),true,false,nothing,true,\"fig-474a105cd7f04be2bee4332cccccbf89-element-13\",false,13,AbstractString[\"/home/tom/.julia/v0.4/Gadfly/src/gadfly.js\"],Tuple{AbstractString,AbstractString}[(\"Snap.svg\",\"Snap\"),(\"Gadfly\",\"Gadfly\")],AbstractString[\"fig.select(\\\"#fig-474a105cd7f04be2bee4332cccccbf89-element-4\\\")\\n .init_gadfly();\"],false,:none)" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "image/svg+xml": [], "text/plain": [ "Plot{Plots.GadflyPackage() n=1}" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "p" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n", "(xmeta,ymeta) = (nothing,nothing)\n" ] } ], "source": [ "# use the same parametric functions to create a custom marker shape\n", "us = linspace(0, 2π, 100)\n", "heart = Shape([(fx(u), fy(u)) for u in us])\n", "\n", "# generate some data\n", "n = 50\n", "xy() = 4rand(2) - 2\n", "\n", "# add a title\n", "title!(\"Let me count the ways...\")\n", "\n", "# add a new series\n", "scatter!(1, z=1:n, marker=(heart,15,:reds))\n", "\n", "# animations!\n", "anim = Animation()\n", "for i in 1:n\n", " x, y = xy()\n", " \n", " # add to a series after creation\n", " push!(p, 2, x, y)\n", " \n", " # easy annotations\n", " annotate!(x, y, text(i))\n", " \n", " # save an animation frame\n", " frame(anim)\n", "end" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "INFO: Saved animation to /home/tom/.julia/v0.4/Plots/examples/meetup/iheartplots.gif\n" ] }, { "data": { "text/html": [ "\" />" ], "text/plain": [ "Plots.AnimatedGif(\"/home/tom/.julia/v0.4/Plots/examples/meetup/iheartplots.gif\")" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "gif(anim, \"iheartplots.gif\", fps=3)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# One problem...\n", "\n", "\n", "\n", "When the abstract comes after the concrete, it's a lot more work. Oops. Better late than never!!" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Fun with data - UCI Wine Quality Dataset\n", "\n", "\n", "P. Cortez, A. Cerdeira, F. Almeida, T. Matos and J. Reis. \n", "Modeling wine preferences by data mining from physicochemical properties. In Decision Support Systems, Elsevier, 47(4):547-553, 2009." ] }, { "cell_type": "markdown", "metadata": { "collapsed": true, "slideshow": { "slide_type": "slide" } }, "source": [ "# Come collaborate:\n", "- Plots.jl\n", "- OnlineStats.jl\n", "- OnlineAI.jl\n", "- LearnBase.jl\n", "- Unums.jl\n", "\n", "# or get in touch:\n", "- tom@breloff.com\n", "- https://github.com/tbreloff" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [] } ], "metadata": { "celltoolbar": "Slideshow", "kernelspec": { "display_name": "Julia 0.4.0", "language": "julia", "name": "julia-0.4" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", "version": "0.4.0" } }, "nbformat": 4, "nbformat_minor": 0 }