@ogrisel I tried picking your commit, but there are nasty merge conflicts in the cd_fast.c file.

Ah well. Fixed them. Sorry for the noise

Merge conflicts in generated C files are a matter of calling Cython again (but I guess you figured that out).

Can we close Olivier's old PR? Which one was it?

@larsmans #2980

Coverage remained the same when pulling 41a0eff on MechCoder:gil-enet into feb6eb1 on scikit-learn:master.

Coverage remained the same when pulling 8d92bf9 on MechCoder:gil-enet into 3a4edd0 on scikit-learn:master.

Coverage remained the same when pulling 59b2f50 on MechCoder:gil-enet into 3a4edd0 on scikit-learn:master.

@larsmans I'm facing trouble in testing the function outside the scikit-learn directory, in using the cblas.h file. I have a few questions, that I don't have any idea about, (First time I'm doing a setup.py file).

1. When scikit-learn is installed, does cblas get installed too? I suppose not because that is why the cblas folder is there in /src right?
2. If I need the cblas files externally, what do I need to do?
   This is my directory structure right now
   CyPractise
   • cblas
   • hello.pyx
   • setup.py

Contents of setup.py - https://gist.github.com/MechCoder/11349640
Contents of hello.pyx - https://gist.github.com/MechCoder/0cf4b7a55e1ac6d6c900
[I am still confused to what should be provided as arguments to the "include_dirs" and "libraries", arguments in setup.py]

I might not require it right now, but I might need it later, and I should not be as clueless as I am right now. Thanks.

1. No. The build system looks for a CBLAS implementation. If it doesn't find one, it builds the parts it needs from sklearn/src/cblas, which contains the reference implementation from ATLAS, and links that into the Cython modules that actually use CBLAS.
2. What you need is a working CBLAS implementation, e.g. sudo apt-get install libatlas-dev on Debian/Ubuntu (if memory serves me, that package got renamed a few times). That should put cblas.h in /usr/include and libcblas.so in /usr/lib. Note that BLAS alone is not enough: CBLAS is the C version, while libblas.so is the Fortran version with a hacky C API in blas.h.

(TODO for me, document this, I learned this by hacking scikit-learn for several years.)

@larsmans
Thanks for the quick reply.
Regarding point

1. By the same logic, won't just copy pasting the cblas directory anywhere else work? provided the setup.py file contains adequate information
2. It seems, I do have cblas.h in /usr/include and libcblas.so in /usr/lib ! . I'm convinced that I did something wrong in the setup.py file (https://gist.github.com/MechCoder/11349640) especially with the libraries and/or include_dirs keyword.

I plotted some benchmarks, and it does seem that releasing the GIL, does offer a considerable advantage generally.

Code - https://gist.github.com/MechCoder/b18c519ce018dc47b8b3

@agramfort @larsmans @ogrisel WDYT?

EDIT: the first one is with gil and the second one is after releasing it.

Would it be good to add these benchmarks to sklearn/benchmarks ?

Sorry but I don't understand these plots. What are the colors, y label, common ylim? What is with or without gil?

@agramfort

y label - is the time.
with gil - is the implementation in master
without gil - is the implementation in this branch after replacing the numpy calls with cblas
colors - different values of n_alphas, 5, 10, 100, 500

Basically I have tested for different values of n_alphas and n_l1_ratios.

I don't see the figure names on github so I just have to guess which is
which.

you should fix the random_state in make_regression to make the results
comparable.

if you do so then it should always be faster with higher number of alphas.
For now
it is still messy. Same is true for l1_ratios, the more you have the more
it should take time.

@agramfort. Umm. Surprisingly it does speed up for higher number of alphas. please run this small bit of code,

n_alphas = [5, 10, 100, 500]
X, y = make_regression(random_state=rng.RandomState(0))

clf = ElasticNetCV()
for alpha in n_alphas:
    t = time.time()
    clf.fit(X, y)
    times.append(time.time() - t)

print times

I'm guessing that this might be due to the fact that, Parallel has a considerable overhead when run for less computationally expensive operations?

yes it's the Parallel overhead. You should bench or mid size problems too
with something like n_samples = 500 and n_features = 2000 or more.

Please ignore the previous comment.

In master:
l1_ratio - 1
n_alphas - 5 : 0.7737178802490234
n_alphas - 10 : 1.0900750160217285
n_alphas - 15 3.704710006713867
n_alphas - 100 6.64526891708374

l1_ratio - 5
n_alphas - 5 6.46356987953186
n_alphas - 10 7.89543890953064
n_alphas - 15 22.287801027297974
n_alphas - 100 37.26467323303223

In this branch
l1_ratio - 1
n_alphas - 5 : 0.7684640884399414, ,
n_alphas - 10 : 1.130321979522705
n_alphas - 15 3.6571431159973145,
n_alphas - 100 6.659605979919434

l1_ratio - 5
n_alphas - 5 6.491890907287598
n_alphas - 10 7.760898113250732
n_alphas - 15 22.719208002090454
n_alphas - 100 37.510425090789795

Is the time gain enough. It also seems to slow down in certain cases.

There is no gain to expect just by releasing the GIL and your benchmarks seem to show this although it would need to be repeated several times and displayed as bar plots with error bars (for instance with the std deviation) to confirm this.

Releasing the GIL just makes it possible to use the threading backend of joblib without having concurrent threads lock one another.

To use the threading backend instead instead of the multiprocessing backend for the ElasticNetCV class, you can add backend='threading' to the Parallel() call in the LinearModelCV class of coordinate_descent.py.

@ogrisel Is that likely to give a speed gain? The documentation of Parallel tells that, "threading" is a very low-overhead backend but it suffers from the Python Global Interpreter Lock if the called function relies a lot on Python objects.

@ogrisel Is that likely to give a speed gain? The documentation of Parallel tells that, "threading" is a very low-overhead backend but it suffers from the Python Global Interpreter Lock if the called function relies a lot on Python objects.

Well this is precisely why we want to release the GIL in the speed critical part of the cython code of the ElasticNetCV class: to be able to use the threading backend and get rid of the multiprocessing overhead. How many cores do you have on your box? It would be interesting to check with n_jobs in [1, 2, 4, 8], both for master with multiprocessing and this branch with the threading backend enabled.

You also need to perform enough iterations of cv to be able to leverage the inner parallelization, e.g. cv=5 or cv=10 for instance.

+1 on @ogrisel 's comments. You have a chance to see a benefit in CV case
with threading.

@ogrisel , @agramfort I benched with cv = 10, for n_core = [1, 2, 4]. It seems that threading (releasing the GIL does have an advantage).

Multiprocess in this branch vs master (after releasing GIL)

Threading in this branch vs master (after releasing GIL)

Threading in this branch with multiprocessing in master

Do I get a go ahead to continue with the rest of this PR?

Is there a difference in memory consumption? Use a large dataset to see this, and maybe the memory-profiler.

I would expect more a difference in memory consumption than speed.

@ogrisel I pushed in a commit that releases the GIL for the multi-task variant? Do you mind having a quick look before I bench?

Coverage increased (+0.0%) when pulling 75b48cd on MechCoder:gil-enet into 662fe00 on scikit-learn:master.

@ogrisel For the Gram variant, after the minor changes :)
In this branch

