Sistemas de recomendación comerciales

¿Te has preguntado alguna vez cómo funcionan esos enlaces en las tiendas online que te sugieren otros productos que "también te pueden gustar..."? Los motores de búsqueda y aprendizaje especializados en detectar ese tipo de sugerencias personalizadas a tus gustos se llaman sistemas de recomendación. Estos sistemas funcionan observando qué decisiones ha tomado cada usuario (tú mismo incluido) y conectándote con otros usuarios con un comportamiento parecido al tuyo.

Por ejemplo, FilmAffinity (en español) te permite comentar tus películas preferidas, y te crea una lista de recomendaciones de películas que no has visto y te podrían gustar. También te pone en contacto con otros usuarios con gustos similares y te deja ver cómo valoraron cada película.

En DirectedEdge han creado una demostración de su sistema que permite navegar por Wikipedia (en inglés) y te busca artículos relacionados con el que estás leyendo.

Aquí hay una lista de recommender systems comerciales. Si alguna vez construyes un servicio web y quieres añadirle un sistema de recomendación: busca, compara y contrata al mejor.

Automusic

done right. A software composer that creates pretty much good music.

http://www.miller-mccune.com/culture-society/triumph-of-the-cyborg-composer-8507/

Flow-Based Programming, the book

A book about design and programming techniques using a flow-based programming language.

PDF book

Online extracts

State of the art MIP solvers

"Leading-edge" Optimizadores para restricciones y programación entera - linear integer programming:

• CPLEX
• Gurobi
• Mosek
• GLPK
• CBC (Coin-OR)
• XPRESS
• lp_solve

