Keep the gradient flowing

The manifold module in scikit-learn is slowly progressing: the locally linear embedding implementation was finally merged along with some documentation.

I decided to test my new Locally Linear Embedding (LLE) implementation against a real dataset.

I've been working lately in improving the low-level API of the libsvm bindings in scikit-learn.

Today got merged some changes I made to function scipy.linalg.get_blas_funcs().

I've been working for some time on implementing a locally linear embedding algorithm for the upcoming manifold module in scikit-learn.

The guys behind pythonxy have been kind enough to add the latest scikit-learn as an additional plugin for their distribution.

The following algorithm computes the Least squares solution || Ax - b|| subject to the equality constrain Bx = d.

Profiling Python extensions has not been a pleasant experience for me, so I made my own package to do the job.

Yesterday was the scikit-learn coding sprint in Paris.

One thing I'd really like to see done in this Friday's scikit-learn sprint is to have full support for Python 3.

Update: a fast and stable norm was added to scipy.linalg in August 2011 and will be available in scipy 0.10 Last week I discussed with Gael how we should compute the euclidean norm of a vector a using SciPy.

I was last weekend in FOSDEM presenting scikits.learn (here are the slides I used at the Data Analytics Devroom).

Latest release of scikits.learn comes with an awesome collection of examples.

Based on the work of libsvm-dense by Ming-Wei Chang, Hsuan-Tien Lin, Ming-Hen Tsai, Chia-Hua Ho and Hsiang-Fu Yu I patched the libsvm distribution shipped with scikits.learn to allow setting weights for individual instances.

Highlights for this release: * New stochastic gradient descent module by Peter Prettenhofer * Improved svm module: memory efficiency, automatic class weights. * Wrap for liblinear's Multi-class SVC (option multi_class in LinearSVC) * New features and perf…

scikits.learn.svm now uses LibSVM-dense instead of LibSVM for some support vector machine related algorithms when input is a dense matrix.

For some time now I've been missing a function in scipy that exploits the triangular structure of a matrix to efficiently solve the associated system, so I decided to implement it by binding the LAPACK method "trtrs", which also checks for singularities a…

I've been working lately with Alexandre Gramfort coding the LARS algorithm in scikits.learn.

Las week took place in Paris the second scikits.learn sprint.

I recently added support for sparse matrices (as defined in scipy.sparse) in some classifiers of scikits.learn.

I often find myself debugging python C extensions from gdb, but usually some variables are hidden because aggressive optimizations that distutils sets by default.

One of the best things of spending summer in Paris: its parcs (here, with friends @ Parc Montsouris).

It is now possible (using the development version as of may 2010) to use Support Vector Machines with custom kernels in scikits.learn.

If your numpy installation uses system-wide BLAS libraries (this will most likely be the case unless you installed it through prebuilt windows binaries), you can retrieve this information at compile time to link python modules to BLAS.

Today I released a new version of the scikits.learn library for machine learning.

Suppose some given data points each belong to one of two classes, and the goal is to decide which class a new data point will be in.

LibSVM is a C++ library that implements several Support Vector Machine algorithms that are commonly used in machine learning.

Yesterday we had an extremely productive coding sprint for the scikits.learn.

Today I released the first public version of Scikit-Learn (release notes).

This week we created a sourceforge project to host our development of scikit-learn.

New job, new code, new city, new colleagues.

This week I arrived to the place where I will be working the following two years: Neurospin.

Nice thing about winter in Granada is, that even in the coldest days, the sky is always blue.

My new job is about managing an open source package for machine learning in Python.

I'm extremely glad that finally I am moving to Paris to work as part of the INRIA crew.

Google Summer of Code program is officially over.

I managed to overcome the overhead in ask() that arises when converting between symbol and integer representation of sentences in conjunctive normal.

Today I've been doing some speed improvements for the logic module.

This commit introduced a new module in sympy: the refine module.

The query module is finally in the main SymPy repository.

After some failed attempts, I just found how to change the language settings dynamically in django, and I thought it could be useful to someone.

Three months after I began to write sympy.queries, I feel it's about time to include it in sympy's trunk, so today I sent for review 4 patches that implement the complete query module.

The 0.6.5 release of SymPy is taking longer than expected because some bugs in the testing framework, so my query module is not merged into trunk (yet).

Last days I've been busy preparing the first public beta of SymPy 0.6.5.

Background: DPLL is the algorithm behind SymPy's implementation of logic.inference.satisfiable After reading the original papers by Davis & Putnam [1], I managed to implement a more efficient version of the DPLL algorithm.

After some hacking on the queries module, I finally got it right without the limitations of past versions.

The DIMACS CNF file format is used to define a Boolean expression, written in conjunctive normal form, that may be used as an example of the satisfiability problem.

Yesterday I finally merged the logic module in sympy's official master branch, and should be released together with SymPy 0.6.5.

Most annoying problem in my implementation of the query system is that it will not solve implications if the implicates are far away from each other.

I sent some patches to sympy-patches with an initial implementation of the query system.