Commit e3e89e82 authored by vincentvigon's avatar vincentvigon

first commit

parents
File added
**/private
<?xml version="1.0" encoding="UTF-8"?>
<module type="PYTHON_MODULE" version="4">
<component name="NewModuleRootManager">
<content url="file://$MODULE_DIR$" />
<orderEntry type="jdk" jdkName="Python 3.5.1 (/Library/Frameworks/Python.framework/Versions/3.5/bin/python3.5)" jdkType="Python SDK" />
<orderEntry type="sourceFolder" forTests="false" />
</component>
<component name="TestRunnerService">
<option name="PROJECT_TEST_RUNNER" value="Unittests" />
</component>
</module>
\ No newline at end of file
<component name="ProjectDictionaryState">
<dictionary name="vigon" />
</component>
\ No newline at end of file
<component name="InspectionProjectProfileManager">
<profile version="1.0">
<option name="myName" value="Project Default" />
<inspection_tool class="PyAttributeOutsideInitInspection" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
<inspection_tool class="PyCompatibilityInspection" enabled="true" level="WARNING" enabled_by_default="true">
<option name="ourVersions">
<value>
<list size="1">
<item index="0" class="java.lang.String" itemvalue="3.5" />
</list>
</value>
</option>
</inspection_tool>
<inspection_tool class="PyListCreationInspection" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
<inspection_tool class="PyMethodMayBeStaticInspection" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
<inspection_tool class="PyMissingTypeHintsInspection" enabled="true" level="WARNING" enabled_by_default="true" />
<inspection_tool class="PyPep8Inspection" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
<inspection_tool class="PyPep8NamingInspection" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
<inspection_tool class="PyShadowingNamesInspection" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
</profile>
</component>
\ No newline at end of file
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="JavaScriptSettings">
<option name="languageLevel" value="ES6" />
</component>
<component name="ProjectRootManager" version="2" project-jdk-name="Python 3.5.1 (/Library/Frameworks/Python.framework/Versions/3.5/bin/python3.5)" project-jdk-type="Python SDK" />
</project>
\ No newline at end of file
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectModuleManager">
<modules>
<module fileurl="file://$PROJECT_DIR$/.idea/aleatDataSignal.iml" filepath="$PROJECT_DIR$/.idea/aleatDataSignal.iml" />
</modules>
</component>
</project>
\ No newline at end of file
This diff is collapsed.
File added
This diff is collapsed.
This diff is collapsed.
This source diff could not be displayed because it is too large. You can view the blob instead.
This source diff could not be displayed because it is too large. You can view the blob instead.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This source diff could not be displayed because it is too large. You can view the blob instead.
This source diff could not be displayed because it is too large. You can view the blob instead.
This diff is collapsed.
import numpy as np
np.set_printoptions(precision=2,suppress=True)
"""voici le second import à connaître par coeur :
il permet de faire des graphiques. """
import matplotlib.pyplot as plt
""" observez : le graphe d'une fonction n'est qu'une ligne brisée """
def step0():
nbPoint=10
"""des points régulièrement répartis entre 0 et 2 pi"""
x=np.linspace(0,2*np.pi,nbPoint)
y=np.sin(x)
print("x",x)
print("y",y)
plt.plot(x,y)
"""idem, mais sans relier les points"""
plt.plot(x,y,'o')
""" a ne pas oublier: cela ouvre la fenêtre graphique """
plt.show()
""" ATTENTION : l'ouverture de la fenêtre graphique bloque l'excécussion du programme.
La ligne suivante n'est pas exécutée:"""
print("toto")
"""
Modifiez le programme précédent : augmenter le nombre de point pour donner une meilleurs représentation du
graphe d'une fonction.
"""
def step1():
nbPoints=10
x=np.linspace(0,2*np.pi,nbPoints)
y=np.sin(x)
z=np.cos(x)
""" on fait une grille 2*3 de fenêtres. """
plt.subplot(2,3,1) #on remplit la fenêtre 1
plt.plot(x,y)
plt.subplot(2, 3, 2) #on remplit la fenêtre 2
plt.plot(x, y,"o-")
plt.subplot(2, 3, 3) # etc.
plt.plot(x, y,".",color="red")
"""superposons"""
plt.subplot(2,3,4)
plt.plot(x,y,"o")
plt.plot(x,z,color="blue")
""" on comprend ici l'intérêt du show() : on ouvre la fenêtre uniquement quand tout est fini. """
plt.show()
def step2():
nbPoints=100
x=np.linspace(0,5,nbPoints)
"""attention 'lambda' est un mot clef réservé de python. du coup j'utilise lamb"""
for lamb in [0.1,0.3,1,2]:
y=np.exp(lamb*x)
plt.plot(x,y,label="lambda:"+str(lamb))
plt.title("comparaison d'exponentielles")
"""on limite les ordonnées. Pourquoi est-ce important?"""
plt.ylim([0,5])
plt.legend()
plt.show()
"""
EXO : dresser le graphe de la fonction x-> 1/x sur l'intervalle [-1,1]
Aide : superposez deux graphes.
"""
\ No newline at end of file
import numpy as np
import matplotlib.pyplot as plt
"""
"""
def step0():
""""""
""" np.arange c'est comme range() sauf qu'on peut préciser le pas."""
ns=np.arange(0,10000,40)
means=[]
for n in ns:
simus=np.random.random(size=n)
means.append(np.mean(simus))
plt.plot(ns,means)
plt.show()
"""
Mais j'ai volontairement fait une erreur dans ce programme, une erreur que font beaucoup d'étudiant chaque année :
Écrivez précisément la loi des grands nombre, comparez cet énoncé avec le programme ci-dessus.
Trouvez le bug mathématique.
"""
import numpy as np
np.set_printoptions(linewidth=500,precision=2,suppress=True)
import matplotlib.pyplot as plt
""" histogramme: """
def step0():
X=np.random.normal(0,1,size=1000)
"""
x_ext : l'échantillon à observer
bins=10 : on découpe l'intervalle [min(x_ext),max(x_ext)] en dix sous-intervalles.
normed=True: la hauteur des batons est normalisée pour que cela ressemble à une densité
rwidth=0.9: la largeur de chaque baton occupe 90% de chaque sous-intervalle.
"""
plt.hist(X,10,color='blue',rwidth=0.9,normed=True)
plt.show()
""" Mais parfois il est préférable de préciser nous même les sous-intervalles (=la base des batons) """
def step1():
X=np.random.normal(0,1,size=1000)
plt.hist(X, [-2,0.5,1,5], rwidth=0.9,normed=True)
plt.show()
""" Attention, pour les lois discrètes il faut obligatoirement préciser le découpage.
Pour voir une catastrophe, remplacez bins par 11 dans plt.hist(). Expliquez le phénomène."""
def step2():
n=10
X=np.random.binomial(n,0.5,size=3000)
"""attention np.arange(0,n+2,1) donne l'intervalle discret [0,n+2[= [0,n+1].
on lui soustrait ensuite 0.5 pour avoir chaque entier de [0,n] dans un sous-intervalle"""
bins=np.arange(0,n+2,1)-0.5
plt.hist(X,bins=bins, histtype='bar', color='blue', rwidth=0.6)
"""on précise les graduations en x"""
plt.xticks(np.arange(0,n+1,1))
plt.show()
"""comparons des lois betas"""
def step3():
nbData=10000
X1=np.random.beta(3,1,size=nbData)
X2=np.random.beta(2,3,size=nbData)
X3=np.random.beta(1,0.5,size=nbData)
plt.hist([X1,X2,X3],bins=30,label=["a=3,b=1","a=2,b=3","a=1,b=0.5"])
plt.legend()
plt.show()
""" La variété des formes possible d'une loi la rend très pratique en modélisation.
Choisissez des lois bêta bien choisies (dilatée par une constante), pour modéliser les variables x_ext suivantes:
x_ext : quantité chocolat consommée par les français (sachant que plus on en mange, et plus on a envie d'en manger)
x_ext : durée de vie des français
x_ext : durée de vie des grenouilles (forte mortalité infantile)
Dressez les histogrammes
Connaissez-vous d'autre loi pour des durées de vie ?
"""
import numpy as np
np.set_printoptions(precision=2,suppress=True)
import matplotlib.pyplot as plt
"""
NB: Par abus de langage, nous dirons :
"dressez l'histrogramme de la loi machin"
pour dire
"dresser l'histogramme d'un échantillon de variables aléatoires ayant la loi machin
"""
"""superposons l'histogramme d'un échantillon gaussien avec la densité de la loi gaussienne"""
def step0():
nbSimu=1000
Simu=np.random.normal(size=nbSimu)
"""formule à emmener partout avec soi"""
def density(x):
return 1/(np.sqrt(2*np.pi))*np.exp(-0.5*x**2)
bins=np.linspace(-3,3,10)
plt.hist(Simu,bins,rwidth=0.9)
x=np.linspace(-3,3,200)
plt.plot(x,density(x))
plt.show()
""" heue : l'histogramme et la densité ne se superpose pas. Qu'ai-je oublié ?"""
"""
IMPORTANT
Il faut bien choisir ses bins.
Exemple de mauvais choix:
bins=np.linspace(-30,30,10) -> trop large.
bins=np.linspace(-3,3,200) -> beaucoup trop de baton par rapport au nombre de simu (1000) -> l'histogramme est irrégulier
bins=np.linspace(-3,3,3) -> pas assez de batons. Cela reflète mal la distribution des données.
A vous : modifier la seconde ligne en
Simu=np.random.normal(loc=2,scale=3,size=nbSimu)
Changer le bins pour avoir toujours un bel histogramme. Et surtout changer la densité.
AIDE pour la densité :
Proposition : si f(x) est la densité d'une va x_ext, alors
1/sigma f( (x-mu) / sigma )
est la densité de la va sigma x_ext + mu
Cette astuce, vous permet de vérifiez que vous ne vous tromper pas dans le ou les paramètres des lois :
Loi exponentielle :
exp(-x) -> 1/sigma exp(-x/sigma) [version anglaise: le paramètre est le paramètre d'échelle (=cst* écart-type) ]
-> lambda exp(-lambda x) [version française: le paramètre est un taux (l'inverse d'un paramètre d'échelle)]
Cauchy :
1/pi * 1/(1+x^2) -> ...
Normale :
...
Démo de la proposition:
Considérons phi fonction teste et x_ext une va de densité f.
E[phi( sigma x_ext + mu )] = int phi( sigma x + mu) f(x) dx
on fait le changement de variable sigma x + mu = y
= int phi( y) f( (x-mu)/sigma) dy/sigma
On en déduit que la densité de sigma x_ext + mu est ...
Il est important de savoir faire ce genre de démonstration rapidement.
Ci-dessous, je vous propose une autre démo sur le même thème.
"""
"""
Observez.
Que représente une distribution log-normale ?
Réponse : c'est la distribution de f(x_ext) avec f ... et x_ext ...
Vérifiez cela en superposant deux histogrammes.
"""
def step1():
size=1000
ech=np.random.normal(size=size)
exp_ech=np.exp(ech)
ech2=np.random.lognormal(size=size)
bins=np.linspace(0,10,20)
plt.hist([exp_ech,ech2],bins=bins,normed=True)
plt.show()
"""
EXO théorique (à la maison).
Complétez le calcul de la densité de la log-normale :
Considérons phi fonction teste et x_ext de loi normale.
E[phi( exp(x_ext) )] = cst int phi( exp(x) ) e^{-1/2* x^2 } dx
on fait le changement de variable exp(x) = y ...
...
donc la densité de exp(x_ext) est ...
superposez cette densité avec les histogramme pour vérifiez votre calcul.
"""
import numpy as np
np.set_printoptions(precision=2,suppress=True)
import matplotlib.pyplot as plt
"""Voici le troisième et dernier import qu'il faut connaître :"""
import scipy.stats as stats
""" scipy= sci-entific py-thon """
"""
4 mots clefs à retenir (qui permette aussi de s'améliorer en anglais scientifique) :
pdf -> Probability density function. -> densité (prend des réels en argument)
pmf -> Probability mass function -> densité discrète (prend des entiers en argument)
cdf -> Cumulative density function. -> fonction de répartition
ppf -> Percent point function (inverse of cdf ) -> fonction quantile (ou percentile)
rvs -> Random variates. -> simulation d'un échantillon de va ayant la loi donnée
A ce point du TP, vous vous dites qu'il y a vraiment trop de choses à retenir. Mais nous
allons les pratiquez très souvent : cela rentrera tout seul.
"""
def step0():
""""""
"""simulons un échantillon"""
simus=stats.norm.rvs(loc=0, scale=1, size=1000)
"""
c'est tout à fait identique à :
simus=np.random.normal(loc=0,scale=1,size=1000)
cependant scipy.stats contient encore plus de loi que numpy.random.
On aura notamment besoin de la loi t de student pour les stats.
"""
x=np.linspace(-3,3,100)
pdf=stats.norm.pdf(x, loc=0, scale=1)
cdf=stats.norm.cdf(x, loc=0, scale=1)
ppf=stats.norm.ppf(x, loc=0, scale=1)
plt.subplot(1,2,1)
plt.hist(simus,20,normed=True,label="simus")
plt.plot(x,pdf,label="pdf")
plt.plot(x,cdf,label="cdf")
plt.legend()
plt.subplot(1,2,2)
plt.plot(x, cdf,label="cdf")
plt.plot(x, ppf,label="ppf")
plt.plot(x, x)
plt.legend()
plt.show()
"""
Dans l'appelle:
simus=stat.norm.rvs(loc=0,scale=1,size=1000)
Tous les arguments sont facultatifs.
Les valeurs par défaut sont logiquement loc=0,scale=1,size=1
On peut écrire par exemple =
simus=stat.norm.rvs(size=1000)
pour
simus=stat.norm.rvs(loc=0,scale=1,size=1000)
par contre si on écrit :
simus=stat.norm.rvs(1000)
cela donne
simus=stat.norm.rvs(loc=1000)
ce qui est sans doute un bug.
Je vous conseille d'écrire le plus souvent le nom des arguments pour éviter ce genre de confusion.
"""
"""
Dans le step0 : Le tracé de la ppf n'est pas très joli, on a l'impression qu'il est incomplet.
Changez cela. Si vous n'avez pas d'idée : la solution est donnée tout en bas de ce fichier.
"""
""" avec une loi discrète """
def step1():
""""""
"""simulons un échantillon"""
n=10
p=0.5
simus=stats.binom.rvs(n, p, size=1000)
x=np.arange(0,n+1)
bins=np.arange(0,n+2)-0.5
pdf=stats.binom.pmf(x, n, p)
cdf=stats.binom.cdf(x, n, p)
plt.hist(simus, bins, normed=True, label="simus")
plt.plot(x, pdf,'o' , label="pdf")
plt.plot(x, cdf,'o', label="cdf")
plt.title("loi binomiale")
plt.legend()
plt.show()
step0()