pydyn is a small library for controlling dynamixel servomotors. It has been designed to be used by complete python beginners, while still allowing depths of customisation for power users. It requires minimal knowledge of the robotis motors for simple usage. One need only three lines of code to start detecting, loading and controlling the motors.

import pydyn
mset = pydyn.MotorSet()
mset.position += 10


The library is currently used by the team on scientific experiments and by students in university courses on robotics.

github: https://github.com/humm/pydyn
license: Open Science

PyPot has been developed by the FLOWERS team in the context of the poppy-project to make it easy and fast to control custom robots based on dynamixel motors. This framework provides different levels of abstraction corresponding to different types of use. More precisely, you can use PyPot to:

1. directly control robotis motors through a USB2serial device,
2. define the structure of your particular robot and control it through high-level commands,
3. define primitives and easily combine them to create complex behavior.

PyPot has been entirely written in Python to allow for fast development, easy deployment and quick scripting by non-necessary expert developers. It can also benefits from the scientific and machine learning libraries existing in Python. The serial communication is handled through the standard library and thus allows for rather high performance (10ms sensorimotor loop). It is currently used in our team to control Poppy, our 25Dof humanoid robot at 100Hz. It is crossed-platform and has been tested on Linux, Windows and Mac OS.

As the rest of the Poppy project, PyPot is open source and has been released  under an open source license GPL V3.  It comes with full documentation, samples and graphical tools for simple uses.

Check us on GitHub for more information! Feedback, bug report and contributions are welcomed!

Github: https://github.com/poppy-project/pypot

Documentation: http://poppy-project.github.io/pypot/

This repository provides an implementation of dynamical systems, function approximators, dynamical movement primitives, and black-box optimization with evolution strategies, in particular the optimization of the parameters of dynamical movement primitives.
This library may be useful for you if you:

1. are new to dynamical movement primitives and want to learn about them (see the tutorial in the doxygen documentation).
2. already know about dynamical movement primitives, but would rather use existing, tested code than brew it yourself.
3. want to do reinforcement learning/optimization of dynamical movement primitives.

Most submodules of this project are independent of all others, so if you don’t care about dynamical movement primitives, the following submodules can still easily be integrated in other code to perform some (hopefully) useful function:

1. functionapproximators : a module that defines a generic interface for function approximators, as well as several specific implementations (LWR, LWPR, iRFRLS, GMR)
2. dynamicalsystems : a module that defines a generic interface for dynamical systems, as well as several specific implementations (exponential, sigmoid, spring-damper)
3. bbo : implementation of some (rather simple) algorithms for the stochastic optimization of black-box cost functions

If you use this library in the context of experiments for a scientific paper, we would appreciate if you could cite this library in the paper as follows:

