{ "cells": [ { "cell_type": "markdown", "source": [ "# Univariate Probability Spaces\n", "## Discrete Domains & Distributions\n", "\n", "### Definition\n", "Let us create a probability distribution of an experiment that simulates a die. In order to do so, we create a subtype of the [jpt.distributions.univariate.Integer](../autoapi/jpt/distributions/univariate/index.html#jpt.distributions.univariate.Integer) class with the range of values that is typical to a fair dice, namely $\\{1, ..., 6\\}$:" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } }, { "cell_type": "code", "execution_count": 24, "outputs": [ { "data": { "text/plain": "jpt.distributions.univariate.Die" }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy as np\n", "\n", "from jpt.distributions import IntegerType\n", "\n", "Die = IntegerType('Die', lmin=1, lmax=6)\n", "Die" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "markdown", "source": [ "[jpt.distributions.IntegerType](../autoapi/jpt/distributions/univariate/index.html#jpt.distributions.univariate.IntegerType) is function that dynamically creates a subclass of ``Integer`` with the passed string as its name and configures it with the respective range of integer values given by its lower and upper bounds passed as ``lmin`` and ``lmax`` arguments, respectively.\n", "\n", "We can create a specific distribution over these possible outcomes of a toss by instantiating the newly created class and setting the parameters of the distribution object. For example, we create the distribution of a fair dice by assigning all values the uniform distribution and plot it in diagram:" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } }, { "cell_type": "code", "execution_count": 25, "outputs": [ { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fair_die = Die()\n", "fair_die.set([1 / 6] * 6)\n", "fair_die.plot(view=True)" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "markdown", "source": [ "We can also compute the moments of the distribution like expectation and variance:" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } }, { "cell_type": "code", "execution_count": 26, "outputs": [ { "data": { "text/plain": "3.5" }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fair_die.expectation()" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "code", "execution_count": 27, "outputs": [ { "data": { "text/plain": "2.9166666666666665" }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fair_die.variance()" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "markdown", "source": [ "We can query for the probability of specific events, e.g. the probability that the result of a dice will be ``1``," ], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } }, { "cell_type": "code", "execution_count": 28, "outputs": [ { "data": { "text/plain": "0.16666666666666666" }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fair_die.p(1)" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "markdown", "source": [ "or that the result will be greater than ``3``" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } }, { "cell_type": "code", "execution_count": 29, "outputs": [ { "data": { "text/plain": "0.5" }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fair_die.p({4, 5, 6})" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "markdown", "source": [ "The most probable events can be obtained from" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } }, { "cell_type": "code", "execution_count": 30, "outputs": [ { "data": { "text/plain": "(0.16666666666666666, {1, 2, 3, 4, 5, 6})" }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fair_die.mpe()" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "markdown", "source": [ "which are, of course, all values in the uniform distribution at hand." ], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } }, { "cell_type": "markdown", "source": [ "### Manipulating Distributions\n", "\n", "We can manipulate an integer distribution by \"cropping\" it to a selection of allowed values. All other value will be assigned 0 probability and the remaining values' probability mass gets adjusted proportionally:\n" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } }, { "cell_type": "code", "execution_count": 31, "outputs": [ { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "biased_dice = fair_die.crop({1, 2, 3})\n", "biased_dice.plot(view=True)" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "markdown", "source": [ "Note that the original distribution has remained untouched by this operation:" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } }, { "cell_type": "code", "execution_count": 32, "outputs": [ { "data": { "text/plain": "" }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fair_die\n" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "markdown", "source": [ "### Learning Distributions from Data\n", "\n", "We can use the instantiated object for conducting experiments with the distribution using its [sample()](../autoapi/jpt/distributions/univariate/index.html#jpt.distributions.univariate.Distribution.sample) method:" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } }, { "cell_type": "code", "execution_count": 33, "outputs": [ { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from matplotlib import pyplot as plt\n", "data = list(fair_die.sample(1000))\n", "plt.hist(data)\n", "plt.show()" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "markdown", "source": [ "The parameters of a distribution can be learnt from data using its ``fit()`` method:" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } }, { "cell_type": "markdown", "source": [], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } }, { "cell_type": "code", "execution_count": 34, "outputs": [ { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "learnt_die = Die()\n", "learnt_die.fit(np.array(data))\n", "learnt_die.plot(view=True)" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "markdown", "source": [ "## Continuous Domains & Distributions\n", "\n", "The ``pyjpt`` package provides means for representing and acquiring probabilty distributions of any arbitrary shape over continuous variable domains. As the probability of an event is defined as the area under the probability density function (PDF), single scalar values of variables have 0 probability mass in continuous probability spaces. Therefore, events with non-zero probability must be specified by means of intervals, i.e. continuous sets in $\\mathds{R}$.\n", "\n", "### Real-valued Sets\n", "\n", "``pyjpt`` implements real-valued interval calculus in the [jpt.base.intervals](../autoapi/jpt/base/intervals/index.html) package. Intervals can be represented by instances of the [jpt.base.intervals.ContinuousSet](../autoapi/jpt/base/intervals/index.html#jpt.base.intervals.ContinuousSet) class:" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } }, { "cell_type": "code", "execution_count": 35, "outputs": [ { "data": { "text/plain": "(, )" }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from jpt.base.intervals import ContinuousSet\n", "i1 = ContinuousSet(0, 1)\n", "i2 = ContinuousSet.parse(']2,inf[')\n", "i1, i2" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "markdown", "source": [ "The ``ContinuousSet`` class supports both closed, open, and half-open intervals. We can use the [sample()](../autoapi/jpt/base/intervals/index.html#jpt.base.intervals.ContinuousSet.sample) method to draw random samples from the interval," ], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } }, { "cell_type": "code", "execution_count": 36, "outputs": [ { "data": { "text/plain": "array([0.24176175, 0.02029824, 0.61214159, 0.68656659, 0.51836989,\n 0.53758937, 0.62040549, 0.86333733, 0.44272855, 0.08339961])" }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "i1.sample(10)" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "markdown", "source": [ "and apply the common set operations like [union()](../autoapi/jpt/base/intervals/index.html#jpt.base.intervals.ContinuousSet.union), [intersection()](../autoapi/jpt/base/intervals/index.html#jpt.base.intervals.ContinuousSet.intersection) or [difference()](../autoapi/jpt/base/intervals/index.html#jpt.base.intervals.ContinuousSet.difference):" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } }, { "cell_type": "code", "execution_count": 37, "outputs": [ { "data": { "text/plain": "" }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "i1.intersection(ContinuousSet(.25, .75))" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "code", "execution_count": 38, "outputs": [ { "data": { "text/plain": "" }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from jpt.base.intervals import EXC\n", "\n", "i1.difference(ContinuousSet(.75, np.inf, right=EXC))" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "code", "execution_count": 39, "outputs": [ { "data": { "text/plain": "; ]>" }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "i3 = i1.union(i2)\n", "i3" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "markdown", "source": [ "Note that, in the latter case, the result of the union operation is a [RealSet](../autoapi/jpt/base/intervals/index.html#jpt.base.intervals.RealSet) instance. ``RealSet``s are disjunctions of discontiguous ``ContinuousSet``s and provide the same operational protocol as regular sets." ], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } }, { "cell_type": "code", "execution_count": 40, "outputs": [ { "data": { "text/plain": "(True, False, 1)" }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ ".5 in i3, 1.5 in i3, i3.contains_interval(ContinuousSet.parse('[.5,.6]'))" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "markdown", "source": [], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } }, { "cell_type": "markdown", "source": [ "## Symbolic Domains & Distributions" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } }, { "cell_type": "code", "execution_count": 41, "outputs": [ { "data": { "text/plain": "jpt.distributions.univariate.Coin" }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from jpt.distributions import SymbolicType\n", "\n", "Coin = SymbolicType('Coin', labels=['Head', 'Tail'])\n", "Coin" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "code", "execution_count": 42, "outputs": [ { "data": { "text/plain": "
", "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAUm0lEQVR4nO3df7RdZX3n8fcnAfwFQoR0Og3hR2tAouNYvAZGpyOzYCRQG6R1SWIV6aBZtUWmSu2ggMNQbEGm1lGwllqGQqdSaqdjZChoK1m2HYUEEUZ+mkUVEkBCQGyMliDf+ePsxJPLvfmhd+c8N3m/1sri7L2f85xvbh7u5z57P3vfVBWSJLVmxqgLkCRpIgaUJKlJBpQkqUkGlCSpSQaUJKlJBpQkqUkGlHZZST6R5Lwp6uugJOuTzOy2lyd5+1T03fX310neNlX97cDnXpjksSSP9ND3lH39tXuK90FpOkryDeBfAE8DPwDuAq4CLq+qZ36Evt5eVX+zA+9ZDvxpVX1yRz6re+/5wIur6i07+t6plOQg4F7g4Kp6dJI2LwQuAH4ReBHwLeCzwIVV9djOqlW7J2dQms5+oar2AQ4GLgL+M/DHU/0hSfaY6j4bcRCwbivhtBfwt8BLgYXAC4F/A6wDFuysIrX7MqA07VXVk1W1DDgFeFuSlwEkuTLJhd3rA5Jcl+TbSR5P8ndJZiS5msE36s92p/B+K8khSSrJ6UkeAL4wtG84rH4myS1JvpPkM0le1H3WMUlWD9eY5BtJjkuyEHg/cEr3ebd3xzefMuzqOjfJN5M8muSqJPt2xzbV8bYkD3Sn586Z7GuTZN/u/Wu7/s7t+j8O+DzwU10dV07w9lO7r83JVXVXVT1TVY9W1W9X1fVd/0d0tX87yZ1JFg199vDX/5gkq5Oc1f2dHk7yK9v3L6zdlQGlXUZV3QKsBn5ugsNndcdmMzg1+P7BW+qtwAMMZmN7V9WHht7zWuAI4PhJPvJU4D8C/5LBqcaPbkeNNwC/A/x593n/eoJmp3V//j3w08DewKXj2vxb4HDgWOADSY6Y5CM/Buzb9fParuZf6U5nngA81NVx2gTvPQ64oarWT9Rxkj0ZnO77HPATwLuA/5nk8Elq+cmuljnA6cBlSWZN0lYyoLTLeYjBtZLxNjIIkoOramNV/V1t+wLs+VX13ar63iTHr66qr1XVd4HzgDdtWkTxY/pl4MNVdX8XDu8DFo+bvf3XqvpeVd0O3A48K+i6WhYD76uqf6qqbwC/B7x1O+vYH3h4K8ePZhCeF1XVU1X1BeA6YMkk7TcCF3Rf/+uB9QxCVpqQAaVdzRzg8Qn2XwKsAj6X5P4kZ29HXw/uwPFvAnsCB2xXlVv3U11/w33vwWDmt8nwqrsNDIJivAO6msb3NWc761jHINS3VueD4xalbK3/dVX19ND2ZHVLgAGlXUiSVzH45vj34491M4izquqngUXAe5Icu+nwJF1ua4Y1d+j1QQxmCI8B3wWeP1TXTAanFre334cYLPwY7vtpBivodsRjXU3j+1qzne//G+D4JC/YSp1zkwx/H9mR/qWtMqA07SV5YZLXA9cwWPr9/yZo8/okL04S4EkGS9M3/eT/LQbXaHbUW5LMT/J8BkuxP11VPwDuA56b5Oe76zTnAs8Zet+3gEPGfWMf9ing3UkOTbI3P7xm9fQk7SfU1XIt8MEk+yQ5GHgP8Kfb2cXVDGaJf5nkJd3iiv2TvD/JicDNDGZBv5VkzyTHAL/A4N9B+rEZUJrOPpvknxh8Ez0H+DAw2cqweQxmBOuBLwEfr6qbumO/C5zbrUT7zR34/KuBKxmcbnsucCYMVhUCvwZ8ksFs4rsMFmhs8hfdf9cl+coE/V7R9f1F4B+B7zNYgPCjeFf3+fczmFn+Wdf/NlXVPzNYKHEPgxV/3wFuYXDq8OaqeopBIJ3AYLb2ceDUqrrnR6xV2oI36kqSmuQMSpLUpN4CKskV3Q15X5vkeJJ8NMmqJHckObKvWiRJ00+fM6grGTweZTInMLguMA9YCvxBj7VIkqaZ3gKqqr7IxPejbHIScFUNfBnYL8nW7rmQJO1GRvkQzDlseaPj6m7fs+5cT7KUwSyLF7zgBa98yUteslMKlCT179Zbb32sqmaP3z8tntJcVZcDlwOMjY3VypUrR1yRJGmqJPnmRPtHuYpvDVveiX8g3oEuSeqMMqCWAad2q/mOBp6sqq09mFKStBvp7RRfkk8BxwAHdL8b578weHAlVfUJ4HrgRAYP8NzA5E8AkCTthnoLqKqa7JH7m44X8Ot9fb4kaXrzSRKSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJvUaUEkWJrk3yaokZ09w/KAkNyW5LckdSU7ssx5J0vTRW0AlmQlcBpwAzAeWJJk/rtm5wLVV9bPAYuDjfdUjSZpe+pxBLQBWVdX9VfUUcA1w0rg2Bbywe70v8FCP9UiSppE+A2oO8ODQ9upu37DzgbckWQ1cD7xroo6SLE2yMsnKtWvX9lGrJKkxo14ksQS4sqoOBE4Erk7yrJqq6vKqGquqsdmzZ+/0IiVJO1+fAbUGmDu0fWC3b9jpwLUAVfUl4LnAAT3WJEmaJvoMqBXAvCSHJtmLwSKIZePaPAAcC5DkCAYB5Tk8SVJ/AVVVTwNnADcCdzNYrXdnkguSLOqanQW8I8ntwKeA06qq+qpJkjR97NFn51V1PYPFD8P7PjD0+i7gNX3WIEmanka9SEKSpAkZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJvUaUEkWJrk3yaokZ0/S5k1J7kpyZ5I/67MeSdL0sUdfHSeZCVwG/AdgNbAiybKqumuozTzgfcBrquqJJD/RVz2SpOmlt4ACFgCrqup+gCTXACcBdw21eQdwWVU9AVBVj/ZYj7bDk08+yQ033MCaNWsAmDNnDscffzz77bffaAuTeuKYb1efp/jmAA8Oba/u9g07DDgsyT8k+XKShRN1lGRpkpVJVq5du7ancnXVVVdx5JFHsnz5cjZs2MCGDRu46aabeOUrX8lVV1016vKkKeeYb1uqqp+OkzcCC6vq7d32W4GjquqMoTbXARuBNwEHAl8E/lVVfXuyfsfGxmrlypW91Ly7O/zww7n55puf9ZPjE088wVFHHcV99903msKknjjm25Dk1qoaG7+/zxnUGmDu0PaB3b5hq4FlVbWxqv4RuA+Y12NN2oqqIsmz9s+YMYO+fpCRRskx37Y+r0GtAOYlOZRBMC0G3jyuzf8GlgD/I8kBDE753d9jTdqKc845hyOPPJLXve51zJ07+NnigQce4POf/zznnXfeiKuTpp5jvm29neIDSHIi8BFgJnBFVX0wyQXAyqpalsGPLr8HLAR+AHywqq7ZWp+e4uvXE088wY033visC8azZs0acWVSPxzzozfZKb5eA6oPBpQk7VpGcQ1K08wVV1yx+fWaNWs49thjmTVrFq9+9au9WKxdkmO+bQaUNrv00ks3v373u9/NKaecwrp163jve9/LO9/5zhFWJvXDMd82A0oTuu+++1i6dCkzZszg5JNP5vHHHx91SVKvHPPt6XMVn6aZ1atXc+aZZ1JVrF27lo0bN7LnnnsCsHHjxhFXJ009x3zbDChtdskll2x+PTY2xvr165k1axaPPPIIixYtGmFlUj8c821zFZ8kaaRcxacfy3XXXTfqEqSdyjE/egaUtsuKFStGXYK0UznmR89TfNrCPffcw2c+85kt7qpftGgRRxxxxIgrk/rhmB89T/Fpmy6++GIWL15MVbFgwQIWLFhAVbFkyRIuuuiiUZcnTTnHfNucQWmzww47jDvvvHPzMttNnnrqKV760pfy9a9/fUSVSf1wzLfBGZS2acaMGTz00EPP2v/www8zY4ZDRbsex3zbvA9Km33kIx/h2GOPZd68eVv86oFVq1Zt8UgYaVfhmG+bp/i0hWeeeYZbbrlliwvGr3rVq5g5c+aIK5P64ZgfvclO8TmD0hZmzJjB0UcfvXn7mGOOAWD58uWjKUjq2fCYd7y3ZYdOsiY5OskNSZYneUNPNUmStPUZVJKfrKpHhna9BzgZCHAzg1/ZLknSlNvWKb5PJPkK8KGq+j7wbeCNwDPAd3qurTfv+LiP0d9e9z70NODXbHv90a+9aNQlTMh/v+3jeN9xfY75rZ7iq6o3ALcB1yU5FfgN4DnA/sAbeqtKkrTb2+Y1qKr6LHA8sC/wV8B9VfXRqlrbd3GSpN3XVgMqyaIkNwE3AF8DTgFOSnJNkp/ZGQVKknZP27oGdSGwAHgecGNVLQDOSjIP+CCwuOf6NGKv/41loy5B2mkc723ZVkA9Cfwi8Hzg0U07q+rrGE6SpB5t6xrUyQwWROwBvLn/ciRJGtjqDKqqHgM+tpNqkSRpMx/XK0lqkgElSWqSASVJapIBJUlqkgElSWqSASVJapIBJUlqkgElSWqSASVJapIBJUlqkgElSWqSASVJalKvAZVkYZJ7k6xKcvZW2v1Skkoy1mc9kqTpo7eASjITuAw4AZgPLEkyf4J2+wD/Cbi5r1okSdNPnzOoBcCqqrq/qp4CrgFOmqDdbwMXA9/vsRZJ0jTTZ0DNAR4c2l7d7dssyZHA3Kr6P1vrKMnSJCuTrFy7du3UVypJas7IFkkkmQF8GDhrW22r6vKqGquqsdmzZ/dfnCRp5PoMqDXA3KHtA7t9m+wDvAxYnuQbwNHAMhdKSJKg34BaAcxLcmiSvYDFwLJNB6vqyao6oKoOqapDgC8Di6pqZY81SZKmid4CqqqeBs4AbgTuBq6tqjuTXJBkUV+fK0naNezRZ+dVdT1w/bh9H5ik7TF91iJJml58koQkqUkGlCSpSQaUJKlJBpQkqUkGlCSpSQaUJKlJBpQkqUkGlCSpSQaUJKlJBpQkqUkGlCSpSQaUJKlJBpQkqUkGlCSpSQaUJKlJBpQkqUkGlCSpSQaUJKlJBpQkqUkGlCSpSQaUJKlJBpQkqUkGlCSpSQaUJKlJBpQkqUkGlCSpSQaUJKlJBpQkqUkGlCSpSQaUJKlJBpQkqUkGlCSpSQaUJKlJBpQkqUkGlCSpSQaUJKlJBpQkqUkGlCSpSb0GVJKFSe5NsirJ2RMcf0+Su5LckeRvkxzcZz2SpOmjt4BKMhO4DDgBmA8sSTJ/XLPbgLGqejnwaeBDfdUjSZpe+pxBLQBWVdX9VfUUcA1w0nCDqrqpqjZ0m18GDuyxHknSNNJnQM0BHhzaXt3tm8zpwF9PdCDJ0iQrk6xcu3btFJYoSWpVE4skkrwFGAMumeh4VV1eVWNVNTZ79uydW5wkaST26LHvNcDcoe0Du31bSHIccA7w2qr65x7rkSRNI33OoFYA85IcmmQvYDGwbLhBkp8F/hBYVFWP9liLJGma6S2gqupp4AzgRuBu4NqqujPJBUkWdc0uAfYG/iLJV5Msm6Q7SdJups9TfFTV9cD14/Z9YOj1cX1+viRp+mpikYQkSeMZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJvUaUEkWJrk3yaokZ09w/DlJ/rw7fnOSQ/qsR5I0ffQWUElmApcBJwDzgSVJ5o9rdjrwRFW9GPh94OK+6pEkTS99zqAWAKuq6v6qegq4BjhpXJuTgD/pXn8aODZJeqxJkjRN7NFj33OAB4e2VwNHTdamqp5O8iSwP/DYcKMkS4Gl3eb6JPf2UrEmcwDj/k00sU/++qgr0BRwvO+AKRrzB0+0s8+AmjJVdTlw+ajr2F0lWVlVY6OuQ9oZHO/t6PMU3xpg7tD2gd2+Cdsk2QPYF1jXY02SpGmiz4BaAcxLcmiSvYDFwLJxbZYBb+tevxH4QlVVjzVJkqaJ3k7xddeUzgBuBGYCV1TVnUkuAFZW1TLgj4Grk6wCHmcQYmqPp1e1O3G8NyJOWCRJLfJJEpKkJhlQkqQmGVC7mSTrx22fluTSKep7eRKX56ppSfZP8tXuzyNJ1gxt7zWu7a8mObV7fWWSN46m6t3TtLgPSpKmSlWtA14BkOR8YH1V/bdJ2n5i51Wm8ZxBabMks5P8ZZIV3Z/XdPsXJPlSktuS/N8kh3f7n5fkmiR3J/kr4Hkj/QtIP6Ik7+jG/O3d/wPP7/afn+Q3R13f7soZ1O7neUm+OrT9In54f9p/B36/qv4+yUEMbhE4ArgH+Lnu1oHjgN8Bfgl4J7Chqo5I8nLgKzvrLyFNsf9VVX8EkORCBg+y/thoS5IBtfv5XlW9YtNGktOATdeNjgPmDz2v94VJ9mbwhI8/STIPKGDP7vi/Az4KUFV3JLmj9+qlfrysC6b9gL0Z/HCmETOgNGwGcHRVfX94Z7eI4qaqOrn7nV3LR1Cb1KcrgTdU1e3dD23HjLQaAV6D0pY+B7xr00aSV3Qv9+WHz1E8baj9F4E3d21fBry89wqlfuwDPJxkT+CXR12MBgwoDTsTGEtyR5K7gF/t9n8I+N0kt7HlrPsPgL2T3A1cANy6U6uVps55wM3APzC45qoG+KgjSVKTnEFJkppkQEmSmmRASZKaZEBJkppkQEmSmmRASZKaZEBJkpr0/wGVoP+uIEskowAAAABJRU5ErkJggg==\n" }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fair_coin = Coin().set([.5] * 2)\n", "fair_coin.plot(view=True)\n", "\n", "biased_coin = Coin().set([.3, .7])\n", "biased_coin.plot(view=True)" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "code", "execution_count": 43, "outputs": [ { "data": { "text/plain": "0.3" }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "biased_coin.p({'Head'})" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "code", "execution_count": 44, "outputs": [ { "data": { "text/plain": "(0.7, {'Tail'})" }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "biased_coin.mpe()" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "markdown", "source": [ "# Random Variables\n", "\n", "In ``pyjpt``, random variables are instances of the [jpt.variables.Variable](../autoapi/jpt/variables/index.html#jpt.variables.Variable) class. ``jpt.Variable`` itself is abstract so it cannot be instantiated directly. There exist three subclasses\n", "\n", " * [jpt.variables.SymbolicVariable](../autoapi/jpt/variables/index.html#jpt.variables.SymbolicVariable)\n", " * [jpt.variables.NumericVariable](../autoapi/jpt/variables/index.html#jpt.variables.NumericVariable)\n", " * [jpt.variables.IntegerVariable](../autoapi/jpt/variables/index.html#jpt.variables.IntegerVariable)\n", "\n", "that implement the behavior of a variable of the respective type.\n", "\n", "A variable is determined by its name and domain, which are passed as arguments in the variable object's constructor.\n", "For instance, in order to instantiate two variables representing the result of the above coin tossing and dicing experiments, we create one integer and symbolic variable:" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } }, { "cell_type": "code", "execution_count": 45, "outputs": [ { "data": { "text/plain": "(CoinToss[Coin], Dice[Die])" }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from jpt.variables import SymbolicVariable, IntegerVariable\n", "\n", "coin = SymbolicVariable('CoinToss', domain=Coin)\n", "die = IntegerVariable('Dice', domain=Die)\n", "\n", "coin, die" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "markdown", "source": [ "A variable object as such does not have much funcionality. Its main purpose is to bind a particular symbol in the domain of discource to the set of admissible values and to carry settings that are relevant for the learning and inference process." ], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } }, { "cell_type": "markdown", "source": [ "# Variable Assignments\n", "\n", "The datastructure that describes questions and answers in JPTs are almost always [jpt.variables.VariableAssignment](../autoapi/jpt/variables/index.html#jpt.variable.VariableAssignment).\n", "A VariableAssignment, as the name suggests, assigns instances of [jpt.variables.Variable](../autoapi/jpt/variables/index.html#jpt.variable.Variable) reference to values of their doamin.\n", "When creating queries and evidences for a JPT one is required to create VariableMaps or dict that map string to variable\n", "values. Variable values can be one of the following things\n", "\n", " * singular values:\n", " Singular values refer to numbers (ints or floats) for numeric variables or one element of a variables domain\n", " (most likely a string or int or float)\n", "\n", " * sets:\n", " For discrete variables a set should be a python set of elements of a variables domain. For numeric variables it can\n", " be either a ContinuousSet or RealSet. A ContinuousSet is a simple interval with lower and upper bound.\n", " A RealSet is a set of intervals in the same sense as for discrete variables. Those sets are interpreted as\n", " the statement: the value of variables x A or B or C for a something like ``{\"A\", \"B\", \"C\"}``" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", "version": "2.7.6" } }, "nbformat": 4, "nbformat_minor": 0 }