Lofkin

I would suggest either using this: https://github.com/yhat/ggplot

or this : https://github.com/bokeh/bokeh/pulse

So Julia then :)

Numba for python also has a no copies vectorization mode.

Personally I'm tempted to make the switch to Julia, but slow higher order functions, high churn in the core data infrastructure and no Pymc 3 are keeping me on pydata for a bit longer. I have numba to hold me over.

For stats plotting in python: https://github.com/mwaskom/seaborn https://github.com/yhat/ggplot

For stats plotting and web apps in python: https://github.com/bokeh/bokeh

For calling r libraries in python: https://pypi.python.org/pypi/rpy2

For out of core datasets in python: https://github.com/blaze/dask https://github.com/blaze/blaze

What don't you like about python? Just curious.

There is this for HMC, NUTS gibbs etc : https://github.com/JuliaStats/Lora.jl

But its not ready to use yet it think.

Where do you see that researchers are posting new code in julia?

Exactly!

Actually many more general constructs like lists and class definitions are on the roadmap or in open PRs.

Actually list support in numba is WIP

Congrats! Looking forward to additional work on the already amazing pydata stack. Thanks for all your contributions to the community!

For interactive exploration of huge and out of core datasets, python Blaze/Dask has data manipulation with OOC parallel dataframes , and python Bokeh has interactive webGL and downsampling for visualization for said dataframe.

http://blaze.pydata.org/en/latest/ http://bokeh.pydata.org/en/latest/ http://dask.pydata.org/en/latest/

Unless you can help here, I see alot of pre coded models and older samplers, but nothing with a flexible JIT for user extensible variab;es and autodiff for newer HMC and NUTS type samplers. Exception being STAN, but that is its own C++ modeling language, can't talk to R functions , is more verbose than PYMC 3 and doesn't do discrete variables (unlike pymc3).

I was wondering this also

R has no native bayesian library like Pymc 3 (Must use stan which is c++). Also Python is better for ad hoc and agent based modeling and for out of core data with blaze and dask.

So no, R is not ahead in everything.

Great comment.

BTW, you can make interactive visualizations in pure python with bokeh: http://bokeh.pydata.org/en/latest/

Also with Blaze, you can use Pandas (or even Dplyr) syntax in python to query Hive, Spark and other large stores. http://blaze.pydata.org/en/latest/

AOT compilation is in the works. Also you might have been using features that numba didn't support yet. They just added more numpy ops, array allocation and vector ops, so your code might be working now.

Just use numba and get fortran like performance by writing in python.

Try converting to a numpy array, executing the operations and converting back to pandas.

More details here: http://pandas.pydata.org/pandas-docs/version/0.16.2/enhancin...

Also they recently added support for array expressions and allocation so you should upgrade if you haven't already.

Yes, python is not the future...but no, Julia and Python's Numba is just as fast as FORTRAN.

He missed a critical option: you can write those loops in python and JIT them to C fast LLVM with numba: https://github.com/numba/numba

For huge datasets, Python has distributed and out of core data structures: http://dask.pydata.org/en/latest/ https://github.com/ContinuumIO/blaze

This is pretty unique, and works better than spark for out of core on one machine...(and easier to set up.)

For stats not in the statsmodels and scikitlearn packages, you can easily whip up the bayesian generalization in pymc3.

Then if there is another R package you need, you can use Rpy2 to call it.

Not sure if this would be relevant to your usecase.

With Pymc3, you can code a bayesian generalization of most of those packages pretty easily. For bayesian models, it is easier than calling into C++ with stan in R.

For everything else, one can call arbitrary R packages with Rpy2, albeit with clunkier syntax.

For agent based modeling, there is no comparison. Python with its better and faster class system and Numba is in another league.

Finally python has distributed and out of core lists, arrays and dataframes: http://dask.pydata.org/en/latest/

You forgot python, with package: (similar in that R needs parallel packages): http://matthewrocklin.com/blog/work/2015/06/26/Complex-Graph...

Awesome!

It is already possible to some degree: https://github.com/JuliaLang/julia/issues/9973

More robust support starts with package precompilation which is slated to go into 0.4

https://github.com/JuliaLang/julia/pull/11426

You clearly haven't used pythons major data science packages.

Scikitlearn and statsmodels are known as being specifically easy to use with a uniform API that disparate R packages lack(though this is somewhat fixed with caret).

Further, for bayesian inference, Pymc 3 is more powerful and concise than training a model in stan.

Definitely.

Take a look at julia!

What is missing? If its something like shiny, Julia is well on way to obviating that problem: https://shashi.github.io/Escher.jl/