Wednesday, August 26, 2015

Curiosa intuición

Supongamos que un sello junto con un sobre cuestan 1,10€. Si sabemos que el sello cuesta 1€ más que el sobre, ¿cuánto vale el sobre?

Cuando hicieron una pregunta similar a esta estudiantes en Universidades de prestigio, un porcentaje muy elevado contestó que el sello costaba 1€ y sobre 10 céntimos.

Es fácil, ¿no?

Pues la verdad es que no tanto. Si el sobre costara 10 céntimos y el sello cuesta 1€ más, el sello costará 1,10€. Por tanto, el sello junto con el sobre costarán 1,20€ (10 céntimos más de lo que se indicaba).

El cerebro está diseñado para esforzarse lo mínimo, de esta forma ahorra energía. En este caso, llegamos de forma automática a una solución aparentemente tan sencilla que ni siquiera verificamos su validez.

Es lo que Daniel Kahneman en su libro Thinking, Fast and Slow detalla al diferenciar la parte intuitiva del cerebro (Sistema 1) de la parte racional pero perezosa (Sistema 2). La parte intuitiva del cerebro llega a una solución aparentemente tan sencilla, que ni siquiera la parte racional del cerebro se molesta en comprobar.

Por lo tanto, el hecho de llegar a conclusiones de forma inmediata, fácil e intuitiva, nos debe alertar para que hagamos una mínima comprobación. De esta forma podremos detectar si hemos sido "engañados" por nuestro cerebro.

Por cierto, el sello cuesta 1,05€ y el sobre 5 céntimos.

Wednesday, July 29, 2015

El pitch de Pixar

En el libro "To Sell is Human", Daniel Pink presenta una técnica para contar historias de forma efectiva.

Esta técnica se basa en la narrativa que comparten las películas de Pixar. El hecho de referirse a Pixar no es casualidad. Todas las películas de Pixar son un éxito en taquilla por lo que merece la pena analizar qué es lo que hacen bien. Según Emma Coats, guionista de Pixar, todas las historias siguen la misma estructura:

Érase una vez (Once upon a time there was) ...
Todos los días (Every day), ...
Un día (One day), ...
Debido a eso (Because of that), ...
Debido a eso (Because of that), ...
Hasta que por fin (Until finally), ...

Por ejemplo, podemos ver como el guión de la película Buscando a Nemo sigue esta estructura:

1. Érase una vez... un pez viudo, llamado Marlin, que era muy protector con su único hijo , Nemo.
2. Todos los días... Marlin advertía a Nemo de los peligros del océano y le imploraba que no nadara lejos.
3. Un día... en un acto de desafío, Nemo ignoró las advertencias de su padre y nadó en mar abierto.
4. Debido a eso... es capturado por un buceador y termina en la pecera de un dentista en Sydney.
5. Debido a eso... Marlin se embarca en un viaje para recuperar a Nemo, con la ayuda de otras criaturas del mar por el camino.
6. Hasta que por fin ... Marlin y Nemo se encuentran, vuelven y Nemo aprende que el amor depende de la confianza.

Según Daniel Pink, podemos usar esta misma estructura para contar nuestras propias ideas y proyectos de forma efectiva y diferente.

Thursday, May 21, 2015

Prueba empírica del problema de Monty Hall

El problema de Monty Hall es un problema matemático bien conocido (es.wikipedia.org/wiki/Problema_de_Monty_Hall).

En este post voy a mostrar un simple programa para los incrédulos que aún piensen que la solución no es correcta.

Este tipo de problema consiste en los siguiente:

En un concurso, nos muestran tres cajas, donde en una hay escondido un premio y las dos restantes están vacías.

El presentador pide que seleccionemos una caja. A continuación, de las restantes cajas, el presentador abre una de ellas, la abre y muestra que está vacía.

En ese momento nos pregunta si queremos cambiar de caja.

¿Qué responderías?

En el momento de tomar esta decisión, hay dos cajas cerradas y sabemos que en una de ellas está el premio. La intuición nos dice que la probabilidad de que el premio esté en nuestra caja es del 50%.
Por lo tanto, cambiemos o no de caja, la probabilidad de llevarnos el premio será del 50%.

Pero esto no es correcto. Si cambiamos de caja, la probabilidad de acertar es aproximadamente del 67%

Aparentemente no tiene sentido, ¿no?.

