From c67556216a2f3d9ecc12f6a724a5dda85535c73a Mon Sep 17 00:00:00 2001 From: kt63707 Date: Thu, 17 Oct 2024 12:00:10 +0200 Subject: [PATCH] Upload files to "Przewodnik_studenta_lab" --- .../02LRAP_przewodnik.ipynb | 395 ++++++++++++++++++ 1 file changed, 395 insertions(+) create mode 100644 Przewodnik_studenta_lab/02LRAP_przewodnik.ipynb diff --git a/Przewodnik_studenta_lab/02LRAP_przewodnik.ipynb b/Przewodnik_studenta_lab/02LRAP_przewodnik.ipynb new file mode 100644 index 0000000..3baad90 --- /dev/null +++ b/Przewodnik_studenta_lab/02LRAP_przewodnik.ipynb @@ -0,0 +1,395 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7c6ce8", + "metadata": { + "collapsed": false + }, + "source": [ + "# Modelowanie przestrzeni probabilistycznych w programie R cz. 2 " + ] + }, + { + "cell_type": "markdown", + "id": "9bb7a3", + "metadata": { + "collapsed": false + }, + "source": [ + "Kontynuujemy temat generowania przestrzeni probabilistycznych w programie R. Przypominamy, że większość interesujących nas funkcji znajduje się w pakiecie `probs`. " + ] + }, + { + "cell_type": "markdown", + "id": "d77bdb", + "metadata": { + "collapsed": false + }, + "source": [ + "## Prawdopodobieństwo warunkowe\n", + "\n", + "Przpomnijmy, że jeśli dane są dwa zdarzenia $A$ i $B$ określone w tej samej przestrzeni probabilistycznej oraz $\\mathbb{P}(B)>0$, to możemy zdefiniować prawdopodobieństwo warunkowe zdarzenia $A$ pod warunkiem zajścia zdarzenia $B$ w następujący sposób:\n", + "\n", + "$$\\mathbb{P}(A|B)=\\frac{\\mathbb{P}(A\\cap B)}{\\mathbb{P}(B)}.$$\n", + "\n", + "Jeśli chcemy obliczyć takie prawdopodobieństwo w programie R, możemy użyć polecenia \n", + "\n", + "`Prob(x, event=A, given=B)`, \n", + "\n", + "gdzie w miejscu $A$ i $B$ należy podać odpowiednie podzbiory w formie ramek danych lub formuły logicznej opisującej to zdarzenie. Jeśłi $A$ zostanie wcześniej zdefiniowane jako podzbiór odpowiedniej przestrzeni probabilistycznej, to można też użyć polecenia `Prob(A, given=B)`." + ] + }, + { + "cell_type": "markdown", + "id": "d1c017", + "metadata": { + "collapsed": false + }, + "source": [ + "**Przykład 1**\n", + "\n", + "Rzucamy dwukrotnie sześcienną kostką do gry. Ile wynosi prawdopodobieństwo, że suma wyrzuconych oczek jest większa od 7, jeśli wiemy, że w pierwszym rzucie wypadła parzysta liczba oczek?" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "id": "ad9ab4", + "metadata": { + "collapsed": false + }, + "outputs": [ + ], + "source": [ + "# Definiujemy przestrzeń probabilistyczną odpowiadającą temu doświadczeniu losowemu\n", + "kostki2=rolldie(2,makespace=TRUE)\n", + "# Definiujemy zdarzenia A i B. Skorzystamy z operatora %% (x %% y zwraca resztę z dzielenia x przez y)\n", + "A=subset(kostki2,X1 %% 2 == 0)\n", + "B=subset(kostki2,X1+X2>7)\n", + "# Obliczamy prawdopodobieństwo warunkowe P(A|B)\n", + "p=Prob(A,given=B)\n", + "print(p)\n", + "# Możemy porównać to prawdopodobieństwo do prawdopodobieństwa zdarzenia A\n", + "p2=Prob(A)\n", + "print(p2)" + ] + }, + { + "cell_type": "markdown", + "id": "2b95c8", + "metadata": { + "collapsed": false + }, + "source": [ + "## Przestrzenie produktowe\n", + "\n", + "Przypomnijmy, że jeśli dane są dwie przestrzenie probabilistyczne $(\\Omega_1, \\mathcal{F}_1, \\mathbb{P}_1)$ oraz $(\\Omega_2, \\mathcal{F}_2, \\mathbb{P}_2)$, to możemy zdefiniować ich produkt jako przestrzeń probabilistyczną $(\\Omega,\\mathcal{F},\\mathcal{P})$, gdzie $\\Omega = \\Omega_1\\times\\Omega_2$, $\\mathcal{F}$ zawiera wszystkie zbiory postaci $A_1\\times A_2\\in \\mathcal{F}_1\\times\\mathcal{F}_2$, oraz funkcja prawdopodobieństwa $\\mathbb{P}$ spełnia warunek\n", + "\n", + "$$ \\mathbb{P}(A_1\\times A_2) = \\mathbb{P}_1(A_1)\\cdot\\mathbb{P}_2(A_2).$$\n", + "\n", + "W analogiczny sposób możemy definiować produkt dowolnej, skończonej liczby przestrzeni probabilistycznych. W programie R istnieje kilka sposobów modelowania tego typu przestrzeni.\n", + "\n", + "### Niezależne powtórzenia tego samego eksperymentu losowego\n", + "\n", + "Załóżmy najpierw, że wielokrotnie w sposób niezależny powtarzamy ten sam eksperyment losowy, np. rzucamy $n$-krotnie standardową kostką sześcienną. Wówczas możemy użyć polecenia \n", + "\n", + "`iidspace(x, ntrials, probs=NULL)`,\n", + "\n", + "gdzie `x` oznacza wektor możliwych wyników w pojedynczym powtórzeniu eksperymentu losowego, `ntrials` podaje liczbę powtórzeń, a `probs` to wektor prawopodobieństw odpowiadający wynikom `x`. Jeśli wszystkie wyniki pojedynczego powtórzenia eksperymentu losowego są równo prawdopodobne, to możemy nie podawać wektora `probs`.\n", + "\n", + "**Przykład 2** \n", + "\n", + "Wygeneruj przestrzeń probabilistyczną odpowiadającą trzykrotnemu rzutowi czworościenną kostką przy założeniu, że:\n", + "\n", + "* kostka jest symetryczna (tzn. każdy wynik jest równo prawdopodobny),\n", + "* prawdopodobieństwo wypadnięcia 1 to 1/2, a prawdopodobieństwo wypadnięcia dowolnej innej liczby oczek to 1/6." + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "id": "10630e", + "metadata": { + "collapsed": false + }, + "outputs": [ + ], + "source": [ + "# Generujemy przestrzeń probabilistyczną odpowiadającą 3-krotnemu rzutowi symetryczną kostką\n", + "x=1:4\n", + "kostka_sym=iidspace(x,3)\n", + "print(kostka_sym)\n", + "# Zwróćmy uwagę, że równoważnie można było w tym przypadku użyć polecenia rolldie(3,nsides=4,makespace=TRUE)\n", + "# Generujemy przestrzeń probabilistyczną odpowiadającą 3-krotnemu rzutowi ,,oszukaną'' kostką\n", + "kostka_osz=iidspace(x,3,probs=c(1/2,1/6,1/6,1/6))\n", + "print(kostka_osz)" + ] + }, + { + "cell_type": "markdown", + "id": "b518a1", + "metadata": { + "collapsed": false + }, + "source": [ + "Szczególnym przypadkiem niezależnych powtórzeń tego samego eksperymentu losowego jest sytuacja, gdy ten eksperyment losowy ma tylko dwa możliwe wyniki umownie nazywane ,,sukcesem'' i ,,porażką''. Jeśli liczba powtórzeń eksperymentu losowego jest ustalona i skończona, to mamy wówczas do czynienia z tzw. *schematem Bernoulliego*. Prawdopodobieństwo uzyskania dokładnie $k$ sukcesów w tego typu doświadczeniu losowym jest wtedy równe:\n", + "\n", + "$$\\tau_k = {n\\choose k}p^k(1-p)^{n-k} \\ \\text{ dla } \\ k=0,1,\\ldots,n,$$\n", + "\n", + "gdzie $n$ to liczba powtórzeń, a $p$ to prawdopodobieństwo sukcesu w pojedynczej próbie. W R prawdopodobieństwa tego typu można liczyć przy pomocy następującego polecenia z pakietu `stats`:\n", + "\n", + "`dbinom(x,size,prob)`,\n", + "\n", + "gdzie `x` oznacza wektor zawierający interesujące nas liczby sukcesów, `size` oznacza liczbę powtórzeń, a `prob` prawdopodobieństwo sukcesu w pojedynczej próbie.\n", + "\n", + "**Przykład 3** \n", + "\n", + "Losujemy $10$ razy, ze zwracaniem jedną kartę z talii $52$ kart. Ile wynosi prawdopodobieństwo, że wylosujemy:\n", + "\n", + "* dokładnie 6 kierów,\n", + "* przynajmniej 6 kierów.\n", + "\n", + "**Uwaga:** Poniższy przykład wymaga zainstalowania i załadowania pakietu `stats`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f55f0a", + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1] \"Prawdopodobieństwo wylosowania dokładnie 6 kierów: 0.0162220001220703\"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1] 1.622200e-02 3.089905e-03 3.862381e-04 2.861023e-05 9.536743e-07\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1] \"Prawdopodobieństwo wylosowania przynajmniej 6 kierów: 0.0197277069091797\"\n" + ] + } + ], + "source": [ + "# Zwróćmy uwagę, że ponieważ losujemy karty ze zwracaniem, to mamy do czynienia z niezależnymi powtórzeniami tego samego eksperymentu losowego\n", + "# Interesuje nas liczba kierów, więc jako sukces możemy przyjąć wylosowanie kiera\n", + "# Liczba powtórzeń wynosi n=10, a prawdopodobieństwo sukcesu w pojedynczej próbie to p=1/4 (bo w talii mamy 13 kierów)\n", + "p1=dbinom(6,10,1/4)\n", + "print(paste('Prawdopodobieństwo wylosowania dokładnie 6 kierów: ', p1))\n", + "# W przypadku zdarzenia ,,wylosujemy przynajmniej 6 kierów'' jako x podamy wektor zawierający wszystkie interesujące nas liczby sukcesów\n", + "y=dbinom(6:10,10,1/4)\n", + "print(y)\n", + "# Zwróćmy uwagę, że zostanie zwrócony wektor prawdopodobieństw odpowiadający wszystkim możliwym liczbom sukcesów. Aby uzyskać odpowiedź musimy je zsumować\n", + "p2=sum(y)\n", + "print(paste('Prawdopodobieństwo wylosowania przynajmniej 6 kierów: ', p2))" + ] + }, + { + "cell_type": "markdown", + "id": "772bd6", + "metadata": { + "collapsed": false + }, + "source": [ + "Mogą nas też interesować doświadczenia losowe polegające na powtarzaniu eksperymentu losowego o dwóch wynikach (ponownie umownie nazywanymi \"sukcesem\" i \"porażką\") do momentu osiągnięcia pierwszego sukcesu. Mamy wówczas do czynienia z tzw. *rozkładem geometrycznym* i możemy obliczyć prawdopodobieństwo, że będziemy potrzebowali dokładnie $k$ prób na osiągnięcie pierwszego sukcesu zgodnie ze wzorem:\n", + "\n", + "$$\\sigma_k=p(1-p)^{k-1} \\ \\text{ dla } \\ k=1,2,\\ldots,$$\n", + "\n", + "gdzie $p$ oznacza prawdopodobieństwo sukcesu w pojedynczej próbie. W R prawdopodobieństwa tego typu można liczyć przy pomocy następującego polecenia z pakietu `stats`:\n", + "\n", + "`dgeom(x,prob)`,\n", + "\n", + "gdzie `x` oznacza wektor zawierający interesujące nas liczby porażek przed osiągnięciem pierwszego sukcesu, a `prob` prawdopodobieństwo sukcesu w pojedynczej próbie.\n", + "\n", + "**Przykład 4** \n", + "\n", + "Losujemy wielokrotnie ze zwracaniem jedną kartę z talii $52$ kart do momentu wylosowania pierwszego kiera. Ile wynosi prawdopodobieństwo, że wykonamy:\n", + "\n", + "* dokładnie 6 losowań,\n", + "* co najwyżej 6 losowań,\n", + "* co najmniej 7 losowań.\n", + "\n", + "**Uwaga:** Poniższy przykład wymaga zainstalowania i załadowania pakietu `stats`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a50388", + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1] \"Prawdopodobieństwo dokładnie 6 losowań: 0.059326171875\"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1] 0.25000000 0.18750000 0.14062500 0.10546875 0.07910156 0.05932617\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1] \"Prawdopodobieństwo co najwyżej 6 losowań: 0.822021484375\"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1] \"Prawdopodobieństwo co najmniej 7 losowań: 0.177978515625\"\n" + ] + } + ], + "source": [ + "# Podobnie, jak w poprzednim przykładzie mamy do czynienia z niezależnymi powtórzeniami tego samego eksperymentu losowego, a sukcesem jest wylosowanie kiera\n", + "# Zwróćmy uwagę, że w poleceniu dgeom podajemy liczbę porażek przed pierwszym sukcesem\n", + "p1=dgeom(5,1/4)\n", + "print(paste('Prawdopodobieństwo dokładnie 6 losowań: ', p1))\n", + "# W przypadku zdarzenia ,,wykonamy co najwyżej 6 losowań'' jako x podamy wektor zawierający wszystkie interesujące nas liczby porażek\n", + "y=dgeom(0:5,1/4)\n", + "print(y)\n", + "# Zwróćmy uwagę, że zostanie zwrócony wektor prawdopodobieństw odpowiadający wszystkim możliwym liczbom wykonanych losowań. Aby uzyskać odpowiedź musimy je zsumować\n", + "p2=sum(y)\n", + "print(paste('Prawdopodobieństwo co najwyżej 6 losowań: ', p2))\n", + "# W przypadku zdarzenia ,,wykonamy co najmniej 7 losowań'' nie będziemy tego rozbijać na wszystkie możliwe przypadki (bo byłoby ich nieskończenie wiele). Zamiast tego skorzystamy ze zdarzenia przeciwnego\n", + "p3=1-p2\n", + "print(paste('Prawdopodobieństwo co najmniej 7 losowań: ', p3))" + ] + }, + { + "cell_type": "markdown", + "id": "f09dac", + "metadata": { + "collapsed": false + }, + "source": [ + "### Ogólne przestrzenie produktowe\n", + "\n", + "Na koniec pokażemy, jak możemy modelować przestrzenie produktowe w przypadku, gdy łączymy wyniki kilku różnych eksperymentów losowych. Wiemy już, że w takim przypadku zbiór zdarzeń elementarnych $\\Omega$ jest iloczynem kartezjańskim zbiorów zdarzeń elementarnych odpowiadających poszczególnym eksperymentom losowym. W programie R do generowania iloczynu kartezjańskiego wektorów możemy użyć polecenia `expand.grid`. Jako argumenty należy podać wektory, których iloczyn kartezjański chcemy wyznaczyć. Jeśli podamy je w formie `tag=v`, to kolumna odpowiadająca wektorowi `v` będzie miała nazwę `tag`.\n", + "\n", + "**Przykład 5**\n", + "\n", + "Rzucamy jednokrotnie sześcienną sześcienną kostką i symetryczną monetą. Wygeneruj przestrzeń probabilistyczną odpowiadającą temu doświadczeniu losowemu.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6ddb94", + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "ename": "ERROR", + "evalue": "Error in probspace(Omega): could not find function \"probspace\"\n", + "output_type": "error", + "traceback": [ + "Error in probspace(Omega): could not find function \"probspace\"\nTraceback:\n" + ] + } + ], + "source": [ + "# Najpierw generujemy zbiór zdarzeń elementarnych\n", + "Omega=expand.grid(k=1:6,m=c('O','R'))\n", + "# Następnie na tej podstawie generujemy przestrzeń probabilistyczną. W tym przypadku możemy przyjąć, że mamy do czynienia z modelem klasycznym\n", + "X=probspace(Omega)" + ] + }, + { + "cell_type": "markdown", + "id": "556d72", + "metadata": { + "collapsed": false + }, + "source": [ + "Należ zwrócić uwagę, że jeśli definiujemy w R produktową przestrzeń probabilistyczną opierając się na przestrzeniach probabilistycznych, w których prawdopodobieństwo nie jest definiowane w sposób klasyczny, to musimy dodatkowo zdefiniować w odpowiedni sposób wektor prawdopodobieństw.\n", + "\n", + "**Przykład 6** \n", + "\n", + "Rzucamy jednokrotnie sześciokrotną kostką i monetą. Zakładamy, że na kostce jedno oczko wypada z prawdopodobieństwem 1/2, a pozostałe liczby oczek wypadają z prawdopodobieństwem 1/10. Wygeneruj przestrzeń probabilistyczną odpowiadającą temu doświadczeniu losowemu. Następnie oblicz prawdopodobieństwo zdarzenia A \\- wypadł orzeł i nieparzysta liczba oczek.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 0, + "id": "3054f9", + "metadata": { + "collapsed": false + }, + "outputs": [ + ], + "source": [ + "# Możemy wykorzystać zbiór zdarzeń elementarnych Omega wygenerowany w poprzednim przykładzie\n", + "# Zgodnie z definicją przestrzeni produktowej aby znaleźć prawdopodobieństwo zdarzenia elementarnego (x,y) należy pomnożyć prawdopodobieństwa tych zdarzeń w pierwotnych przestrzeniach probabilistycznych\n", + "\n", + "p=rep(0,12)\n", + "for (i in 1:12) {\n", + " if (Omega[i,1]==1) {\n", + " p[i]=0.5*0.5} else {p[i]=0.1*0.5\n", + "}}\n", + "# Generujemy przestrzeń probabilistyczną\n", + "X2=probspace(Omega,p)\n", + "print(X2)\n", + "# Możemy teraz obliczyć prawdopodobieństwo zdarzenie A\n", + "A=subset(Omega,(k %in% seq(1,6,by=2)) & (m=='O'))\n", + "print(Prob(A))\n", + "# Alternatywnie, można by wyznaczyć prawdopodobieństwo wypadnięcia nieparzystej liczby oczek w przestrzeni rzutu kostką i prawdopodobieństwo wypadnięcia orła w przestrzeni rzutu monetą i pomnożyć przez siebie te dwa prawdopodobieństwa\n", + "kostka=probspace(1:6,c(0.5,rep(0.1,5))) # Definiujemy przestrzeń związaną z rzutem kostką\n", + "A1=subset(kostka,(x %in% seq(1,6,by=2)))\n", + "moneta=probspace(c('O','R')) # Definiujemy przestrzeń związaną z rzutem monetą\n", + "A2=subset(moneta,x=='O')\n", + "pA=Prob(A1)*Prob(A2)\n", + "print(pA)" + ] + } + ], + "metadata": { + "kernelspec": { + "argv": [ + "/usr/bin/R", + "-e", + "IRkernel::main()", + "--args", + "{connection_file}" + ], + "display_name": "R (system-wide)", + "env": { + }, + "language": "r", + "metadata": { + "cocalc": { + "description": "R statistical programming language", + "priority": 10, + "url": "https://www.r-project.org/" + } + }, + "name": "ir", + "resource_dir": "/ext/jupyter/kernels/ir" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file