07 - Clases y objetos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Clases y objetos\n",
    "\n",
    "Acá una explicación tomada de [Brilliant](https://brilliant.org/wiki/classes-oop/):\n",
    "\n",
    "> In object-oriented programming, a class is a blueprint for creating objects (a particular data structure), providing initial values for state (member variables or attributes), and implementations of behavior (member functions or methods).\n",
    "\n",
    "Acá una de [Wikipedia](https://simple.wikipedia.org/wiki/Class_(programming)):\n",
    "\n",
    "> A class is written by a programmer in a defined structure to create an object (computer science) in an object oriented programming language. It defines a set of properties and methods that are common to all objects of one type.\n",
    "\n",
    "Acá otra de [IIT Kanpur](http://www.iitk.ac.in/esc101/05Aug/tutorial/java/concepts/class.html):\n",
    "\n",
    "> A class is a blueprint that defines the variables and the methods common to all objects of a certain kind\n",
    "\n",
    "Ahora un ejemplo tomado de [Dummies.com](https://www.dummies.com/programming/java/understanding-classes-and-objects/)\n",
    "\n",
    "> A class is like a blueprint for a kind of house in a housing development. An object is like a particular house. The blueprint says things like “Each house’s living room has its own color paint.” A particular house has red paint, or white paint, or some other color paint.\n",
    "\n",
    "Honestamente, si nunca has tenido contacto con programación orientada a objetos, te recomiendo visitar todas las fuentes que cité, con media hora de lectura. mas los ejemplos y talleres que haremos en clase, sabrás todo lo necesario.\n",
    "\n",
    "Finalmente, acá te dejo un par de lecturas para entender un poco más a profundidad la programación orientada a objetos, todos los conceptos los usaremos en el curso:\n",
    "\n",
    "- [What is Object Oriented Programming? OOP Explained in Depth](https://www.educative.io/blog/object-oriented-programming)\n",
    "- [How to explain object-oriented programming concepts to a 6-year-old](https://www.freecodecamp.org/news/object-oriented-programming-concepts-21bb035f7260/)\n",
    "\n",
    "En esta ocasión vamos a partir de un caso práctico para usar programación orientada objetos. Usaremos el ejercicio de probabilidad de 2.2.14 de [Richard J Larsen and Morris L Marx: An Introduction to Mathematical Statistics and Its Applications](https://www.amazon.com/Introduction-Mathematical-Statistics-Its-Applications/dp/0321693949). El ejercicio dice lo siguiente:\n",
    "\n",
    "> A probability-minded despot offers a convicted murderer a final chance to gain his release. The prisoner is given twenty chips, ten white and ten black. All twenty are to be placed into two urns, according to any allocation scheme the prisoner wishes, with the one proviso being that each urn contain at least one chip. The executioner will then pick one of the two urns at random and from that urn, one chip at random. If the chip selected is white, the prisoner will be set free; if it is black, he “buys the farm.” Characterize the sample space describing the prisoner’s possible allocation options. (Intuitively, which allocation affords the prisoner the greatest chance of survival?)\n",
    "\n",
    "Es importante resaltar que el libro mencionado no tiene nada que ver con programación, pero me pareció un interesante ejercicio para mostrar cómo podemos sacar provecho de la programación orientada objetos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import itertools\n",
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modelar el problema utilizando OOP\n",
    "\n",
    "El primer elemento del que nos hablan son los `chips`, de los que sabemos únicamente su color; esta es la única propiedad importante, por lo que nos limitaremos a representar chips con un tipo `str`. \n",
    "\n",
    "Empecemos modelando el elemento más importante de todo el experimento: las urnas (`urn`). De cada urna sabemos lo siguiente:\n",
    "\n",
    "- Tiene un conjunto de `chips`.\n",
    "- Tiene un número definido de `chips` blancos.\n",
    "- Tiene un número definido de `chips` negros.\n",
    "- Hay una probabilidad de sacar blanco o negro de acuerdo al número de `chips` de cada color."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Urn:\n",
    "    \"\"\"A container of black and white chips.\n",
    "    \n",
    "    Args:\n",
    "        chips (list[str]): chips to put in the urn, must\n",
    "            be `\"white\"` or `\"black\"` only.\n",
    "        \n",
    "    Attributes:\n",
    "        num_chips (int): total number of chips\n",
    "        num_white_chips (int): number of white chips in urn.\n",
    "        num_black_chips (int): number of black chips in urn.\n",
    "        prob_white (float): probability of getting a white chip\n",
    "            out of the urn.\n",
    "        prob_black (float): probability of getting a black chip\n",
    "            out of the urn.\n",
    "            \n",
    "    \"\"\"\n",
    "    _VALID_CHIPS = frozenset([\"white\", \"black\"])\n",
    "    def __init__(self, chips):\n",
    "        if set(chips).union(self._VALID_CHIPS) != self._VALID_CHIPS:\n",
    "            msg = \"this urn only support {}, got {}\"\n",
    "            raise ValueError(msg.format(\n",
    "                self._VALID_CHIPS, set(chips)\n",
    "            ))\n",
    "            \n",
    "        self._chips = chips\n",
    "        random.shuffle(self._chips)\n",
    "        \n",
    "    def sample(self):\n",
    "        \"\"\"Returns a random chip from the urn. \"\"\"\n",
    "        return self._chips.pop()\n",
    "    \n",
    "    @property\n",
    "    def num_chips(self):\n",
    "        return len(self._chips)\n",
    "    \n",
    "    @property\n",
    "    def num_white_chips(self):\n",
    "        return Counter(self._chips)[\"white\"]\n",
    "    \n",
    "    @property\n",
    "    def num_black_chips(self):\n",
    "        return self.num_chips - self.num_white_chips\n",
    "\n",
    "    @property\n",
    "    def prob_white(self):\n",
    "        \"\"\"float: Returns the probability of taking a white chip. \"\"\"\n",
    "        return self.num_white_chips / self.num_chips\n",
    "\n",
    "    @property\n",
    "    def prob_black(self):\n",
    "        \"\"\"float: Returns the probability of taking a black chip. \"\"\"\n",
    "        return self.num_black_chips / self.num_chips\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"Urn({self.num_white_chips}W.{self.num_black_chips}B)\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hasta ahora no hemos ejecutado nada de código, lo único que hemos hecho es definir cuáles son los elementos que describen una urna (propiedades) y lo que se puede hacer con una de ellas (métodos). A continuación, crearemos una instancia (un objeto) de la clase `Urn` y extraeremos sus propiedades."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of chips in urn: 3\n",
      "Number of white chips in urn: 1\n",
      "Number of black chips in urn: 2\n",
      "Probability of randomly taking a white chip out: 0.3333333333333333\n",
      "Probability of randomly taking a black chip out: 0.6666666666666666\n"
     ]
    }
   ],
   "source": [
    "u = Urn([\"white\", \"black\", \"black\"])\n",
    "print(f\"Number of chips in urn: {u.num_chips}\")\n",
    "print(f\"Number of white chips in urn: {u.num_white_chips}\")\n",
    "print(f\"Number of black chips in urn: {u.num_black_chips}\")\n",
    "print(f\"Probability of randomly taking a white chip out: {u.prob_white}\")\n",
    "print(f\"Probability of randomly taking a black chip out: {u.prob_black}\")\n",
    "assert round(u.prob_white + u.prob_black ) == 1 # probabilities shuold sum up to one"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Miremos qué pasaría si intetáramos crear una urna con colores no válidos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "this urn only support frozenset({'white', 'black'}), got {'white', 'black', 'blue', 'pink'}",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-4-bbefbc73c1b2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mUrn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"pink\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"blue\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"white\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"black\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-2-e52493d8f262>\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, chips)\u001b[0m\n\u001b[1;32m     20\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mchips\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munion\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_VALID_CHIPS\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_VALID_CHIPS\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     21\u001b[0m             \u001b[0mmsg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"this urn only support {}, got {}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 22\u001b[0;31m             raise ValueError(msg.format(\n\u001b[0m\u001b[1;32m     23\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_VALID_CHIPS\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mchips\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     24\u001b[0m             ))\n",
      "\u001b[0;31mValueError\u001b[0m: this urn only support frozenset({'white', 'black'}), got {'white', 'black', 'blue', 'pink'}"
     ]
    }
   ],
   "source": [
    "Urn([\"pink\", \"blue\", \"white\", \"black\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "gracias a esto, podemos restringir bastante nuestro problema, para evitar incluir errores sin darnos cuenta. Piensa en qué pasaría si tratamos de utilizar un `chip` azul: los cálculos de probabilidad serían inválidos. \n",
    "\n",
    "¿Cómo sacar un element aleatoriamente de nuestra urna?\n",
    "\n",
    "Usar el método `sample`!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'white'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u.sample()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finalmente, la implementación del método `__repr__` nos permite imprimir nuestros objetos de una forma útil (trata eliminar ese método y mira el resultado de la siguiente línea):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Urn(0W.2B)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nota que hay un `chip` blanco menos en la urna comparando con el inicio.\n",
    "\n",
    "Ahora vamos a la parte más interesante del problema, vamos a modelar cómo luce una asignación de `chips` blancos y negros en las dos urnas planteadas. Recordemos que de una asignación, solo nos importa la probabilidad de salir libre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Allocation:\n",
    "    \"\"\"A distribution of allowed chips in two urns.\n",
    "    \n",
    "    Note:\n",
    "        The we enforce that all chips for the problem are\n",
    "        placed in one of the two urns.\n",
    "    \n",
    "    Args:\n",
    "        urn1 (Urn): An urn, it must have at least 1 chip.\n",
    "        urn2 (Urn): An urn, it must have at least 1 chip.\n",
    "        \n",
    "    Attributes:\n",
    "        prob_release (float): probability of release from a\n",
    "            given allocation of chips.\n",
    "            \n",
    "    \"\"\"\n",
    "    _TOTAL_WHITE_CHIPS = 10\n",
    "    _TOTAL_BLACK_CHIPS = 10\n",
    "    _ALL_CHIPS = (\n",
    "        [\"white\"] * _TOTAL_WHITE_CHIPS\n",
    "        + [\"black\"] * _TOTAL_BLACK_CHIPS\n",
    "    )\n",
    "    def __init__(self, urn1, urn2):\n",
    "        if not self._is_valid(urn1, urn2):\n",
    "            raise ValueError(f\"invalid allocation {urn1}, {urn2}\")\n",
    "        self._urn1 = urn1\n",
    "        self._urn2 = urn2\n",
    "\n",
    "    @classmethod\n",
    "    def make_random_allocation(cls):\n",
    "        \"\"\" This method allows you to create new random allocations. \"\"\"\n",
    "        total_in_urn1 = random.randrange(1, 20)\n",
    "        urn1 = Urn(random.sample(cls._ALL_CHIPS, total_in_urn1))\n",
    "        urn2 = Urn(\n",
    "            [\"white\"] * (cls._TOTAL_WHITE_CHIPS - urn1.num_white_chips)\n",
    "            + [\"black\"] * (cls._TOTAL_BLACK_CHIPS - urn1.num_black_chips)\n",
    "        )\n",
    "        return cls(urn1, urn2)\n",
    "\n",
    "    @property\n",
    "    def prob_release(self):\n",
    "        return 0.5 * (self._urn1.prob_white + self._urn2.prob_white)\n",
    "    \n",
    "    def _is_valid(self, urn1, urn2):\n",
    "        cond1 = urn1.num_chips >= 1 and urn2.num_chips >= 1\n",
    "        cond2 = urn1.num_white_chips + urn2.num_white_chips == self._TOTAL_WHITE_CHIPS\n",
    "        cond3 = urn1.num_black_chips + urn2.num_black_chips == self._TOTAL_BLACK_CHIPS\n",
    "        return cond1 and cond2 and cond3\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"Allocation({self._urn1}, {self._urn2})\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Acá utilizamos algo diferente: `@classmethod` . A diferencia de los demás métodos, este corresponde a uno de la clase y no de los objetos, suelen ser usados para crear objetos de la clase en que se definen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Allocation(Urn(6W.5B), Urn(4W.5B))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "allocation = Allocation.make_random_allocation()\n",
    "allocation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4949494949494949"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "allocation.prob_release"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con esta forma de modelar el problema, nos resulta bastante claro hacer una simulación, para extraer respuestas importantes para el problema planteado.\n",
    "\n",
    "**¿Cuál es la probabilidad de salir libre con asignación aleatoria?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def freedom_probability_of_random_allocation(num_trials):\n",
    "    return sum(\n",
    "        Allocation.make_random_allocation().prob_release\n",
    "        for _ in range(num_trials)\n",
    "    )/num_trials"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.49890640735747593"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "freedom_probability_of_random_allocation(10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**¿Qué asignación maximiza la probabilidad de salir libre?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def best_allocation():\n",
    "    best_allocation = Allocation.make_random_allocation()\n",
    "    for i, j in itertools.product(range(0, 10), repeat=2):\n",
    "        if 0 < i + j < 19:\n",
    "            num_white_in_urn1 = i\n",
    "            num_black_in_urn1 = j\n",
    "            num_white_in_urn2 = 10 - num_white_in_urn1\n",
    "            num_black_in_urn2 = 10 - num_black_in_urn1\n",
    "\n",
    "            urn1 = Urn(\n",
    "                [\"white\"] * num_white_in_urn1\n",
    "                + [\"black\"] * num_black_in_urn1\n",
    "            )\n",
    "            urn2 = Urn(\n",
    "                [\"white\"] * num_white_in_urn2\n",
    "                + [\"black\"] * num_black_in_urn2\n",
    "            )\n",
    "            allocation = Allocation(urn1, urn2)\n",
    "            if allocation.prob_release > best_allocation.prob_release:\n",
    "                best_allocation = allocation\n",
    "    return best_allocation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best allocation is Allocation(Urn(1W.0B), Urn(9W.10B)), with release probability of 0.7368421052631579\n"
     ]
    }
   ],
   "source": [
    "allocation = best_allocation()\n",
    "msg = \"Best allocation is {}, with release probability of {}\"\n",
    "print(msg.format(allocation, allocation.prob_release))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def approximate_best_allocation(num_trials):\n",
    "    best_allocation = Allocation.make_random_allocation()\n",
    "    for _ in range(num_trials):\n",
    "        num_white_in_urn1 = random.randint(0, 10)\n",
    "        num_black_in_urn1 = 10 - num_white_in_urn1\n",
    "        num_white_in_urn2 = 10 - num_white_in_urn1\n",
    "        num_black_in_urn2 = 10 - num_black_in_urn1\n",
    "        urn1 = Urn(\n",
    "            [\"white\"] * num_white_in_urn1\n",
    "            + [\"black\"] * num_black_in_urn1\n",
    "        )\n",
    "        urn2 = Urn(\n",
    "            [\"white\"] * num_white_in_urn2\n",
    "            + [\"black\"] * num_black_in_urn2\n",
    "        )\n",
    "        allocation = Allocation(urn1, urn2)\n",
    "        if allocation.prob_release > best_allocation.prob_release:\n",
    "            best_allocation = allocation\n",
    "    return best_allocation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Approximate best allocation is Allocation(Urn(4W.6B), Urn(6W.4B)), with release probability of 0.5\n"
     ]
    }
   ],
   "source": [
    "allocation = approximate_best_allocation(5000)\n",
    "msg = \"Approximate best allocation is {}, with release probability of {}\"\n",
    "print(msg.format(allocation, allocation.prob_release))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}