Si en el momento en el que tenemos que tomar la decisión de cambiar o no de caja, viniera una persona que no ha visto lo que ha sucedido y se pusiera en nuestro lugar, la probabilidad de que se llevara el premio en ese caso sí sería del 50%. ¿Cómo puede ser que si cambiamos de caja aumente la probabilidad de ganar el premio?

La respuesta es muy sencilla. Cuando tenemos las tres cajas, la probabilidad de que el premio se encuentre en la caja que hemos seleccionado es del 33% (1/3). Sin embargo, la probabilidad de que el premio se encuentre en alguna de las cajas que no hemos seleccionados es del 67% (2/3).

Cuando el presentador muestra una caja vacía, la probabilidad de que el premio esté en la caja que hemos seleccionado sigue siendo del 33% y la probabilidad de que el premio se encuentre en alguna de las cajas que no hemos seleccionado también sigue siendo del 67%. Pero ahora el resto de cajas que no hemos seleccionado es una, ya que el presentador ha abierto la otra. Por lo tanto, cambiar de caja hace que la probabilidad de llevarnos el premio pase del 33% al 67%.

La persona que viene de fuera no tiene tanta información, no sabe que antes había tres cajas y que el presentador ha abierto una de las cajas que no tenía el premio. Es esta información lo que hace que nuestra probabilidad de llevarnos el tiempo sea del 67% frente al 50% que tiene la persona que viene de fuera.

Una forma sencilla de ver esto, es imaginar que en vez de tres cajas, hay 1000 cajas. En este caso, igual que antes, seleccionamos una caja y el presentador, a continuación, abre 998 cajas mostrando que están vacías. En este momento estamos en el mismo caso que antes, tenemos dos cajas y en una está el premio. ¿Cambiarías ahora de caja?. Seguro que sí, ¿no? La probabilidad de haber seleccionado la caja con el premio a la primera de entre 1000 cajas, es bastante baja.

Para los incrédulos, aquí he hecho un programa en Java que simula este concurso y lo prueba:

import java.util.Random;

public class ChangeVariable {
  private boolean boxes[];
  
  private int boxWithTheBall;
  private int shownEmptyBox;
  private int boxSelectedByPerson;
  
  private Random rnd;
  
  public ChangeVariable(boolean changeBox) {
    rnd = new Random();
    
    start(changeBox);
  }
  
  private void putBallInBox() {
    boxWithTheBall = rnd.nextInt(3);
    boxes=new boolean[3];
    boxes[boxWithTheBall]=true;
  }
  
  private void showEmptyBox() {
    do {
      shownEmptyBox = rnd.nextInt(3);
    } while (
        shownEmptyBox==boxWithTheBall ||
        shownEmptyBox==boxSelectedByPerson);
  }
  
  private void selectBox() {
    boxSelectedByPerson = rnd.nextInt(3);
  }
  
  private void changeBox() {
    for (int i=0;i<3;i++) {
      if (i!=shownEmptyBox && i!=boxSelectedByPerson) {
        boxSelectedByPerson = i;
        break;
      }
    }
  }
  
  private boolean isGuessed() {
    return boxSelectedByPerson==boxWithTheBall;
  }
  
  private void start(boolean changeBox) {
    int iterations = 100000;
    int hits=0; 
    
    for (int i=0;i<iterations;i++) {
      
      // Put a ball in a box
      putBallInBox();
      
      // The person selects a box
      selectBox();
      
      // Show an empty box which
      // is not the selected by the person
      showEmptyBox();
      
      if (changeBox) {
        // The person changes the box
        changeBox();
      } 
      
      if (isGuessed()) hits++;      
      
    }
    
    System.out.println("Hits: "+(hits/(float)iterations));
  }
  
  public static void main(String args[]) {
    boolean changeBox = false;
    
    new ChangeVariable(changeBox);
  }
}

Cuando lo ejecutamos con changeBox=false (no cambiamos de caja), la probabilidad que sale será algo parecido a 0.333 que corresponde al 33% (1/3) que matemáticamente corresponde.

Sin embargo, cuando lo ejecutamos con changeBox=true (siempre cambiamos de caja), la probabilidad que sale será algo parecido a 0.666 que corresponde al 67% (2/3) que acabamos de ver.

Sunday, April 26, 2015

Encontrando gente con el mismo cumpleaños