In master

@GaelVaroquaux @ogrisel @agramfort

Some benchmarks for the multi-task variant. X = 10000 X 1000, y = 10000 X 3

In this branch

In master

Memory benefits:

In this branch

In master

I've updated the PR from [WIP] to [MRG]

Once my last comment has been taken into account, +1 for merging. Thanks for the contrib and the extensive benchmarks @MechCoder!

@ogrisel Can I add my name at the top pf the cd_fast.pyx file?

@MechCoder sure.

Can you please re-run the multitask threading benchmark to check the impact of this last optim?

yes. running it.

Coverage increased (+0.0%) when pulling 2c83678 on MechCoder:gil-enet into 662fe00 on scikit-learn:master.

@ogrisel It doesn't look like there is much difference. A slight improvement.
In this branch

In master

Ping @agramfort Please have a look :)

LGTM !

+1 for merge

@ogrisel shall I merge?

I just did :)

@ogrisel @agramfort Thanks a lot for your help. Learnt a lot from this.

@ogrisel @agramfort one of my gsoc goals, is to benchmark cyclic / random coordinate descent, and to test if it converges faster or not.

For cyclic descent, I need to permute the indices of the features once before every outer iteration. On the lines of this

for n_iter in range(max_iter):
    rng = np.random.RandomState(n_iter)
    f_shuffle = rng.permutation(n_features)
    for i in f_shuffle:
         .... so on

Sorry to be a noob, Since we have released the GIL and a numpy call might cause overhead, is there anything that would help me replace it with a C - call. thanks

No need to reinit a new RandomState instance at each iteration, you can just pass it as an argument to the cython function and call rng = check_random_state(self.random_state) in the body of the fit method of the parent python classes if not already done this way. This is a very generic pattern throughout the library.

Now as to answer you question about calling rng.permutation in a nogil block, you have two solutions:

• locally acquire the GIL just around the call to rng.permutation:

        with gil:
             f_shuffle = rng.permutation(n_features)

• reuse what @arjoly, @glouppe and @larsmans did to have a pure C, GIL free permutations in the random forests code: https://github.com/scikit-learn/scikit-learn/blob/master/sklearn/tree/_tree.pyx#L1090 (enot that this has the additional benefit of not allocating any new memory for the permuted array).

The first solution my introduce some significant lock contentions on very small problems, so ideally we should try to implement the GIL-free solution. That would probably involve refactoring the cython source of the project to factorize the pure-cython RNG out of the tree code to make it more reusable.

@ogrisel . I had a quick look at the Fisher-Yates algorithm and the tree code. Is the algo used a special adaption of the Fisher-Yates? Because I see comments like,

    # skip the CPU intensive evaluation of the impurity criterion for
    # features that were already detected as constant 

In that case, we might need to change it a bit for the linear models.

In tree code, there are specific changes to take into account constant features in a split. But I don't think you need that sort of think for linear model. I think what @ogrisel suggests is to factorize
the RNG (our_rand_r, rand_double and rand_int)

I think what @ogrisel suggests is to factorize the RNG (our_rand_r, rand_double and rand_int)

Yes exactly. And then implement your own Fisher-Yates loop in the stochastic CD loop using that refactored rand_int function.