# Journal de bord du Mooc N_Corduri
## Module 1 : Cahier de notes, cahier de laboratoire
### Exercice 01-1 : Gitlab Recherche / Gitlab Historique
Il est possible dans Gitlab de trouver des fichiers contenant des chaînes de caractères spécifiques en simplement écrivant dans la barre de recherche de Gitlab
la chaîne de caractères souhaitée.
De plus, il est possible de voir toutes les modifications qui ont été effectué sur un fichier et par quelle personne en cherchant dans l'historique du fichier.
Pour cela, il suffit d'aller dans l'onglet 'History' un fois le document ouvert.
Chaque modification dans Gitlab est accompagnée d'un numéro de commit (Exemple : dcdc68a8) et du nom de l'auteur du commit (Exemple : N_Corduri)
### Exercice 01-2 : Ecrire un fichier markdown / Comparer avec la solution
Les différentes syntaxes de base pour écrire en markdown :
| **Syntaxe** | **Symbole** | **Exemple** |
|---|---|---|
|Titre 1|``#``|``# Titre 1``|
|Titre 2|``##``|``## Titre 2``|
|*Italique*|``* *``|``* Une phrase en italique *``|
|**Gras**|``** **``|``** Une phrase en gras **``|
|Lien|``[]()``|``[fun-mooc.fr](https://www.fun-mooc.fr/fr/)``|
|Code|`` ``|``Une ligne de code``|
|Liste à puce| ``-``| `` - item ``|
|Liste numérotée| ``1.``| ``1. item``|
Plus de syntaxes basiques [ici](https://www.markdownguide.org/basic-syntax/) et plus de syntaxes plus spécifiques [ici](https://www.markdownguide.org/extended-syntax/).
### Exercice 01-3 : Ecrire un journal de bord
Ce journal de bord à été écrit en Markdown en utilisant les syntaxes apprises dans l'exercice 01-2.
## Module 2 : La vitrine et l'envers du décor : le document computationnel
Dans ce module il est possible d'utiliser trois outils, à avoir, Jupyter, Rstudio et OrgMode. Dans notre cas nous utilisons Jupyter.
### Exercice 02-1 : Savoir utiliser un notebook
Dans cet exercice il faut reproduire un document [modèle](https://lms.fun-mooc.fr/asset-v1:inria+41016+self-paced+type@asset+block/toy_notebook_fr.pdf) en utilisant Jupyter.
Mon document est [celui-ci](https://app-learninglab.inria.fr/moocrr/jupyter/user/f3525de4a1a18e7596f7a06bd19c9fc1/notebooks/work/module2/exo1/toy_notebook_fr.ipynb).
Il a suffit de reproduire les textes en markdown avec des syntaxes vu précédemment et les morceaux de codes en python.
Pour avoir le même affichage que dans l'exemple il faut enregistrer le document en pdf.
De plus, les équations en markdown s'écrivent comme dans le tableau ci-dessous :
| **Syntaxe** | **Symbole** | **Exemple** |
|---|---|---|
|Equation|``$ $``|``$x + y =1$``|
|Pi|``\pi``| |
|Vague|``\sim``||
|Inférieur ou égale|``\leq``||
### Exercice 02-2 : Savoir faire un calcul simple soi-même
Ce exercice demande de savoir effectuer des calcul simple sur une list de nombre en utilisant la biliothèque de python numpy.
Pour cela il faut utiliser les commandes ci dessous.
| **Calcul** | **Exemple** |
|---|---|
|Créer une liste|``List = [1, 2, 3, ...]``|
|Moyenne|``np.mean(List)``|
|Ecart-type|``np.std(List)``|
|Médiane|``np.median(List)``|
|Minimum|``np.min(List)``|
|Maximum|``np.max(List)``|
Voici le [lien](https://app-learninglab.inria.fr/moocrr/jupyter/user/f3525de4a1a18e7596f7a06bd19c9fc1/notebooks/work/module2/exo2/exercice.ipynb) pour accéder à l'exercice 02-2.
### Exercice 02-3 : Réaliser un affichage graphique
Pour tracer un graphique utiliser ``import matplotlib.pyplot as plt``
| **Calcul** | **Exemple** |
|---|---|
|Graphique|``plt.plot(List)``|
|Histogramme|``plt.hist(List)``|
Voici un [exemple](https://app-learninglab.inria.fr/moocrr/jupyter/user/f3525de4a1a18e7596f7a06bd19c9fc1/notebooks/work/module2/exo3/exercice.ipynb) de graphiques effectués avec cette méthode.
## Module 3 : La main à la pâte : une analyse réplicable
### Exercice 03-1 : Analyse de l'incidence du syndrôme grippal avec une copie locale des données
Dans cet exercice, nous modifions un URL qui nécessite un accès internet par un URL local afin d'être sûr de ne pas avoir de problème lors de l'ouverture du fichier.
Pour cela, nous enregistrons les données localement dans un fichier CSV et nous modifions le code afin que celui-ci utilise le bon fichier.
```
# data_url = "http://www.sentiweb.fr/datasets/incidence-PAY-3.csv"
data_url = "Donnees_Grippe.csv"
```
Pour plus de précision sur le code, voir directement sur le notebook de l'exercice correspondant [ici](https://app-learninglab.inria.fr/moocrr/jupyter/user/f3525de4a1a18e7596f7a06bd19c9fc1/notebooks/work/module3/exo1/analyse-syndrome-grippal.ipynb).
### Exercice 03-2 : Analyse de l'incidence de la varicelle
Afin d'obtenir des résultats similaires à l'exercice précédent, il suffit de reproduire le même code avec les données de la varicelle et en modifiant la date de départ de chaque année à septembre au lieu de aout.
```
# data_url = "https://www.sentiweb.fr/datasets/incidence-PAY-7.csv"
data_url = "Donnees_Varicelle.csv"
```
Et pour effectuer un changement du mois de référence de chaque année de août à septembre :
```
first_august_week = [pd.Period(pd.Timestamp(y, 8, 1), 'W')
for y in range(1985,
sorted_data.index[-1].year)]
```
Devient :
```
first_september_week = [pd.Period(pd.Timestamp(y, 9, 1), 'W')
for y in range(1991,
sorted_data.index[-1].year)]
```
Nous pouvons alors voir que l'année avec le plus de cas de varicelle est l'année 2009 et celle avec le moins de cas est l'année 2020.
Pour plus de précision sur le code, voir directement sur le notebook de l'exercice correspondant [ici](https://app-learninglab.inria.fr/moocrr/jupyter/user/f3525de4a1a18e7596f7a06bd19c9fc1/notebooks/work/module3/exo2/exercice.ipynb).
### Exercice 03-3 : Travail pratique avec évaluation par les pairs
Le but de cet exercice est d'écrire un document computationnel à l'aide de sujets proposés. Dans mon cas j'ai choisi le sujet 7 : Autour du SARS-CoV-2 (Covid-19).
L'exercice a été réalisé sans trop de problème avec la bibliothèque Pandas en python.
Les détails de cet exercice sont disponibles sur le notebook [ici](https://app-learninglab.inria.fr/moocrr/jupyter/user/f3525de4a1a18e7596f7a06bd19c9fc1/notebooks/work/module3/exo3/exercice.ipynb),
mais également sous forme pdf [ici](https://app-learninglab.inria.fr/moocrr/gitlab/f3525de4a1a18e7596f7a06bd19c9fc1/mooc-rr/blob/master/module3/exo3/exercice.pdf)
et sous forme ipynb [ici](https://app-learninglab.inria.fr/moocrr/gitlab/f3525de4a1a18e7596f7a06bd19c9fc1/mooc-rr/blob/master/module3/exo3/exercice.ipynb)
De plus, j'ai corrigé deux documents effectués par deux autres personnes réalisant ce MOOC qui ont été très bien réalisé.
### Exercice Final : Comment reproduire le document computationnel de l'exercice 03-3
Cet exercice a pour but de donner toute la démarche pour que n'importe qui puisse reproduire le document computationnel de l'exercice 03-3 : [Autour du SARS-CoV-2 (Covid-19)](https://app-learninglab.inria.fr/moocrr/gitlab/f3525de4a1a18e7596f7a06bd19c9fc1/mooc-rr/blob/master/module3/exo3/exercice.pdf).
Un document computationnel est un document séparé en plusieurs parties, à savoir des parties de texte en langage de balisage markdown et des parties de code en langage python.
Pour avoir plus d'information sur la manière d'écrire en markdown, se référer aux explications données sur les exercices ci-dessus.
Tout d'abord, ouvrez un document Jupyter.
#### 1. Titre
Donnez un titre à votre document. Pour cela, il est nécessaire de passer de l'écriture "code" à l'écriture "markdown".
Une fois en écriture "markdown" écrivez : "# Ecrire un document computationnel autour du SARS-CoV-2 (Covid-19)", "#" signifiant titre d'ordre 1 en markdown.
Il faudra suivre la même démarche pour toutes les écritures en markdown par la suite.
#### 2. Contexte
Donnez un peu de contexte avec un paragraphe nommé "## Contexte", "##" signifiant titre d'ordre 2.
Le contenu de ce paragraphe est le suivant :
"Le but de cet exercice est d'écrire un document computationnel autour du SARS-CoV-2 (Covid-19). Il faut réaliser une représentaion graphique semblable à celles du [South China Morning Post](https://www.scmp.com/) concernant le nombre total de cas de personne atteintes de la maladie du Covid-19 par pays.
Nous nous concentrons sur les données disponibles à cette [adresse](https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_confirmed_global.csv).
Dans notre cas, nous regarderons les données des pays suivants : la Belgique (Belgium), la Chine - toutes les provinces sauf Hong-Kong (China), Hong Kong (China, Hong-Kong), la France métropolitaine (France), l’Allemagne (Germany), l’Iran (Iran), l’Italie (Italy), le Japon (Japan), la Corée du Sud (Korea, South), la Hollande sans les colonies (Netherlands), le Portugal (Portugal), l’Espagne (Spain), le Royaume-Uni sans les colonies (United Kingdom), les États-Unis (US)."
Utilisez ``[]()`` pour ajouter des liens aux mots souhaités, par exemple : ``[fun-mooc.fr](https://www.fun-mooc.fr/fr/)``.
Dans votre, cas vous allez donner le lien ``https://www.scmp.com/`` à ``South China Morning Post`` afin de donner accès au site d'origine des données que vous allez utiliser aux lecteurs et ``https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_confirmed_global.csv`` à ``adresse`` afin de donner accès aux données brutes aux lecteurs
#### 3. Exploitation des données
Vous allez maintenant traiter les données que vous avez récupérées via le lien ``https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_confirmed_global.csv``.
Votre but est d'extraire les données du nombre de personnes ayant eu le Covid 19 depuis le début de l'épidémie en fonction de la date et du pays parmi les pays que vous avez sélectionnés.
Afin d'avoir exactement les mêmes données datées du 14/10/2022, enregistrez les données suivantes : [ici](https://app-learninglab.inria.fr/moocrr/jupyter/user/f3525de4a1a18e7596f7a06bd19c9fc1/edit/work/module3/exo3/Donn%C3%A9es%20Covid%2019.csv) dans un document .csv nommé "Données Covid 19.csv" dans le même dossier que votre document computationnel.
Pour cela, copier coller les données (clique droit "Tout selectionner", "Copier") dans un fichier "Text" que vous aurez créé dans le même dossier que votre document computationnel et renommez ce fichier "Données Covid 19.csv".
Les différentes annotations en markdown dans cette partie n'étant pas une nécessité pour le fonctionnement du code, elles vous seront données comme ceci : MARKDOWN : "Texte". Si vous voulez avoir exactement le même document, il vous faudra alors les ajouter à votre propre document computationnel.
MARKDOWN : "## Exploitation des données"
MARKDOWN : "Afin de pouvoir traiter ces données en python, il est nécessaire d'importer les bibliothèques python suivantes."
L'avantage de python est de pouvoir utiliser des bibliothèques contenant des fonctions déjà programmées. Vous allez utiliser les bibliothèques ``matplotlib.pyplot``, ``pandas`` et ``isoweek``. Pour cela, écrivez le code suivant :
```
%matplotlib inline
import matplotlib.pyplot as plt
import pandas as pd
import isoweek
```
Le but de cet exercice étant de reproduire le document computationnel et non d'apprendre à écrire en langage python, les passages de codes seront donnés dans les grandes lignes.
Pour les détails n'hésité pas à consulter les documentations de [matplotlib.pyplot](https://matplotlib.org/), [pandas](https://pandas.pydata.org) et de [isoweek](https://pypi.org/project/isoweek/).
MARKDOWN : "Pour ne pas avoir de problème de modification de données entre temps j'enregistre les données localement. Ces données n'évolueront donc pas ce qui évitera des problèmes par la suite. En revanche, la date la plus récentes est le 14/10/2022, date de la sauvegarde local."
Vous pouvez maintenant ouvrir vos données à l'aide de la fonction ``pd.read_csv()``. Pour cela, écrivez le code suivant :
```
# data_url = "https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_confirmed_global.csv"
data_url = "Données Covid 19.csv"
data_raw = pd.read_csv(data_url)
data = data_raw
# display(data)
```
MARKDOWN : "Une fois nos données disponibles, je vais chercher les lignes des pays nous intéressant avec la fonction `.loc()` de la bibliothèque Pandas. Une fois ces données localisées, je vais les regrouper sous forme de DataFrame afin de pouvoir les traiter."
Pour obtenir l'écriture sous la forme de code `.loc()` écrivez ``.loc()``.
Vous pouvez maintenant extraire les données pour chaque pays. Pour cela, il faut tout d'abord les localiser avec la fonction `.loc()` en écrivant le code suivant :
```
Row_Belgium = data.loc[data['Country/Region'] == 'Belgium']
Series_Belgium = pd.Series(data.loc[Row_Belgium.index[0]], name = 'Belgium', dtype = int)
Row_China = data.loc[(data['Country/Region'] == 'China') & (data['Province/State'] != 'Hong Kong')]
Series_China_Total = Row_China.sum()
Row_HongKong = data.loc[data['Province/State'] == 'Hong Kong']
Series_HongKong = pd.Series(data.loc[Row_HongKong.index[0]], name = 'HongKong', dtype = int)
Row_France = data.loc[(data['Province/State'].isna()) & (data['Country/Region'] == 'France')]
Series_France = pd.Series(data.loc[Row_France.index[0]], name = 'France', dtype = int)
Row_Germany = data.loc[data['Country/Region'] == 'Germany']
Series_Germany = pd.Series(data.loc[Row_Germany.index[0]], name = 'Germany', dtype = int)
Row_Iran = data.loc[data['Country/Region'] == 'Iran']
Series_Iran = pd.Series(data.loc[Row_Iran.index[0]], name = 'Iran', dtype = int)
Row_Italy = data.loc[data['Country/Region'] == 'Italy']
Series_Italy = pd.Series(data.loc[Row_Italy.index[0]], name = 'Italy', dtype = int)
Row_Japan = data.loc[data['Country/Region'] == 'Japan']
Series_Japan = pd.Series(data.loc[Row_Japan.index[0]], name = 'Japan', dtype = int)
Row_KoreaSouth = data.loc[data['Country/Region'] == 'Korea, South']
Series_KoreaSouth = pd.Series(data.loc[Row_KoreaSouth.index[0]], name = 'Korea, South', dtype = int)
Row_Netherlands = data.loc[(data['Province/State'].isna()) & (data['Country/Region'] == 'Netherlands')]
Series_Netherlands = pd.Series(data.loc[Row_Netherlands.index[0]], name = 'Netherlands', dtype = int)
Row_Portugal = data.loc[data['Country/Region'] == 'Portugal']
Series_Portugal = pd.Series(data.loc[Row_Portugal.index[0]], name = 'Portugal', dtype = int)
Row_Spain = data.loc[data['Country/Region'] == 'Spain']
Series_Spain = pd.Series(data.loc[Row_Spain.index[0]], name = 'Spain', dtype = int)
Row_UnitedKingdom = data.loc[(data['Province/State'].isna()) & (data['Country/Region'] == 'United Kingdom')]
Series_UnitedKingdom = pd.Series(data.loc[Row_UnitedKingdom.index[0]], name = 'United Kingdom', dtype = int)
Row_US = data.loc[data['Country/Region'] == 'US']
Series_US = pd.Series(data.loc[Row_US.index[0]], name = 'US', dtype = int)
frame = {'Belgium': Series_Belgium,
'China': Series_China_Total,
'Hong Kong': Series_HongKong,
'France': Series_France,
'Germany': Series_Germany,
'Iran': Series_Iran,
'Italy': Series_Italy,
'Japan': Series_Japan,
'Korea, South': Series_KoreaSouth,
'Netherlands': Series_Netherlands,
'Portugal': Series_Portugal,
'Spain': Series_Spain,
'United Kingdom': Series_UnitedKingdom,
'US': Series_US}
selected_data_raw = pd.DataFrame(frame)
selected_data = selected_data_raw[4:].reset_index()
selected_data = selected_data.rename(columns={'index': 'Date'})
# display(selected_data)
```
En plus d'avoir localisé les valeurs des différents pays, celles-ci ont été regroupées dans un dataframe nommé "selected_data" à l'aide de la fonction ``DataFrame()``.
Les fonctions ``reset_index()`` et ``.rename()`` quant à elles permettent de pouvoir classer toutes ces valeurs en fonction de la date à laquelle elles correspondent.
MARKDOWN : "Une fois nos données regroupées dans le DataFrame `selected_data`, je vais alors pouvoir les tracer avec la fonction `.plot()` de la bibliothèque Pandas."
De la même manière que précedemment, pour écrire `selected_data`, écrivez `selected_data` et pour `.plot()`, écrivez ``.plot()``.
Il ne reste plus qu'à tracer les différentes données que vous souhaitez.
Dans un premier temps, vous allez tracer les données de chaque pays en fonction de la date à l'aide de la fonction ``.plot()``. Pour cela, utilisez le code suivant :
```
colors = ['black',
'gray',
'silver',
'brown',
'red',
'coral',
'chocolate',
'orange',
'gold',
'darkgreen',
'lime',
'cyan',
'darkblue',
'magenta'
]
selected_data.plot(x = 'Date',
y = ['Belgium','China','Hong Kong',
'France','Germany','Iran',
'Italy','Japan','Korea, South',
'Netherlands','Portugal','Spain',
'United Kingdom', 'US'],
figsize=(15, 8),
color = colors)
plt.title('Nombre de cas de Covid-19 en fonction de la date et du pays', fontsize = 18)
plt.xlabel('Date',fontsize = 18)
plt.ylabel('Nombre de cas de Covid-19',fontsize = 18)
plt.xticks([0,345,710,996],
[selected_data['Date'][0],
selected_data['Date'][345],
selected_data['Date'][710],
selected_data['Date'][996]],
rotation=45)
plt.grid(which='both', linestyle='--')
```
MARKDOWN : "Nous avons donc un graphique représentant le nombre de cas de Covid-19 en fonction de la date et du pays. Nous allons maintenant refaire ce graphique avec toutes les données de chaque pays selectionné cumulées."
A présent, tracez les données totales de tous ces pays en échelle linéaire, mais aussi en échelle logarithmique.
Pour cela, il est tout d'abord nécessaire d'additionner tous les cas de Covid 19 de chaque pays et de les tracer avec la fonction ``.plot()``.
Pour passer en échelle logarithmique, il suffit d'ajouter la commande ``plt.yscale('log')``.
Pour effectuer tout cela, utilisez le code suivant :
```
selected_data['Total'] = selected_data['Belgium'] + selected_data['China'] + selected_data['France'] + selected_data['Germany'] + selected_data['Hong Kong'] + selected_data['Iran'] + selected_data['Italy'] + selected_data['Japan'] + selected_data['Korea, South'] + selected_data['Netherlands'] + selected_data['Portugal'] + selected_data['Spain'] + selected_data['US'] + selected_data['United Kingdom']
# Echelle linéaire
selected_data.plot(x = 'Date',
y = 'Total',
figsize=(15, 8),)
plt.title('Nombre de cas de Covid-19 total des pays selectionnés en fonction de la date en échelle linéaire', fontsize = 18)
plt.xlabel('Date',fontsize = 18)
plt.ylabel('Nombre de cas de Covid-19',fontsize = 18)
plt.xticks([0,345,710,996],
[selected_data['Date'][0],
selected_data['Date'][345],
selected_data['Date'][710],
selected_data['Date'][996]],
rotation=45)
plt.grid(which='both', linestyle='--')
plt.show()
# Echelle logarithmique
selected_data.plot(x = 'Date',
y = 'Total',
figsize=(15, 8),)
plt.title('Nombre de cas de Covid-19 total des pays selectionnés en fonction de la date en échelle logarithmique', fontsize = 18)
plt.xlabel('Date',fontsize = 18)
plt.ylabel('Nombre de cas de Covid-19',fontsize = 18)
plt.yscale('log')
plt.xticks([0,345,710,996],
[selected_data['Date'][0],
selected_data['Date'][345],
selected_data['Date'][710],
selected_data['Date'][996]],
rotation=45)
plt.grid(which='both', linestyle='--')
plt.show()
```
Votre document computationnel est maintenant terminé. Vous pouvez le télécharger en format .pdf en allant dans "File", "Download as", "PDF via LaTeK" et le comparer avec le [document computationnel d'origine](https://app-learninglab.inria.fr/moocrr/gitlab/f3525de4a1a18e7596f7a06bd19c9fc1/mooc-rr/blob/master/module3/exo3/exercice.pdf).