Hace algunos meses escuché en un programa de Redes que la probabilidad de que en una fiesta haya dos personas que cumplan años el mismo día es bastante alta. A priori, esto choca un poco. Por lo general, de forma intuitiva, diríamos que esa probabilidad es bastante baja. El motivo podría ser que consideramos esa probabilidad similar a la de encontrar en una fiesta alguien que cumpla años el mismo día que nosotros. Sin embargo, ambas probabilidades no tienen nada que ver.

Para calcular la probabilidad de que en una fiesta de N personas existan dos personas que cumplan años el mismo día, podemos pensar en 365 vasos y N bolas colocadas en alguno de esos vasos al azar. La probabilidad es la misma que 1 menos la probabilidad de que en los 365 vasos haya como máximo una bola. Es decir, la probabilidad de que en algún vaso haya más de una bola (al menos dos personas con el mismo cumpleaños).

La probabilidad sería 1 - 365!/exp(365,n)*(365-n)!

En base a esta ecuación, en una fiesta con 20 personas, la probabilidad de que haya dos personas con el mismo cumpleaños es del 41% y en una fiesta con 50 personas, esta probabilidad es del 97%. Es decir, casi con total seguridad, en una fiesta medianamente grande, va a haber al menos dos personas que cumplen años el mismo día.

Por otro lado, la probabilidad de que cuando llegamos a una fiesta con N personas haya al menos una persona que cumpla años el mismo día que nosotros, se puede calcular como la probabilidad de que al colocar N bolas al azar en 365 vasos, no haya ninguna en el vaso donde está nuestra bola.

La probabilidad sería 1 - exp(364/365, n)

Por tanto, que en una fiesta con 20 personas haya alguien que cumpla años el mismo día que nosotros es sólo del 5%, mientras que en una fiesta con 50 personas es del 13%.

Friday, January 23, 2015

Cómo usar el plugin Database Migration de Grails

A continuación describiré una manera de trabajar con el plugin Migration de Grails basado en Liquibase que me resulta especialmente cómoda. La diferencia respecto a la del manual es que podemos seguir trabajando en local con el modo dbCreate=create-drop sin necesidad de tener en cuenta las migraciones hasta el momento del pase a Producción.

Supongamos que tenemos nuestro modelo de datos en local (con dbCreate=create-drop) y es la primera vez que se va a instalar en Producción. Lo primero que hacemos es detener la aplicación en local, y generar el changelog inicial de la siguiente forma:

grails dbm-generate-gorm-changelog changelog.groovy

Esto generará el fichero changelog.groovy en /grails-app/migrations

En este caso, al estar nuestro entorno local en modo create-drop, cuando se ejecuta este script se creará el esquema tal como refleje las clases del dominio en ese momento.

Para instalar por primera vez en Producción, simplemente haremos contra Producción grails prod dbm-update y se creará el mismo esquema de base de datos que tenemos en local.

Obviamente, en Producción dbCreate debe estar comentado porque queremos que el esquema se cree y actualice mediante changelogs y no de forma automática.

En este momento los esquemas en local y en Producción serán iguales.

Seguimos nuestros desarrollos en local, creando y modificando clases de dominio sin preocuparnos de nada, ya que estamos en modo create-drop.

Llegado el momento, decidimos migrar el esquema modificado a Producción. Lo que queremos es aplicar únicamente los cambios, por lo que tenemos que obtener en primer lugar el changelog de los cambios. Para ello, simplemente comentamos el dbCreate para que no se autogenere el esquema a partir del dominio, y borramos el esquema local mediante cualquier cliente de base de datos (el esquema debe quedar vacío, sin ninguna tabla).

Con estas premisas, ejecutamos en local grails dbm-update, asegurándonos que en grails-app/migrations está el changelog.groovy que se ejecutó en Producción. Esto hará que nuestro esquema local sea en ese momento idéntico al de Producción que queremos actualizar.

A continuación hacemos grails dbm-gorm-diff updates.groovy. Esto generará el changelog con las diferencias entre el modelo local (dominio) y el esquema copia de Producción, que será precisamente lo que haya que ejecutar en Producción.

Los cambios contenidos en el fichero que se acaba de generar grails-app/migrations/updates.groovy los copiamos en changelog.groovy y ejecutamos contra Producción grails prod dbm-update. Esto hará que se apliquen los cambios quedando Producción actualizado.

Por último, en local volvemos a descomentar dbCreate dejándolo de nuevo en modo create-drop para seguir trabajando de forma cómoda en local.