Modelador en Java OptimJ (http://www.ateji.com/)

Microsoft Solver Foundation

5 intuiciones sobre la evolución

Ars technica -

Five essential things to know about evolution

Cinco detalles para entender la evolución de las especies que no todo el mundo acaba de comprender.

Diet planner software

KDiet Planner
http://www.betbyte.com/kdietscreenshots.htm

Un programa que calcula los parámetros de la dieta introducida a mano, con varios medidores de progreso y de dieta equilibrada

Some intuitions on Monads

Remember your first lesson in structured programming, when the teacher insisted there where 3 operations for program structure: the conditional (if), loop (while), and sequence (;) operators. Conditionals choose between two alternate control sequences; loops repeat a sequence; and 'sequence' itself defines the order in which simple operations are chained together.

Did you mutter to yourself then, "how can 'sequence' be an operator and not just, well, how the program is laid out in the file?" Well, fact is you really can think of sequence as an explicit operator. And monads are a way to overload that operator, in the OOP sense of operator overloading.

If you have defined a monad in a functional program, you can use it to build a sequence of operations, just like you would in an imperative program. But you can actually change the meaning of the composition in the sequence: every step of your program, the logic in the monad is activated and it decides how (and if) it should perform the next step.

See this example from Monads in Ruby (with nice syntax!):

def with_failable_rbinding(first_divisor)
    with_monad Failable do
        val1 =xx fdiv(2.0, first_divisor)
        val2 =xx fdiv(3.0, 1.0)
        val3 =xx fdiv(val1, val2)
        val3
    end
end

Here you have a do-block containing a sequence of divisions composed using the special monadic assignment =xx. Everything executed within the block is handled by the Failable monad, wich is programmed to return a special non-numeric Failure value when a division by 0 is performed:

puts fdiv_with_binding(1.0)
=> Success(0.666666666666667)

puts fdiv_with_binding(0.0)

=> Failure(cannot divide by zero)

For every side effect in traditional imperative programming (control of errors, concurrency, input/output, commit/rollback of the whole application state, non-determinism... and some more) you can get some specific logic added for it, anytime, for free, without any syntactic complexity other than the sequence operation. Better yet, you can change the allowed side effects without actually changing a single line of your imperative procedure, just by redefining the logic encapsulated in the monad that glues the statemens in the procedure together.

See some more of my intuitions on monads here.

The Automation WWW

Information technologies have two sides to their popularity:
- they are novel communication channels
- they allow for automation of repetitive tasks (either simple or complex)

While both have been used since the conception of electricity as a controlling signal, it's the arrival of the World Wide Web in the 90's that has really made clear to the general population the implications of information as a technological product.

The WWW primarily exploits the communication side of ITs, though. It still remains to be seen a similar popular-culture event that equally conveys the implications of the automation possibilities. People typically fail to grasp the impact that a massive mechanization of information tasks can have on society.

The only topics close to popular awareness are email spam and computer viruses/malware, but unfortunately the general population don't understand the inner workings of those phenomena; they only feel their nastiness, but not the reason why they are so prevalent.

When a mechanism appears that allows people to easily take advantage of computer automation, we'll see a second transformation of the Internet in a similar scale of what happened when the Web arrived. "Web 2.0" is on the right path with its focus on widgets and web-apps, but so far the most popular automatisms in this class are those that provide automatic notification to a group of acquaintances in the social relations graph (Facebook, Tweeter).

Recomendador wikipedia - Directed Edge Launches Recommender Engine Public Beta!

Recomendador de artículos de la Wikipedia.

It’s an exciting day for us at Directed Edge. Today we’re finally putting our Wikipedia-based technology preview out there for people to play with. Before you click over to it, here’s a little about what you’re looking at.

As our name implies, we’re graph theory nerds. We look at the roughly 60 million links between the 2.5 million English Wikipedia pages, and with a few extra cues from the content, figure out pages related to the current one and put that in a little box in the upper left (as evident from the image on our home page). In some cases, if we’re able to pick out what sort of page it is, we also drop in a second box with just other pages of the same type.

Google killer

Welcome the Google-killer overlord

I've just been given 20 invites to beta-test True Knowledge, a semantic search engine based on a logic knowledge base. I've been fairly impressed by its ability to utilize user-provided knowledge and its overall good usability, although I've also seen potential for great misdeed by malicious users.

It's mostly a cross between Google and Wikipedia: users provide "facts" about the world, that are stored in a logic format. The interface allows to ask questions that are translated to formal queries over the knowledge expert system, which uses limited reasoning to try and answer the question. This is all quite classic Artificial Intelligence, but the highlights are because of the easiness of use:

• if the query fails, it reverts to a classic keyword-based search. So the user is almost always given some relevant information.

• the process to add new facts is (almost) newbie friendly, which is something really hard to achieve in the dry world of AI

• there is a quality control/assesments of the facts by the users, so that assertions that don't make sense can be voted on and rejected by other users.

If you want to judge it for yourself, drop me a letter or leave a comment and I'll send you an invite on a FIFO basis.

Mónadas: intuiciones

En programación funcional:
- una Monad es un módulo funcional con estilo Inversion of Control. (Es decir, se pueden construir funciones que usan la mónada como parámetro, y la ejecución de la mónada llama a estas funciones en el orden adecuado).
- el type constructor M es el functor usado para construir expresiones del tipo monádico. (La "declaración" del tipo monádico).
- la unit function transforma un valor normal en un valor del tipo monádico (el "cuerpo" del constructor de tipo monádico).
- el método Bind (>>) de una mónada recibe argumentos, y una continuation. (Es decir, para construir la definición de la mónada tenemos que indicar cómo se combinan las funciones a las que hay que llamar, y para controlar ese flujo utilizamos un estilo de programación con continuations).

Considerando lenguajes como Nombre Verbo: Si en programación orientada a objetos los objetos son nombres (son una abstracción de un dato o conjunto de datos reutilizables), en funcional las mónadas se podrían considerar verbos (son abstracciones de computaciones reutilizables).

Me autocito de la Wikipedia:

Intuitively, the type constructor would correspond to a type declaration, the unit function takes the role of a constructor method in OOP, and the binding operation contains the logic necessary to execute its registered callbacks (the monadic functions).

Formally, a monad is constructed by defining two operations bind and return and a type constructor M that must fulfill several properties to allow the correct composition of monadic functions (i.e. functions that use values from the monad as their arguments). The return operation puts a value from a plain type into a monadic container of type M. The bind operation performs the reverse process, extracting the original value from the container and passing it to the associated next function in the pipeline.

Interfaces adaptativos: la exactitud, más importante que la consistencia

Intelligent user interface, AI, artificial intelligence, beyond Clippy

Two research articles on adaptive interfaces:
- the first one shows that accuracy is more important than predictability to achieve a useful interface.
- the second studies several alternative designs for adaptive interfaces, and finds a dedicated "smart menu" to be the best option.
---
Dos artículos sobre interfaces adaptativos:

- el primero indica que la precisión es importante
- el segundo estudia qué estructura adaptativa es más eficaz

Predictability and accuracy in adaptive user interfaces

We present a study that examines the relative effects of
predictability and accuracy on the usability of adaptive UIs.
Our results show that increasing predictability and accuracy
led to strongly improved satisfaction. Increasing accuracy
also resulted in improved performance and higher utilization
of the adaptive interface. Contrary to our expectations,
improvement in accuracy had a stronger effect on performance,
utilization and some satisfaction ratings than the improvement
in predictability.

Exploring the Design Space for Adaptive Graphical User Interfaces

...fast and largely mechanical
interactions caused users to pay more attention to the operational
properties of the interfaces. For example, in the
more complex and more slowly-paced interactions of the
first experiment, users were less concerned with distance
between the extra toolbar and the original location of the
adapted buttons but they frequently commented that they
appreciated that all relevant functionality was grouped in
one place, allowing them concentrate on the task rather
than on navigating the interface.
...it is surprising that Greenberg’s design proved
successful, since it drastically restructures the interface
after each adaptation. This result might be explained by
the very high complexity of the interface (a hierarchical
menu with over a thousand leaf elements), which prevented
the users from developing strong motor memory
for the location of different elements.

Spirit: Gramáticas flexibles en C++

Una extensión de la librería Boost para generar gramáticas compilables en C++.
Podría usarse para crear nuestro propagador de restricciones.

Introduction

A simple EBNF grammar snippet:

group ::= '(' expression ')'
factor ::= integer | group
term ::= factor (('*' factor) | ('/' factor))*
expression ::= term (('+' term) | ('-' term))*

is approximated using Spirit's facilities as seen in this code snippet:

group = '(' >> expression >> ')';
factor = integer | group;
term = factor >> *(('*' >> factor) | ('/' >> factor));
expression = term >> *(('+' >> term) | ('-' >> term));

Through the magic of expression templates, this is perfectly valid and executable C++ code. The production rule expression is in fact an object that has a member function parse that does the work given a source code written in the grammar that we have just declared. Yes, it's a calculator. We shall simplify for now by skipping the type declarations and the definition of the rule integer invoked by factor. The production rule expression in our grammar specification, traditionally called the start symbol, can recognize inputs such as:

e4Graph:

Librería BSD para almacenar en base de datos una estructura de grafo, de forma eficiente. Free software.

e4Graph Introduction

The e4Graph library enables your program to represent and manipulate graph-like data efficiently and to store this data persistently. The overhead for persistence is etremely low, so e4Graph is useful also for when you do not care about keeping the data around between runs of your program; you can use it purely as a data structure library, without concern for persistence.

The key benefit provided by e4Graph is that it frees you to think about your data structures and the relations between the various entities without worrying about how to build the data structure and how to efficiently store it. Your program accesses and manipulates the data according to the relationships it represents, and e4Graph takes care of how to represent the data efficiently and persistently. Data is loaded into the executing program on demand, as a connection from an already loaded item to an on-disk item is followed; this data loading step is transparent to your program, and in-memory storage is recovered automatically when the data is no longer accessible by your program. This allows e4Graph to efficiently manipulate data graphs whose sizes are several orders of magnitude larger than the machine's available memory.

CSPLib: archivo de problemas CSP de restricciones

Modelado de problemas de restricciones CSPs, biblioteca - colección - archivo.

CSPLib

: a problem library for constraints

Interactive fiction - compilador natural

comentarios de slashdot /. Incluye enlaces al IF Archive, y al nuevo lenguaje de programación de Infocom Inform 7, programable en lenguaje natural (casi).

Lost Infocom Games Discovered The IF Archive [ifarchive.org] has an extensive collection of these games, and there are several [tads.org] review [wurb.com] sites [ifreviews.org] that attempt to catalog and organize the archive. The IF community has long had rec.arts.int-fiction [google.com] and rec.games.int-fiction [google.com] at their center, though with the rise of blogs and web forums it has started to fragment some. This is fascinating not just for Infocom fans, but also for programmers. For example:

The
Deathbot Assembly Line is a room. "Here is the heart of the whole
operation, where your opponents are assembled fresh from scrap metal
and bits of old car." The dangerous robot is a thing in the Assembly
Line. "One dangerous robot looks ready to take you on!" A robotic head,
a drill arm, a needle arm, a crushing leg and a kicking leg are parts
of the dangerous robot.

That's source code.
Inform 7 has been out for a couple years, and I've been working
intimately with it for most of that time, but I'm still impressed.


Eventyr: Hackday Dojo

- Uso del entorno Inform 7 para crear un juego "interactivo" que recibe notificación de eventos desde sensores en el mundo real

Using the 5 minutes before we started to get an idea for the resources available we came up with the idea for generating a real-world interactive game using Inform 7 and the many different sensors that had been brought by Thom Hopper.

Roomba barata por internet en españa

Por 279€, iva y envio incluidos



Caracteristícas - Robot Roomba 530:

- Capacidad de limpieza de bordes: sigue las paredes y llega hasta los rincones para eliminar el polvo, la suciedad y los residuos
- Detecta la suciedad: detecta las áreas mas sucia y limpia más a fondo en esos lugares
- Sistema anti-enredos: no se atasca con los cables, flecos no bordes de las alfombras
- Funcionamento sencillo: tan sólo presione el botón "clean" y Roomba hace el resto
- Una aspiradora potente: dos cepillo contra rotantes y un sistema de aspiracion hacen que llegue hasta lo más profundo de las alfombras para eliminar la suciedad
- Inteligencia Robótica: limpia perfectamente todo el piso,debajo y alrededor de los muebles, y a lo largo de las paredes
- Cabezal de limpieza: se ajusta automáticamente para limpiar alfombras y suelos
- Evita las escaleras: detecta y evita automaticamente las escaleras y demás desniveles
- Navegación inteligente: la pared virtual incluida permite dividir espacios grandes para optimizar la limpieza
- Siempre lista para usarse: Roomba es capaz de acudir a la base de carga para recargarse de forma automática
- Robot Roomba 560 incluye: 1 batería, 1 base de carga automática, 1 filtro, 2 pared virtual

2 solvers de restricciones en Python

El de Gustavo Niemeyer:

python-constraint - Labix

python-constraint is a Python module offering solvers for Constraint Solving Problems (CSPs) over finite domains in simple and pure Python. CSP is class of problems which may be represented in terms of variables (a, b, ...), domains (a in [1, 2, 3], ...), and constraints (a < b, ...).



El de Logilab:

logilab-constraint (a constraint satisfaction problem solver written in 100% pure Python) (elo)

The constraint package is a constraint satisfaction problem solver written in 100% pure Python. The implementation uses constraint propagation algorithms. Constraints and Domain implementations are provided to work with finite domains and finite intervals. It should be fairly easy to add new kind of domains such as finite integer domains, together with specialized constraints.

Google publica un API de cloud computing ,para crear aplicaciones online masivas

El motor perfecto (y en Python) para construir el planificador de recetas "qué comemos hoy?" en el que llevo tiempo pensando.

Combinado con python-constraint, el solver escrito en python puro, no tengo que crear nada de infraestructura - sólo la lógica del problema que quiero resolver.


What Is Google App Engine? - Google App Engine - Google Code

Google App Engine makes it easy to build an application that runs
reliably, even under heavy load and with large amounts of data. The
environment includes the following features:

• dynamic web serving, with full support for common web technologies
• persistent storage with queries, sorting and transactions
• automatic scaling and load balancing
• APIs for authenticating users and sending email using Google Accounts
• a fully featured local development environment that simulates Google App Engine on your computer

Google App Engine applications are implemented using the Python programming language. The runtime environment includes the full Python language and most of the Python standard library.

Although Python is currently the only language supported by Google
App Engine, we look forward to supporting more languages in the future.

python-constraint - Labix

python-constraint is a Python module offering solvers for Constraint Solving Problems (CSPs) over finite domains in simple and pure Python. CSP is class of problems which may be represented in terms of variables (a, b, ...), domains (a in [1, 2, 3], ...), and constraints (a <>, ...).

En minería de datos, cuanto más datos mejor

En el problema de recomendación de películas, un algoritmo simple con más datos funcionó mejor que uno con un algoritmo más potente.

Data mining.

Datawocky: More data usually beats better algorithms

Different student teams in my class adopted different approaches to
the problem, using both published algorithms and novel ideas. Of these,
the results from two of the teams illustrate a broader point. Team A
came up with a very sophisticated algorithm using the Netflix data.
Team B used a very simple algorithm, but they added in additional data
beyond the Netflix set: information about movie genres from the Internet Movie Database (IMDB). Guess which team did better?

Team B got much better results, close to the best results on the
Netflix leaderboard!! I'm really happy for them, and they're going to
tune their algorithm and take a crack at the grand prize. But the
bigger point is, adding more, independent data usually beats out
designing ever-better algorithms to analyze an existing data set. I'm
often suprised that many people in the business, and even in academia,
don't realize this.