@MISC{stulp_dmpbbo,
    author = {Freek Stulp},
    title  = {{\tt DmpBbo} -- A C++ library for black-box optimization of 
                                                dynamical movement primitives.},
    year   = {2014},
    url    = {https://github.com/stulp/dmpbbo.git}
}

 

github: https://github.com/stulp/dmpbbo

This repository provides an unofficial update for the m3 software to control the meka robot at Ensta ParisTech. It improves performance, reliability and integration with newer systems.

github: https://github.com/ahoarau.mekabot

Intelligent Tutoring System (ITS) are computer environments designed to guide students in their learning. Through the proposal of different activities, it provides teaching experience, guidance and feedback to improve learning.

The FLOWERS team has developed several computational models of artificial curiosity and intrinsic motivation based on research on psychology that might have a great impact for ITS. Results showed that activities with intermediate levels of complexity, neither too easy nor too difficult but just a little more difficult that the current level, provide better teaching experiences.

B. Clement, D. Roy, P.-Y. Oudeyer, M. Lopes, Multi-Armed Bandits for Intelligent Tutoring Systems, Journal of Educational Data Mining (JEDM), 2015

website: https://github.com/flowersteam/kidlearn
license: dual-license model: GNU Affero GPL License v3 (AGPL3) and Commercial.

RLPark is a reinforcement learning framework in Java. RLPark includes learning algorithms, agent state representa- tions, reinforcement learning architectures, standard benchmark problems, communication interfaces for robots, a framework for running experiments on clusters, and real-time visual- ization using Zephyr.

RLPark has been used in more than a dozens of publications (see http://rlpark.github.com/publications.html for a list). Moreover, RLPark has been ported to C++ by Saminda Abeyruwan, a student of the University of Miami (United States of America).

website: http://rlpark.github.com
maturity: RLPark has been used for research since 2010.
license: Eclipse Public License – v1.0

Github: https://github.com/omangin/multimodal

A set of tools and experimental scripts used to achieve multimodal learning with nonnegative matrix factorization (NMF).

This code reproduces the experiments from the publication:

O. Mangin, P.Y. Oudeyer, Learning semantic components from sub symbolic multi modal perceptionJoint IEEE International Conference on Development and Learning and on Epigenetic Robotics (ICDL EpiRob), Osaka (Japan) (2013) (More information, bibtex)

Please consider citing this paper when re-using the code in scientific publications.

The NMF implementation used in this code is also available as third party code for the scikit-learn project.

Matlab code for the algorithms developped in the Flowers team for intrinsic motivation exploration by robots: SGIM (Socially Guided Exploration) and SAGG-RIAC. This code corresponds to the algorithms and works described in : Nguyen (2013), A Curious Robot Learner for Interactive Goal-Babbling : Strategically Choosing What, How, When and from Whom to Learn, PhD Thesis, INRIA, France.

Downloadable from http://nguyensmai.free.fr/publication/SGIM.zip
Website: http://nguyensmai.free.fr

Maturity: The algorithm SGIM has been used for several experimental setups. The core code for the algorithm will not change. However, examples with the experimental setups will be added.

Associated journal articles:

Active Choice of Teachers, Learning Strategies and Goals for a Socially Guided Intrinsic Motivation Learner
Sao Mai Nguyen ; Pierre-Yves Oudeyer Paladyn Journal of Bejavioral Robotics, Springer, 2012, 3 (3), pp. 136-146 

Socially Guided Intrinsic Motivation for Robot Learning of Motor Skills
Sao Mai Nguyen ; Pierre-Yves Oudeyer Autonomous Robots, Springer, 2014, 36 (3), pp. 273-294 

Matlab code for the algorithms developped in the Flowers team for learning from unlabeled instructions. This code allows a robot to learn a new task by interacting with a human, but without knowing beforehand the associated meaning the communicative signals of the human. The result is a Calibration-Free Human-Machine Interaction system. This code corresponds to the algorithms and works described in : Grizou, J., Iturrate, I., Montesano, L., Oudeyer, P. Y., & Lopes, M. (2014, July). Interactive learning from unlabeled instructions. In Conference on Uncertainty in Artificial Intelligence (UAI) 

Downloadable from: https://github.com/jgrizou/lfui and https://github.com/jgrizou/thesis_code
Website: http://jgrizou.com/

For more information please visit the following page: http://jgrizou.com/projects/thesis-defense/

Zephyr is a software to visualize numeric variables and data structure in real time and at different time scale. Zephyr is practical because it requires only minimal changes in the code: it uses Java reflexivity to automatically detect variables in the code to monitor and data structure with an associated dedicated view. Zephyr can easily be extended with new plugins because it is based on the popular Eclipse Rich Client Platform. Consequently, Zephyr takes advantage of an already existing and fully operational Eclipse plugins for many of its functionalities. Finally, Zephyr is distributed with a Java python virtual machine named Jython and a lisp implementation named Clojure.

Zephyr was started in fall 2009 in the RLAI group at the university of Alberta (Canada) when Thomas Degris was a postdoc in this group. Zephyr is still actively used by RLAI. Users include Adam White, Joseph Modayil and Patrick Pilarski from the University of Alberta. Zephyr has been registered on the Eclipse marketplace since October 2011.

website: http://zephyrplugins.github.com
license: Eclipse Public License

forest has been designed to be easy to use while ensuring data integrity. It features many ways to protect the tree data incorrect inputs. It also features coverage and history logging, ensuring that the data structure was correctly used during an experiment. Because the main goal of the authors of the library was to ensure that their scientific experiments were correct, some of the design choices led to an characteristically unpythonic API.

contact author: Fabien Benureau (fabien.benureau@inria.fr)
github: https://github.com/flowersteam/forest
license: Open Science