1-Intro-OT/RandomVector.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RandomVector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Résumé\n",
    "\n",
    "Dans ce document, nous présentons la classe `RandomVector`. Nous présentons en particulier le lien et les différences avec la classe `ComposedDistribution`. \n",
    "\n",
    "[Pour voir ce Jupyter Notebook, nous conseillons NBViewer.](https://nbviewer.org/github/mbaudin47/otsupgalilee-eleve/blob/master/1-Intro-OT/RandomVector.ipynb)\n",
    "\n",
    "## Références\n",
    "\n",
    "* http://openturns.github.io/openturns/master/user_manual/_generated/openturns.RandomVector.html\n",
    "* http://openturns.github.io/openturns/master/user_manual/_generated/openturns.ComposedDistribution.html\n",
    "* http://openturns.github.io/openturns/master/user_manual/_generated/openturns.CompositeDistribution.html\n",
    "* http://openturns.github.io/openturns/master/examples/probabilistic_modeling/composite_distribution.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "OpenTURNS fournit deux classes « associées » aux fonctions :\n",
    "\n",
    "* `ComposedDistribution` : une distribution multidimensionnelle définie par des marginales et une copule ;\n",
    "* `RandomVector` : un vecteur aléatoire.\n",
    "\n",
    "On peut créer un `RandomVector` de deux manières :\n",
    "\n",
    "* à partir d’une `Distribution` ;\n",
    "* l’application d’une fonction $g$ à un `RandomVector`.\n",
    "\n",
    "*Objectifs* :\n",
    "\n",
    "* comprendre le lien entre un `RandomVector` et une fonction ;\n",
    "* comprendre le rôle de la classe `RandomVector`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import openturns as ot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une `ComposedDistribution` est composée :\n",
    "* des marginales ;\n",
    "* une copule (par défaut, c’est la copule indépendante).\n",
    "\n",
    "Exemple : on considère trois variables gaussiennes indépendantes et on souhaite créer la distribution associée. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On commence par créer les marginales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "X0 = ot.Normal(0.0, 1.0)\n",
    "X1 = ot.Normal(0.0, 1.0)\n",
    "X2 = ot.Normal(0.0, 1.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puis on crée la loi jointe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputDistribution = ot.ComposedDistribution([X0, X1, X2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour créer un `RandomVector` à partir d’une distribution on utilise le constructeur suivant :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputRandomVector = ot.RandomVector(inputDistribution)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant, on va pouvoir lui appliquer une fonction $g$.\n",
    "\n",
    "\n",
    "Pour créer un `RandomVector` à partir d’une fonction $g$, il faut :\n",
    "* un `RandomVector` en entrée ;\n",
    "* une `Function` à appliquer sur l’entrée.\n",
    "\n",
    "Dans l'exemple suivant, on crée un `RandomVector` à partir d’un `RandomVector` et d’une fonction\n",
    "$g$. On commence par créer une fonction avec l'opérateur Python `def`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mySimulator(x):\n",
    "    y0 = x[0] + x[1] + x[2]\n",
    "    y1 = x[0] - x[1] * x[2]\n",
    "    y = [y0, y1]\n",
    "    return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puis on utilise les classes `PythonFunction` et `RandomVector` pour créer le vecteur de sortie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfunction = ot.PythonFunction(3, 2, mySimulator)\n",
    "outputRandomVector = ot.CompositeRandomVector(myfunction, inputRandomVector)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Points communs et différences entre `RandomVector` et `ComposedDistribution`\n",
    "\n",
    "Points communs entre `RandomVector` et `ComposedDistribution` :\n",
    "\n",
    "* la méthode `getSample` est commune aux deux classes.\n",
    "\n",
    "Différence entre `RandomVector` et `ComposedDistribution` :\n",
    "    \n",
    "- un `RandomVector` n’a pas de méthode pour évaluer sa PDF. En général, il faudrait avoir toute la distribution de $Y = g(\\boldsymbol{X})$ pour l’avoir. En général, lorsque $g$ est un code de calcul externe de type boîte\n",
    "noire, c’est très coûteux, voire impossible.\n",
    "- une `ComposedDistribution` dispose des méthodes pour évaluer la PDF, la CDF, les quantiles, etc... En d’autres termes, toute la distribution est connue. Exemple : la méthode `computeCDF`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deux cas particuliers de `RandomVector`\n",
    "\n",
    "* Cas 1 : Le `RandomVector` d’entrée a été construit à partir d’une\n",
    "`ComposedDistribution` qu’on peut récupérer grâce à la méthode\n",
    "`getDistribution`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<p>ComposedDistribution(Normal(mu = 0, sigma = 1), Normal(mu = 0, sigma = 1), Normal(mu = 0, sigma = 1), IndependentCopula(dimension = 3))</p>"
      ],
      "text/plain": [
       "class=ComposedDistribution name=ComposedDistribution dimension=3 copula=class=IndependentCopula name=IndependentCopula dimension=3 marginal[0]=class=Normal name=Normal dimension=1 mean=class=Point name=Unnamed dimension=1 values=[0] sigma=class=Point name=Unnamed dimension=1 values=[1] correlationMatrix=class=CorrelationMatrix dimension=1 implementation=class=MatrixImplementation name=Unnamed rows=1 columns=1 values=[1] marginal[1]=class=Normal name=Normal dimension=1 mean=class=Point name=Unnamed dimension=1 values=[0] sigma=class=Point name=Unnamed dimension=1 values=[1] correlationMatrix=class=CorrelationMatrix dimension=1 implementation=class=MatrixImplementation name=Unnamed rows=1 columns=1 values=[1] marginal[2]=class=Normal name=Normal dimension=1 mean=class=Point name=Unnamed dimension=1 values=[0] sigma=class=Point name=Unnamed dimension=1 values=[1] correlationMatrix=class=CorrelationMatrix dimension=1 implementation=class=MatrixImplementation name=Unnamed rows=1 columns=1 values=[1]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inputRandomVector.getDistribution()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Cas 2 : Le `RandomVector` de sortie a été construit à partir d'une fonction : la méthode `getDistribution` échoue, et c’est normal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Génère une exception\n",
    "# outputRandomVector.getDistribution()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 1 : une fonction à trois entrées\n",
    "\n",
    "Définir la fonction mySymbolicSimulator comme une `SymbolicFunction` implémentant la fonction suivante :\n",
    "$$\n",
    "\\begin{aligned}\n",
    "Y_1 &= X_1 + X_2 + X_3 \\\\\n",
    "Y_2 &= X_1 - X_2 X_3\n",
    "\\end{aligned}\n",
    "$$\n",
    "Comment créer le `RandomVector` associé ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 2 : quatre conversions\n",
    "\n",
    "Expérimenter les quatre conversions présentées ci-dessous :`\n",
    "1. `RandomVector` → `RandomVector`\n",
    "1. `Distribution` → `Distribution`\n",
    "1. `Distribution` → `RandomVector`\n",
    "1. `RandomVector` → `Distribution`\n",
    "\n",
    "**Questions**\n",
    "* Quelles sont les conversions possibles ?\n",
    "* Pourquoi certaines conversions sont elles impossibles ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 3 : composition de RandomVector\n",
    "\n",
    "On considère la fonction `mySimulator2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mySimulator2(x):\n",
    "    y0 = x[0] + x[1]\n",
    "    y1 = x[1] ** 2\n",
    "    y = [y0, y1]\n",
    "    return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questions**\n",
    "- Utiliser la classe `RandomVector` pour définir le vecteur aléatoire associé à la composition de la fonction `mySimulator` par la fonction `mySimulator2`, c’est à dire `Y = mySimulator2(mySimulator(X))`.\n",
    "- Utiliser la classe `ComposedFunction` pour définir la fonction `mySimulator3` créée par composition de `mySimulator2` et `mySimulator`. Puis créer le `RandomVector` associé à `mySimulator3`. Ici, on crée une fonction `mySimulator3(x) = mySimulator2(mySimulator(x)` puis on crée le `RandomVector` défini par `mySimulator3` et `inputRandomVector`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 4 :  la classe CompositeDistribution\n",
    "\n",
    "La classe `CompositeDistribution` permet de définir une distribution fondée sur l'application d'une fonction scalaire (de $\\mathbb{R}$ dans $\\mathbb{R}$) à une distribution unidimensionnelle. \n",
    "Considérons $X$ une variable aléatoire de loi $\\mathcal{L}_X$ et $g : \\mathbb{R} \\rightarrow \\mathbb{R}$ une fonction. On considère la variable aléatoire $Y$ définie par :\n",
    "$$\n",
    "Y = g(X).\n",
    "$$\n",
    "On note $\\mathcal{L}_Y$ la distribution de la variable $Y$ : la classe `CompositeDistribution` permet de définir la loi de $Y$. \n",
    "\n",
    "On considère la variable $X$ de loi uniforme entre 0 et 12. On considère la fonction $g$ définie par :\n",
    "$$\n",
    "g(X) = X^2\n",
    "$$\n",
    "pour $X \\in [0,12]$.\n",
    "\n",
    "**Questions**\n",
    "* Définir la variable `distributionX` associée à la loi de la variable $X$. Dessiner la densité de probabilité de la distribution.\n",
    "* Définir la fonction `maFonc` associée à la fonction $g$. Dessiner la fonction entre 0 et 12.\n",
    "* Utiliser la classe `CompositeDistribution` pour définir la distribution associée à $Y$. Dessiner cette distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}