From 04a56759c0916212e308534b58dd43d7b6640841 Mon Sep 17 00:00:00 2001 From: Patryk Gronkiewicz Date: Sun, 4 Jul 2021 17:26:35 +0200 Subject: [PATCH 01/24] Fix wording --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index a332901..91e3a54 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Corona analysis 1 -This repository is made to gather all data about spreading of SARS-CoV-2 in +This repository exists to gather all data about spreading of SARS-CoV-2 in Poland. ## Requirements From 0d3d79254cd7cc761f127bee0ce31d64ae2ccf80 Mon Sep 17 00:00:00 2001 From: Patryk Gronkiewicz Date: Tue, 6 Jul 2021 19:07:50 +0200 Subject: [PATCH 02/24] refactor: RMF24 - add vaccinations --- corona_analysis/scrapers/rmf24.py | 34 ++++++++++++++++++++----------- 1 file changed, 22 insertions(+), 12 deletions(-) diff --git a/corona_analysis/scrapers/rmf24.py b/corona_analysis/scrapers/rmf24.py index 172b5a8..a479641 100644 --- a/corona_analysis/scrapers/rmf24.py +++ b/corona_analysis/scrapers/rmf24.py @@ -4,6 +4,7 @@ import re from urllib import request +from typing import List, Dict, Any import pandas as pd from bs4 import BeautifulSoup @@ -14,7 +15,7 @@ URL = "https://www.rmf.fm/inc/outer/korona-wykres/wykres.html" -def scrape(data_url: str = URL) -> dict: +def scrape(data_url: str = URL) -> Dict[str, Any]: """ Scrapes data from rmf's chart @@ -34,11 +35,12 @@ def scrape(data_url: str = URL) -> dict: data = str(soup.body.find("script")) # find lists of data - (sick, deaths, recovers) = re.findall(r"\[\[.*\]\]", data) + (sick, deaths, recoveries, vaccinations) = re.findall(r"\[\[.*\]\]", data) sick = sick.split("],[") deaths = deaths.split("],[") - recovers = recovers.split("],[") + recoveries = recoveries.split("],[") + vaccinations = vaccinations.split("],[") sick = [ remove_suffix(remove_prefix(remove_prefix(i, "[["), "Date.UTC"), "]]") @@ -48,23 +50,28 @@ def scrape(data_url: str = URL) -> dict: remove_suffix(remove_prefix(remove_prefix(i, "[["), "Date.UTC"), "]]") for i in deaths ] - recovers = [ + recoveries = [ remove_suffix(remove_prefix(remove_prefix(i, "[["), "Date.UTC"), "]]") - for i in recovers + for i in recoveries + ] + vaccinations = [ + remove_suffix(remove_prefix(remove_prefix(i, "[["), "Date.UTC"), "]]") + for i in vaccinations ] sick = [i.split("),") for i in sick] deaths = [i.split("),") for i in deaths] - recovers = [i.split("),") for i in recovers] + recoveries = [i.split("),") for i in recoveries] + vaccinations = [i.split("),") for i in vaccinations] sick = [["-".join(i[0][1:].split(",")), i[1]] for i in sick] deaths = [["-".join(i[0][1:].split(",")), i[1]] for i in deaths] - recovers = [["-".join(i[0][1:].split(",")), i[1]] for i in recovers] + vaccinations = [["-".join(i[0][1:].split(",")), i[1]] for i in vaccinations] - return {"sick": sick, "deaths": deaths, "recovers": recovers} + return {"sick": sick, "deaths": deaths, "recovers": recoveries, "vaccinations": vaccinations} -def get_data(sick: list, deaths: list, recovers: list) -> dict: +def get_data(sick: List[int], deaths: List[int], recoveries: List[int], vaccinations: List[int]) -> Dict[str, pd.DataFrame]: """ Returns dataframe of deaths, recovered and sick people @@ -86,10 +93,13 @@ def get_data(sick: list, deaths: list, recovers: list) -> dict: deaths = pd.DataFrame(deaths) deaths.columns = ("date", "deaths") - recovers = pd.DataFrame(recovers) - recovers.columns = ("date", "recovers") + recoveries = pd.DataFrame(recoveries) + recoveries.columns = ("date", "recoveries") + + vaccinations = pd.DataFrame(vaccinations) + vaccinations.columns = ("date", "vaccinations") tmp = pd.merge(sick, deaths, how="outer", on="date") - tmp = pd.merge(tmp, recovers, how="outer", on="date") + tmp = pd.merge(tmp, recoveries, how="outer", on="date") return {"rmf24": tmp} From 77acd70f3548c7945d93e6d2814903c86de432d6 Mon Sep 17 00:00:00 2001 From: Patryk Gronkiewicz Date: Tue, 6 Jul 2021 19:28:35 +0200 Subject: [PATCH 03/24] Stop mutating types --- corona_analysis/scrapers/rmf24.py | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/corona_analysis/scrapers/rmf24.py b/corona_analysis/scrapers/rmf24.py index a479641..ddeefeb 100644 --- a/corona_analysis/scrapers/rmf24.py +++ b/corona_analysis/scrapers/rmf24.py @@ -87,19 +87,19 @@ def get_data(sick: List[int], deaths: List[int], recoveries: List[int], vaccinat list of lists with date and amount of recovered people """ - sick = pd.DataFrame(sick) - sick.columns = ("date", "sick") + sickDF = pd.DataFrame(sick) + sickDF.columns = ("date", "sick") - deaths = pd.DataFrame(deaths) - deaths.columns = ("date", "deaths") + deathsDF = pd.DataFrame(deaths) + deathsDF.columns = ("date", "deaths") - recoveries = pd.DataFrame(recoveries) - recoveries.columns = ("date", "recoveries") + recoveriesDF = pd.DataFrame(recoveries) + recoveriesDF.columns = ("date", "recoveries") - vaccinations = pd.DataFrame(vaccinations) - vaccinations.columns = ("date", "vaccinations") + vaccinationsDF = pd.DataFrame(vaccinations) + vaccinationsDF.columns = ("date", "vaccinations") - tmp = pd.merge(sick, deaths, how="outer", on="date") - tmp = pd.merge(tmp, recoveries, how="outer", on="date") + tmp = pd.merge(sickDF, deathsDF, how="outer", on="date") + tmp = pd.merge(tmp, recoveriesDF, how="outer", on="date") return {"rmf24": tmp} From 8733b8bb3f80761e2a6b6898ad6c1f2c7e90498c Mon Sep 17 00:00:00 2001 From: Patryk Gronkiewicz Date: Tue, 6 Jul 2021 19:29:46 +0200 Subject: [PATCH 04/24] Add vaccinations to returned dataframe --- corona_analysis/scrapers/rmf24.py | 1 + 1 file changed, 1 insertion(+) diff --git a/corona_analysis/scrapers/rmf24.py b/corona_analysis/scrapers/rmf24.py index ddeefeb..ecba9d2 100644 --- a/corona_analysis/scrapers/rmf24.py +++ b/corona_analysis/scrapers/rmf24.py @@ -101,5 +101,6 @@ def get_data(sick: List[int], deaths: List[int], recoveries: List[int], vaccinat tmp = pd.merge(sickDF, deathsDF, how="outer", on="date") tmp = pd.merge(tmp, recoveriesDF, how="outer", on="date") + tmp = pd.merge(tmp, vaccinationsDF, how="outer", on="date") return {"rmf24": tmp} From 3df1b6732b62d1a4f4ca1c8fb494f8a02dd67148 Mon Sep 17 00:00:00 2001 From: Patryk Gronkiewicz Date: Tue, 6 Jul 2021 19:31:21 +0200 Subject: [PATCH 05/24] Add documentation of return type for get_data fun --- corona_analysis/scrapers/rmf24.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/corona_analysis/scrapers/rmf24.py b/corona_analysis/scrapers/rmf24.py index ecba9d2..e72bba9 100644 --- a/corona_analysis/scrapers/rmf24.py +++ b/corona_analysis/scrapers/rmf24.py @@ -75,8 +75,6 @@ def get_data(sick: List[int], deaths: List[int], recoveries: List[int], vaccinat """ Returns dataframe of deaths, recovered and sick people - ... - Attributes ---------- sick : list @@ -85,6 +83,11 @@ def get_data(sick: List[int], deaths: List[int], recoveries: List[int], vaccinat list of lists with date and amount of dead people recovers : list list of lists with date and amount of recovered people + + Returns + ------- + dict + "rmf24" with dataframe """ sickDF = pd.DataFrame(sick) From 4519dc5c758024d504837c0a1dd44a2b262798c2 Mon Sep 17 00:00:00 2001 From: Patryk Gronkiewicz Date: Wed, 7 Jul 2021 21:00:27 +0200 Subject: [PATCH 06/24] Create proper shell.nix to work with jupyter --- shell.nix | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/shell.nix b/shell.nix index 74aa316..a2fc300 100644 --- a/shell.nix +++ b/shell.nix @@ -1,9 +1,17 @@ let - _default = "conda,nixpkgs,wheel"; mach-nix = import (builtins.fetchGit { url = "https://github.com/DavHau/mach-nix/"; - ref = "master"; - }) {}; -in mach-nix.mkPythonShell { - requirements = builtins.readFile ./requirements.txt; + ref = "refs/tags/3.3.0"; + }) { + # optionally bring your own nixpkgs + # pkgs = import {}; + + # optionally specify the python version + python = "python38"; + }; +in +mach-nix.mkPythonShell { + requirements = '' +${builtins.readFile ./requirements.txt} +jupyterlab''; } From c7d31d2e47aa3f0861a393d555989ee5527d7e12 Mon Sep 17 00:00:00 2001 From: Patryk Gronkiewicz Date: Wed, 7 Jul 2021 21:03:13 +0200 Subject: [PATCH 07/24] Add sklearn as dependency --- requirements.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 431896f..79123a4 100644 --- a/requirements.txt +++ b/requirements.txt @@ -2,4 +2,5 @@ pandas beautifulsoup4 demjson statsmodels -seaborn \ No newline at end of file +seaborn +sklearn From be64d917b6c34353b77d6530e484cb089629de66 Mon Sep 17 00:00:00 2001 From: Patryk Gronkiewicz Date: Wed, 7 Jul 2021 21:05:02 +0200 Subject: [PATCH 08/24] add ipywidgets as dep --- requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements.txt b/requirements.txt index 79123a4..f0800fd 100644 --- a/requirements.txt +++ b/requirements.txt @@ -4,3 +4,4 @@ demjson statsmodels seaborn sklearn +ipywidgets From 94a40df2589b2fc61c3eb3cae8d2041eab4d6b3c Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Wed, 7 Jul 2021 19:19:03 +0000 Subject: [PATCH 09/24] Restyled by autopep8 --- corona_analysis/scrapers/rmf24.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/corona_analysis/scrapers/rmf24.py b/corona_analysis/scrapers/rmf24.py index e72bba9..19aa642 100644 --- a/corona_analysis/scrapers/rmf24.py +++ b/corona_analysis/scrapers/rmf24.py @@ -66,7 +66,8 @@ def scrape(data_url: str = URL) -> Dict[str, Any]: sick = [["-".join(i[0][1:].split(",")), i[1]] for i in sick] deaths = [["-".join(i[0][1:].split(",")), i[1]] for i in deaths] - vaccinations = [["-".join(i[0][1:].split(",")), i[1]] for i in vaccinations] + vaccinations = [["-".join(i[0][1:].split(",")), i[1]] + for i in vaccinations] return {"sick": sick, "deaths": deaths, "recovers": recoveries, "vaccinations": vaccinations} From 317861db92f7b08b6776989475d2a75516ab40fc Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Wed, 7 Jul 2021 19:19:11 +0000 Subject: [PATCH 10/24] Restyled by black --- corona_analysis/scrapers/rmf24.py | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/corona_analysis/scrapers/rmf24.py b/corona_analysis/scrapers/rmf24.py index 19aa642..2c5b056 100644 --- a/corona_analysis/scrapers/rmf24.py +++ b/corona_analysis/scrapers/rmf24.py @@ -66,13 +66,19 @@ def scrape(data_url: str = URL) -> Dict[str, Any]: sick = [["-".join(i[0][1:].split(",")), i[1]] for i in sick] deaths = [["-".join(i[0][1:].split(",")), i[1]] for i in deaths] - vaccinations = [["-".join(i[0][1:].split(",")), i[1]] - for i in vaccinations] + vaccinations = [["-".join(i[0][1:].split(",")), i[1]] for i in vaccinations] - return {"sick": sick, "deaths": deaths, "recovers": recoveries, "vaccinations": vaccinations} + return { + "sick": sick, + "deaths": deaths, + "recovers": recoveries, + "vaccinations": vaccinations, + } -def get_data(sick: List[int], deaths: List[int], recoveries: List[int], vaccinations: List[int]) -> Dict[str, pd.DataFrame]: +def get_data( + sick: List[int], deaths: List[int], recoveries: List[int], vaccinations: List[int] +) -> Dict[str, pd.DataFrame]: """ Returns dataframe of deaths, recovered and sick people From d0924db35505cd59e74b2123f71eef903a20be2a Mon Sep 17 00:00:00 2001 From: Piotr Krawiec Date: Wed, 7 Jul 2021 15:53:21 +0200 Subject: [PATCH 11/24] fix scraper - fix scrpit tag pattern - fix column names --- corona_analysis/scrapers/koronawirusunas.py | 132 +++++++++++--------- requirements.txt | 1 + 2 files changed, 77 insertions(+), 56 deletions(-) diff --git a/corona_analysis/scrapers/koronawirusunas.py b/corona_analysis/scrapers/koronawirusunas.py index 542736a..c43600d 100644 --- a/corona_analysis/scrapers/koronawirusunas.py +++ b/corona_analysis/scrapers/koronawirusunas.py @@ -6,24 +6,26 @@ import numpy as np URL = "https://www.koronawirusunas.pl/{}" -PATTERN = re.compile(r"var\sdataSource_przyrost") -SUB_SITES = ("", - "wojewodztwo-slaskie", - "wojewodztwo-mazowieckie", - "wojewodztwo-dolnoslaskie", - "wojewodztwo-wielkopolskie", - "wojewodztwo-lodzkie", - "wojewodztwo-malopolskie", - "wojewodztwo-opolskie", - "wojewodztwo-kujawsko-pomorskie", - "wojewodztwo-pomorskie", - "wojewodztwo-zachodniopomorskie", - "wojewodztwo-podlaskie", - "wojewodztwo-lubelskie", - "wojewodztwo-podkarpackie", - "wojewodztwo-swietokrzyskie", - "wojewodztwo-warminsko-mazurskie", - "wojewodztwo-lubuskie") +PATTERN = re.compile(r"var dataSource_przyrost|var dataSource_koronawirus") +SUB_SITES = ( + "", + "wojewodztwo-slaskie", + "wojewodztwo-mazowieckie", + "wojewodztwo-dolnoslaskie", + "wojewodztwo-wielkopolskie", + "wojewodztwo-lodzkie", + "wojewodztwo-malopolskie", + "wojewodztwo-opolskie", + "wojewodztwo-kujawsko-pomorskie", + "wojewodztwo-pomorskie", + "wojewodztwo-zachodniopomorskie", + "wojewodztwo-podlaskie", + "wojewodztwo-lubelskie", + "wojewodztwo-podkarpackie", + "wojewodztwo-swietokrzyskie", + "wojewodztwo-warminsko-mazurskie", + "wojewodztwo-lubuskie", +) def scrape(url=URL) -> dict: @@ -35,11 +37,10 @@ def scrape(url=URL) -> dict: soup = BeautifulSoup(web.read(), "lxml") # Get first script tag that contains PATTERN - script = soup.find('script', text=PATTERN) + script = soup.find("script", text=re.compile(PATTERN)) # Group all vars to ('var name,'[data]') - jsdata = re.findall( - r'var\s*(.*?)\s*=(\s*\[[\s\S]*?\]);', script.string) + jsdata = re.findall(r"var\s*(.*?)\s*=(\s*\[[\s\S]*?]);", script.string) return {t[0]: pd.DataFrame(demjson.decode(t[1])) for t in jsdata} @@ -80,8 +81,9 @@ def clean_regions(data: dict): data[key].fillna(axis=1, inplace=True, value=0) data[key]["wojewodztwo"] = np.nan data[key].fillna(axis=1, inplace=True, value=key) - data[key]["date"] = (data[key].index - data[ - key].index.min()) / np.timedelta64(1, 'D') + data[key]["date"] = ( + data[key].index - data[key].index.min() + ) / np.timedelta64(1, "D") df_regions = df_regions.append(data[key]) return df_regions @@ -96,8 +98,8 @@ def clean_country(data: pd.DataFrame): data : pd.DataFrame dict containing pd.DataFrame """ - data['kwar_z'].fillna(0, inplace=True) - data.fillna(method='ffill', inplace=True) + data["kwar_z"].fillna(0, inplace=True) + data.fillna(method="ffill", inplace=True) data.fillna(0, inplace=True) return data @@ -112,46 +114,64 @@ def get_data(): data = [scrape(url=URL.format(sub)) for sub in SUB_SITES] # Clean data for whole country - testy = clean(data[0]["dataSource_testy"], - cols=data[0]["dataSource_testy"].columns, - new_index_name="dzien") - - przyrost = clean(data[0]["dataSource_przyrost"], - cols=["country", "zar", "chor", "zgo", "wyl"], - new_index_name="country") - - mobilnosc = clean(data[0]["dataSource_mobilnosc"], - cols=["dzien", "pieszo", "pojazdem"], - new_index_name="dzien") - - hospitalizacja = clean(data[0]["dataSource_hospitalizacja"], - cols=["country", "hosp", - "kwar", "kwar_z", "nadzor"], - new_index_name="country") + testy = clean( + data[0]["dataSource_testy"], + cols=data[0]["dataSource_testy"].columns, + new_index_name="dzien", + ) + + przyrost = clean( + data[0]["dataSource_przyrost"], + cols=["country", "zar", "chor", "zgo", "wyl"], + new_index_name="country", + ) + + mobilnosc = clean( + data[0]["dataSource_mobilnosc"], + cols=["dzien", "chorzy_prev", "pieszo", "pojazdem"], + new_index_name="dzien", + ) + + hospitalizacja = clean( + data[0]["dataSource_hospitalizacja"], + cols=["country", "kwar", "kwar_z", "nadzor"], + new_index_name="country", + ) # Clean each region - regions = {SUB_SITES[i][12:]: clean(data[i]["dataSource_przyrost"], - cols=["country", "zar", "chor", - "zgo", "wyl"], - new_index_name="country") - for i in range(1, len(data))} + regions = { + SUB_SITES[i][12:]: clean( + data[i]["dataSource_koronawirus"], + cols=["dzien", "woj_zar", "woj_chor", "woj_zgo", "woj_wyl"], + new_index_name="dzien", + ) + for i in range(1, len(data)) + } df_regions = clean_regions(regions) # Merge and return DataFrames - df_poland = pd.merge(testy, przyrost, how='outer', left_index=True, - right_index=True) - df_poland = pd.merge(df_poland, mobilnosc, how='outer', left_index=True, - right_index=True) - df_poland = pd.merge(df_poland, hospitalizacja, how='outer', - left_index=True, - right_index=True) + df_poland = pd.merge( + testy, przyrost, how="outer", left_index=True, right_index=True + ) + df_poland = pd.merge( + df_poland, mobilnosc, how="outer", left_index=True, right_index=True + ) + df_poland = pd.merge( + df_poland, + hospitalizacja, + how="outer", + left_index=True, + right_index=True, + ) df_poland = clean_country(df_poland) - return {"koronawirusunas_poland": df_poland, - "koronawirusunas_regions": df_regions} + return { + "koronawirusunas_poland": df_poland, + "koronawirusunas_regions": df_regions, + } -if __name__ == '__main__': +if __name__ == "__main__": print(get_data()) diff --git a/requirements.txt b/requirements.txt index 431896f..ec60e37 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,3 +1,4 @@ +numpy pandas beautifulsoup4 demjson From c298fa374e1edf6e2bff209b66e6fcd76fefee97 Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Wed, 7 Jul 2021 13:56:43 +0000 Subject: [PATCH 12/24] Restyled by black --- corona_analysis/scrapers/koronawirusunas.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/corona_analysis/scrapers/koronawirusunas.py b/corona_analysis/scrapers/koronawirusunas.py index c43600d..21d5d6f 100644 --- a/corona_analysis/scrapers/koronawirusunas.py +++ b/corona_analysis/scrapers/koronawirusunas.py @@ -81,9 +81,9 @@ def clean_regions(data: dict): data[key].fillna(axis=1, inplace=True, value=0) data[key]["wojewodztwo"] = np.nan data[key].fillna(axis=1, inplace=True, value=key) - data[key]["date"] = ( - data[key].index - data[key].index.min() - ) / np.timedelta64(1, "D") + data[key]["date"] = (data[key].index - data[key].index.min()) / np.timedelta64( + 1, "D" + ) df_regions = df_regions.append(data[key]) return df_regions From 36470f3ab77b38554e21d24897fb45f15dd40123 Mon Sep 17 00:00:00 2001 From: Patryk Gronkiewicz Date: Sat, 10 Jul 2021 10:45:04 +0200 Subject: [PATCH 13/24] refactor get_data to receive url only --- corona_analysis/scrapers/rmf24.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/corona_analysis/scrapers/rmf24.py b/corona_analysis/scrapers/rmf24.py index e72bba9..32b85f6 100644 --- a/corona_analysis/scrapers/rmf24.py +++ b/corona_analysis/scrapers/rmf24.py @@ -4,7 +4,7 @@ import re from urllib import request -from typing import List, Dict, Any +from typing import List, Dict, Any, Optional import pandas as pd from bs4 import BeautifulSoup @@ -71,7 +71,7 @@ def scrape(data_url: str = URL) -> Dict[str, Any]: return {"sick": sick, "deaths": deaths, "recovers": recoveries, "vaccinations": vaccinations} -def get_data(sick: List[int], deaths: List[int], recoveries: List[int], vaccinations: List[int]) -> Dict[str, pd.DataFrame]: +def get_data(url: str = URL) -> Dict[str, pd.DataFrame]: """ Returns dataframe of deaths, recovered and sick people @@ -89,17 +89,18 @@ def get_data(sick: List[int], deaths: List[int], recoveries: List[int], vaccinat dict "rmf24" with dataframe """ + data = scrape(URL) - sickDF = pd.DataFrame(sick) + sickDF = pd.DataFrame(data["sick"]) sickDF.columns = ("date", "sick") - deathsDF = pd.DataFrame(deaths) + deathsDF = pd.DataFrame(data["deaths"]) deathsDF.columns = ("date", "deaths") - recoveriesDF = pd.DataFrame(recoveries) + recoveriesDF = pd.DataFrame(data["recoveries"]) recoveriesDF.columns = ("date", "recoveries") - vaccinationsDF = pd.DataFrame(vaccinations) + vaccinationsDF = pd.DataFrame(data["vaccinations"]) vaccinationsDF.columns = ("date", "vaccinations") tmp = pd.merge(sickDF, deathsDF, how="outer", on="date") From 09fa393c1dd493f6ff2aeb48c3ba48755c358deb Mon Sep 17 00:00:00 2001 From: Patryk Gronkiewicz Date: Sat, 10 Jul 2021 10:49:42 +0200 Subject: [PATCH 14/24] refactor to match scheme --- corona_analysis/scrapers/rmf24.py | 1 - requirements.txt | 1 + 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/corona_analysis/scrapers/rmf24.py b/corona_analysis/scrapers/rmf24.py index 944d195..f24461e 100644 --- a/corona_analysis/scrapers/rmf24.py +++ b/corona_analysis/scrapers/rmf24.py @@ -19,7 +19,6 @@ def scrape(data_url: str = URL) -> Dict[str, Any]: """ Scrapes data from rmf's chart - ... Attributes ---------- diff --git a/requirements.txt b/requirements.txt index f0800fd..8425986 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,5 @@ pandas +numpy beautifulsoup4 demjson statsmodels From 7f73f79e301bec585acaaf6c0fd4ee1f1a8facff Mon Sep 17 00:00:00 2001 From: Patryk Gronkiewicz Date: Sat, 10 Jul 2021 11:30:40 +0200 Subject: [PATCH 15/24] remove unused imports --- corona_analysis/scrapers/rmf24.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/corona_analysis/scrapers/rmf24.py b/corona_analysis/scrapers/rmf24.py index f24461e..865b95f 100644 --- a/corona_analysis/scrapers/rmf24.py +++ b/corona_analysis/scrapers/rmf24.py @@ -4,7 +4,7 @@ import re from urllib import request -from typing import List, Dict, Any, Optional +from typing import Dict, Any import pandas as pd from bs4 import BeautifulSoup From fe80b62cf5460da8bcf8fdaedc7ee2e0dbc09c1c Mon Sep 17 00:00:00 2001 From: Piotr Krawiec Date: Fri, 16 Jul 2021 17:12:39 +0200 Subject: [PATCH 16/24] add data sources --- presentation.md | 27 ++++++++++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/presentation.md b/presentation.md index f014c60..fd848d0 100644 --- a/presentation.md +++ b/presentation.md @@ -7,5 +7,30 @@ abstract: | Lorem ipsum dolor sit amet --- -# Document Title +# Źródła danych + +To było pierwszym sporym wyzwaniem w naszym projekcie, ponieważ szczególnie na początku +pandemii dostęp do szczegółowych danych nie był tak prosty, ponieważ: +- na stronie ministerstwa publikowane były wyłącznie dane z danego dnia. +- publicznie dostępne dane dotyczące wielu krajów nie zawierały podziału na województwa. + +Na szczęście udało nam się znaleźć inne źródła, tj. strony tworzone przez ludzi, którzy +codziennie sami zbierali te dane i udostępniali je w formie wykresów. Przykładem takiej +strony jest koronawirusunas.pl . Dzięki danym na niej zawartym udało nam się +przeprowadzić. + +Do głównych źródeł danych zaliczyć możemy: +- IHME +- koronawirusunas.pl +- policja.pl + +# Techniki zbierania danych + +Główną techniką wykorzystywaną przez nas wył web scraping, stworzyliśmy skrypty, które +(oczywiście za zgodą właścicieli portali) pobierały z nich bieżące dane. Z kolei pozostałe +dane były udostępnione publicznie w formie skompresowanych plików, także aktualizowanych +codziennie. + + +![](img/zar.png) \ No newline at end of file From cd2dda106aea30a40e5c8937a7eb8716fadb08ad Mon Sep 17 00:00:00 2001 From: Piotr Krawiec Date: Sun, 18 Jul 2021 15:07:24 +0200 Subject: [PATCH 17/24] add desc of data manipulation --- presentation.md | 39 +++++++++++++++++++++++++++------------ 1 file changed, 27 insertions(+), 12 deletions(-) diff --git a/presentation.md b/presentation.md index fd848d0..c1d0027 100644 --- a/presentation.md +++ b/presentation.md @@ -7,30 +7,45 @@ abstract: | Lorem ipsum dolor sit amet --- - # Źródła danych -To było pierwszym sporym wyzwaniem w naszym projekcie, ponieważ szczególnie na początku -pandemii dostęp do szczegółowych danych nie był tak prosty, ponieważ: +To było pierwszym sporym wyzwaniem w naszym projekcie, ponieważ szczególnie na +początku pandemii dostęp do szczegółowych danych nie był tak prosty, ponieważ: + - na stronie ministerstwa publikowane były wyłącznie dane z danego dnia. -- publicznie dostępne dane dotyczące wielu krajów nie zawierały podziału na województwa. +- publicznie dostępne dane dotyczące wielu krajów nie zawierały podziału na + województwa. -Na szczęście udało nam się znaleźć inne źródła, tj. strony tworzone przez ludzi, którzy -codziennie sami zbierali te dane i udostępniali je w formie wykresów. Przykładem takiej -strony jest koronawirusunas.pl . Dzięki danym na niej zawartym udało nam się -przeprowadzić. +Na szczęście udało nam się znaleźć inne źródła, tj. strony tworzone przez ludzi, +którzy codziennie sami zbierali te dane i udostępniali je w formie wykresów. +Przykładem takiej strony jest koronawirusunas.pl . Dzięki danym na niej zawartym +udało nam się przeprowadzić. Do głównych źródeł danych zaliczyć możemy: + - IHME - koronawirusunas.pl - policja.pl # Techniki zbierania danych -Główną techniką wykorzystywaną przez nas wył web scraping, stworzyliśmy skrypty, które -(oczywiście za zgodą właścicieli portali) pobierały z nich bieżące dane. Z kolei pozostałe -dane były udostępnione publicznie w formie skompresowanych plików, także aktualizowanych -codziennie. +Główną techniką wykorzystywaną przez nas wył web scraping, stworzyliśmy skrypty, +które +(oczywiście za zgodą właścicieli portali) pobierały z nich bieżące dane. Z kolei +pozostałe dane były udostępnione publicznie w formie skompresowanych plików, +także aktualizowanych codziennie. + +# Jak pracowaliśmy z danymi + +Te dane musiały zostac sprowadzone do wspólnego formatu, tak aby wszystkie +stworzone wykresy i analizy można było odtwarzać natychmiast po aktualizacji +danych. Do tego wykorzystaliśmy pythona i Jupyterlab. +Z pomoca jupyterlab można stworzyć interaktywne notatniki, które działają krok +po kroku, jeden z nich służył wyłącznie do pobrania danych ze wszystkich źródeł +ich oczyszczenia i sprowadzenia do wspólnego formatu. Same analizy znalazły się +w osobnym notatniku, co umożliwiło nam zapanowanie nad projektem. Oczywiście +korzystanie z notatników też ma swoje wady, kolejne zmiany utrzymywane w +systemie kontroli wersji Git nie są czytalne. ![](img/zar.png) \ No newline at end of file From a292649ec8eedcac208580aa4feaa06657664d5a Mon Sep 17 00:00:00 2001 From: Piotr Krawiec Date: Sun, 11 Jul 2021 20:50:52 +0200 Subject: [PATCH 18/24] add pairplots and begin ARIMA modeling --- notebooks/Analiza.ipynb | 573 ++++++++++++++++++++++++++++++++++------ 1 file changed, 497 insertions(+), 76 deletions(-) diff --git a/notebooks/Analiza.ipynb b/notebooks/Analiza.ipynb index 0f5f132..efd550f 100644 --- a/notebooks/Analiza.ipynb +++ b/notebooks/Analiza.ipynb @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 81, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -36,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": 82, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -45,10 +45,9 @@ "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "import datetime\n", - "from src.utils import save\n", - "from src.utils import save, paths\n", + "from corona_analysis.utils import save, paths\n", "from pathlib import Path\n", - "from src.scrapers import healthdata, koronawirusunas, meteostat, policjapl, rmf24, wiki_demo, wiki_urban" + "from corona_analysis.scrapers import healthdata, koronawirusunas, meteostat, policjapl, rmf24, wiki_demo, wiki_urban" ] }, { @@ -60,7 +59,7 @@ }, { "cell_type": "code", - "execution_count": 83, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -76,7 +75,7 @@ }, { "cell_type": "code", - "execution_count": 84, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -230,7 +229,7 @@ "[3 rows x 39 columns]" ] }, - "execution_count": 84, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -241,7 +240,7 @@ }, { "cell_type": "code", - "execution_count": 85, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -395,7 +394,7 @@ "[3 rows x 39 columns]" ] }, - "execution_count": 85, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -406,7 +405,7 @@ }, { "cell_type": "code", - "execution_count": 86, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -423,7 +422,7 @@ }, { "cell_type": "code", - "execution_count": 87, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -439,7 +438,7 @@ }, { "cell_type": "code", - "execution_count": 88, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -457,7 +456,7 @@ }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -475,7 +474,7 @@ }, { "cell_type": "code", - "execution_count": 90, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -571,7 +570,7 @@ "[1 rows x 42 columns]" ] }, - "execution_count": 90, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -596,21 +595,21 @@ }, { "cell_type": "code", - "execution_count": 91, + "execution_count": 16, "metadata": { - "jupyter": { - "source_hidden": true - } + "tags": [] }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -633,17 +632,27 @@ }, { "cell_type": "code", - "execution_count": 92, + "execution_count": 17, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/pk/miniconda3/envs/corona-analysis-1/lib/python3.8/site-packages/pandas/core/indexing.py:719: FutureWarning: Slicing a positional slice with .loc is not supported, and will raise TypeError in a future version. Use .loc with labels or .iloc with positions instead.\n", + " indexer = self._get_setitem_indexer(key)\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -669,7 +678,7 @@ }, { "cell_type": "code", - "execution_count": 93, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -684,7 +693,7 @@ "Name: confirmed_infections, dtype: float64" ] }, - "execution_count": 93, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -695,7 +704,7 @@ }, { "cell_type": "code", - "execution_count": 94, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -710,7 +719,7 @@ "Name: pieszo, dtype: float64" ] }, - "execution_count": 94, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -721,22 +730,22 @@ }, { "cell_type": "code", - "execution_count": 95, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "label\n", - "0.0 11.0\n", - "1.0 18.0\n", - "2.0 18.0\n", - "3.0 18.0\n", - "4.0 12.0\n", - "Name: pieszo, dtype: float64" + "0.0 11\n", + "1.0 18\n", + "2.0 18\n", + "3.0 18\n", + "4.0 12\n", + "Name: pieszo, dtype: int64" ] }, - "execution_count": 95, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -747,7 +756,7 @@ }, { "cell_type": "code", - "execution_count": 96, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -762,7 +771,7 @@ "Name: pieszo, dtype: float64" ] }, - "execution_count": 96, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -773,7 +782,7 @@ }, { "cell_type": "code", - "execution_count": 97, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -788,7 +797,7 @@ "Name: confirmed_infections, dtype: float64" ] }, - "execution_count": 97, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -799,21 +808,19 @@ }, { "cell_type": "code", - "execution_count": 98, - "metadata": { - "jupyter": { - "source_hidden": true - } - }, + "execution_count": 23, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -840,17 +847,19 @@ }, { "cell_type": "code", - "execution_count": 99, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -871,17 +880,19 @@ }, { "cell_type": "code", - "execution_count": 100, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -901,17 +912,19 @@ }, { "cell_type": "code", - "execution_count": 101, + "execution_count": 26, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -931,17 +944,19 @@ }, { "cell_type": "code", - "execution_count": 102, + "execution_count": 27, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAJPCAYAAACQObveAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABB9ElEQVR4nO3deZxkVX3//9d7GNSRUVklzaKQOI6ouOC4xSVEFHHJlyVGSTQDSEIWo2YxXzUm0bjkp8k3bllUogTGuBEDka8xKkEH9WsQB0VckMy4IEsLw7Do6AQZ5/P7456Gounu6Znp6u2+no9HP/rWuUudc6vq1rvOuVU3VYUkSVIfLZnrCkiSJM0Vg5AkSeotg5AkSeotg5AkSeotg5AkSeotg5AkSeotgxCQ5ElJrtiF9Q9JUkmWzmS9ZkOS5yf55DyoRyV5wFzXAyDJ2iS/MdvrLmRJfinJ55Is385y90uyOcluM3jfu/T6S/LdJE+d5rJfT3LkztzPuO38SZJ37+p22rZek+Sf2/SCPRZNR5Izk7x+knnvTPJn09jGrL5Gh/GcH7f9v0/y2u0sM2+Or/NRr4LQZAe8qvpsVa2cizrNtap6X1UdPdf10PywMwfMJIcDfwg8q6o2T7VsVX2vqpZX1U93pZ5zpaoeUlVrZ2A7f1lVvQvMOyLJyUk+N93lq+q3q+p1w6zTzhjmcz7JacCtVfXnM7CtHdrfi8mi/NQgSLK0qrbOdT20+FXVV4FfnOt6SH1TVafPdR0Wg171CE0myZFJrh64fXCSc5JsTLIpyd+18q+0Ls6xvxrXTf7CJNcmGU3ysoHtPSbJfyW5uc37uyR3m6QufzfuPrYmeU2b94ok30rywyTfSHL8wHonJ/l/Sd6SZBPwmiQ/l+RTrQ03JHlfkj3b8seMu5//SXJpm3f3JG9tbbm2Td99cF8l+aMk17f2nNLmPTrJdYNdwElOSPKVNr1bGxIYa8MlSQ4eaP5Tk6xv++nvk2SC/XOPJFuS7Ntuv6rto3u3269r9T1gXPt+nKQG6vE3bZ98J8nvTTWckOSFSS5v2zkvyV4D856W5JtJbmnPk0yy7k1JPpHk/gPzKsnvtjb/sNX955J8PskPkpw9xfNkyjYkuU+S97TH5/okfziw7gOSXNjqfEOSD7Xyz7RFvtLa+rxW/ptJNiS5sbX/gFae9ny7vtX3q0ke2uYta/W7st3P51rZpEM3SZ437jG7NcnaNu9ZSb7c7ueqtNfEJPvmTj2/GRg6ard/vdVrU5JXjVv3NW2/r2mPydeTrJpo20mW5I7X5Ka23t5t3lg7T0ryvbafXzVFnf4lyffbvvpMkodM0b5D2+P3wyTnA/tOsewp7fn3wyTfTvJbUyx7ZZJHtennt/o/pN0+Ncm/tenHJFnXHovrkry5lU947Eryx0n+ddx9vT3J29r0ya1uP0z3XH5+ksOAdwKPb9u6eYL63ivJp9u2knHDZkmOTXJpq+e3khwzsPr90x0vf5jkk2nHkwnu48Ikv9ymn9D2ybPa7aNyxzFzSZI/bfvw+vb8uU+bd6fnfO782rwmyevTjpk78BhMeoxu8/+4bf/aJC8cKJ/wuDjR/m7Ps5uTLGnr/mOS6we29d4kvz/Rfltwqqo3f8B3gadOUH4kcHWb3g34CvAWYA/gHsATJ1jnNOCbwL2BQ4ACPtDWORzYOHZfwKOAx9H1wB0CXA78/jTq+4i2nUe2278CHEAXYJ8H/AgYafNOBrYCL273swx4APA04O7AfsBngLdOcD93B/4LeHm7/VrgIuC+bb3PA68b2Fdb2zK7A88Efgzs1eZ/A3jGwLbPBf6oTf8x8FVgJV1geDiwT5tXwEeBPYH7tXYfM8l++Qzwy236k8C3xu6zzTt+gnXeB3ygTf92q+dBwF7Af7b7X9rmrwV+o00fC2wGjgLu2bbz7jZvX+CHwHPavviDtm8G190AHNYekz8FPj9QpwI+QvcceghwK3AB8LPAfVodT5pkH2yvDecCn22P30pglPY8pnuevorueXSn53fbxgMGbj8FuAE4oj1P/hb4TJv3dOCS9piltXPs+fj3bT8eSPea+vm2/iGD9ZziuX9vutfJbw087w5vdX4YcB1wXJt3p20y7nUOvAb45zb94PZ4PrnV583tMXvqwLL/Q/e83g34/4CLJjqGAC+le50c1Lb1Lu54jo3V6R/pXosPb4/vYePr1G6/ELhX285bgUun2Df/1ep999aOHw60b/y+eBbwc+3x+QW61+oRk2x3DXe8Vk+ne139zsC8Pxi4/19v08uBx0117AJG6I5Ve7Z5S4Hr6Y6LewA/AFa2eSPAQwaOaZ8bt90zgdcD+wAXA68fP69NPwa4he74t4Tuefiggdf3t4AHtsdmLfDGSfbJa4G/bdN/0tZ708C8tw08fhvoXrvLgXOA907ymJxL91zZg+4YezF3PM+n+xhMdYw+hu718dB2H+9n3Ot6kuPiRPv7e8Cj2vQVwLe54zn8Pdp700L/m/MKzGpjpxeEHt9ewJMeqIEnthfyA9vtsSf6gwaW+SvgPZOs//vAudup636tvidOscylwLFt+mTge9vZ5nHAlycoPwt4/8DtbwHPHLj9dOC7A/tqy+D+afvicW365cD72vTedAfesTfHK8bqO0Ediju/IZ8NvGKSZV8HvJ3ugPp9ujekN9K9qW+hhauB5V9O94a9rN3+FO3A024/lcmD0H8Abx9Y9n7tPvYAVnPnN8kAV49b99SB+Uva/rj/QJufMDD/EloYbbf/hgmC6/baAOzfpo8YmP/n3HFgXkN3kD1oksdhMAi9B/irgdvLgdvonvNPAf6bLuQvGdfOLcDDJ9j+IWwnCLX1Pwq8Y4pl3gq8ZaJtMnUQ+nPggwPz9gB+wp2D0H8OzH8wsGXg9ncHlr0cOGpg3kjbN2MfeGpwH9O94Z04vk4TtG3Ptu59Jph3P7rgtsdA2fuZJAhNsP6/AS+dZN6pwHkDbfuNsX0FXDn2fKL7sPEXwL6TbOcuxy6618JvtulnA98Y2P83A79Me30OrHMyEwehM4CvAX88wbyxIPSusefHBPVbC/zpwO3fBT4+ybJHAZe16Y+3fXJRu30hcEKbvgD43YH1Vk7wXBh7bd462FbgV4FP7+BjMNUx+gwGgh1d4LtLEOKux8WJ9vd76c7/+xm64/df0X0IO7Q9bksm2m8L7c+hsbs6GLiyJjm/Jt1Qztl0n9T/e9zsqwamr6TrvSHJA5N8tHV9/wD4S6buzt4d+DBdOPngQPnq1tV7c+sqfui47Vw1bjv7J/lg6379AfDP4+833RDeQ+legGMOaPW/S1uaTeP2z4/p3iBp9/FLSfYAngt8tqpG27yD6V7Ak/n+JNsc70K6QHYEXQ/T+XSfdh8HbKiqTQPtewZdUDquqrYMtG9wX91pv41zf7pPW0B34iPdG+f9x2+nuiPHVePWfdvA43UjXVg6cGCZ6wamt0xwe7J9MFUb7t/W/fJA2VhPHMD/bvW4ON3QzwuZ3J2eC9WdDL0JOLCqPgX8HV3vz/VJTk83RLkvXSid6rGeyhvoekdeMlaQ5LFtGGRjklvoDsaTvoa2057Bx+xHrT2Dxj8P75GJh03vD5w78PheDvyU7s1usm3d5fFMN8z5xjZ88wO6EAETt+8A4KZW7zFXTrDc2LafkeSidMOaN9P1dE223y4EnpRkhK437GzgCUkOoeuhvLQtdyrdm+s3k3wxybMH7m/CYxfdh60XtOkX0L3Bju3/59E9nqNJ/j3JgyZrT/Msup6cd06xzEwda/4LeGCS/el6udYAB7ehtMfQhUKY+Jg5FnwG3Z+u93h04HnzLrqeHZj+YzDVMXr8seEuz49JjosTGTvWPrm1dS3dsfYX6I7t26ZYd8EwCN3VVcD9JjrwJVlG94nqrVX1HxOsO3i+y/2Aa9v0O+iG0VZU1b3puljvcv7LgL+l6y7+04H7vj9dN/vv0fV47En3qWhwOzVuO3/Zyg5v9/uCweXbmPkfctcXw7V0L9iJ2jKlqrqG7uBxAvDrtANecxVdN/2u+jzdm/rxwIVV9Y1Wx2fSvXABSLKS7gD83KoaPDCM0g1njBl83Ma7Cnj32EGrHbjuRtfbNTq4bpKM29ZVdL02ew78Lauqz7PrpmrDVXRB5KaBOp9FFy6oqu9X1W9W1QHAbwH/kMm/KXan50ILuPsA17Rtvb2qHkXXc/JAuuHPG+iGl3b4sU5yIt0n5OdU1W0Ds94PnAccXFX3oXsTnOw19CO6YcwxPzMwPf4xu2drz864im5IdvDxvUd7DeyIX6MbRn0q3ZvdIWPVm2DZUWCv9jiMud9EG23njPwr8H+A/dsx42OTbJeq2kAXCl5MN/z5A7rAcBpdT8G2ttz6qvpVujfvNwEfHqjPXY5dzb8BD0t3Dtmz6YZkxu73E1X1NLoetW/SHefgrsezMf9I1zvzsXH7YdCMHGuq6sd0vSYvBb5WVT+hO/78IfCtqrqhLTrRMXMrd/5gM1avW+l608aeM/euqoe0+5vWYzDJ/Y0do+/0HGfc82OK4+JE+/tC4El0YehC4HPAE+iC0IUTLL8g9TEI7Z7uhNuxv/GB52K6J9Ibk+zRlnlCm3cG8M2q+qtJtv1nSe7ZTm47BfhQK78X3cFhc/u08zuTVS7dyYy/ADx/XNreg+6JurEtdwpdT85U7kV3PsQtSQ6ke5Mau58H0n26+ZVxLwboziH50yT7tU8+f07X0zNda+h6HQ6nGysf827gdUlWpPOwJDv8JjRwcHoRd7wYP0/3qfJCgNYz8RHgVVU1/iuhZwMvTXJgupPHXz7F3b2TLswd0t5I9gYe2rb578BD0p0QvpSuB+Nnxq37ytxxsuN9kvzKjrZ3EpO2ofXAnUv3SXssNP8M3RstSX4lyViIuonueTX2XLuO7jyHMR8ATknyiPbG+pfAF6rqu+lOjn9s6wX4EV342daet2cAb053cuZuSR6fgZM5J5LkkXRvpMdV1cZxs+8F3FhV/5PkMXThYTKXAicm2T3dic7PGZj3YeDZSZ6Y7kT017Lzx8F3Am9oH1Jor5djd2I796J7c9xEF+D+crIFq+pKYB3wF0nuluSJwC9Nsvjd6M4j2ghsbb0A2/upjAvpPmyNva7WjrtNkhck2a89zje34m1THLuoqv+h9RQBF7ee1bFe62NboLmV7ng1+Fw8KBN/YeD36IZq/m/7gDree+iet0elO5H5wGn0NE1mu/uE7nXyB+lOMF5O9xh+aPzIQnttfhL4myT3bnX7uSS/sBP3N9kx+mzg5CQPbkH/1WMrbee4eJf9XVXr6XqXX0D3ofMHbblfxiC0oH2M7oEd+3vN4Mzqfuvhl+hONP4e3Tkfz2uzTwSOz53Pun/SwOoX0p0wdwHwf6pq7IcKX0Z34P4h3aeZDzG5X6V7I7p24D7+pPV6/A1db8t1dCHj/22nrX9BN3x0C92b9mAoeSbdJ+FPDNzPWE/F6+kOtpfRDal8qZVN17m0YYMWWsa8me5F+km6YPgeui7unXEhXRfzxQO378UdXdVH0PUavWXw8Wrz/rHV4TK64aOP0X16u8vvfFTVuXQh67NJbmrLvLrNu4HuBPY30r2JrWDgMWnrvgn4YLohj68Bz9jJ9o63vTa8kO6csO8k2UI33HJkm/do4Attf5xHd87It9u81wBntZ6k51bVfwJ/RtezMEr3KfvEtuy9Wz1uout+3wT8dZv3MrrnzhfphgTfxPaPN8fSnfj9uYHHbKzn9XeB1yb5Id1B/+wptvNnrZ430b0G3j82o6q+Theg39/acxPda3xnvI1u/32y1esi4LE7sZ01dPvvGroT4C/azvK/1u7nRrrn4pqJFqqqH9KF87Pp2vlrrb5TGf86Gn8bupNxv96eP2+jOxdoC5McuwbWO4vuuDXYS7yErnfl2taeX+COD4qfAr4OfD/JDQPrjA1Dn0b32H0kyT3Gzb+Y7sPoW+iOfxdy5x6UHTGdfXJGa9dngO/QfSh48STbW00XUr9B97h8mK43bEfub9JjdButeCvd/tvQ/o+Z6rg42f6+kO50iKsGbqfd56KQ7vkkzawk36IbFvrPua7L9rRPyu+sqikPlOnG6V9fVS+Yarm5MFUbkvwpcMkkw7nSrEhyP7qhr59pPQu9kORn6b5UsHv5hjsv9bFHSEOW7nc3ijt/Epk30v2ezTOTLG1Dhq+m68XanifRfYqbczvYhl+k+0kIaU6k+y2aP6T7BlRvQlDzULov4BiC5imDkGZUuh/Aewfwonn8jYLQDZncRDesdDndcMv2XAz8epKphmVmy4604eN0Q6CnzFLdpNu1839+QPebPq/ezuKLSrofMj0deMVc10WTc2hMkiT1lj1CkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSpt8ZfeX2x8FciJUkLRea6An1mj5AkSeotg5AkSeotg5AkSeqtxXqOkHbAAQcfwOjVo3NdjaEYOWiEa6+6dq6rIUmapxbr1ecXZaOGJQlHnnnkXFdjKNaevJZF+hyXtHh4svQccmhMkiT1lkFIkiT1lkFIkiT1lkFIkiT1lkFIkiT1lkFIkiT1lkFIkiT1lkFIkiT1lkFIkiT1lkFIkiT1lkFIkiT1lkFIkiT1lkFIkiT1lkFIkiT1lkFIkiT1lkFIkiT1lkFIkiT1lkFIkiT1lkFIkiT1lkFIkiT1lkFIkiT1lkFIkiT1lkFIkiT1lkFIkiT1lkFIkiT11tK5rsBCcMDBBzB69ehcV0OSJM0wg9A0jF49ypFnHjnX1RiatSevnesqSJI0JxwakyRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvWUQkiRJvbV0risgDdUSSDLXtRiaJbsvYdtt2+a6GkMzctAI11517VxXQzvhgIMPYPTq0bmuxtD43Fw8DEJa3LbBkWceOde1GJq1J69d9O3TwjR69ajPTS0IDo1JkqTeMghJkqTeMghJkqTeMghJkqTeMghJkqTeMghJkqTeMghJkqTeSlXNdR1mXJKPA/tuZ7F9gRtmoTrzkW3vJ9veT7Z9/ruhqo6Z60r01aIMQtORZF1VrZrreswF227b+8a223ZpMg6NSZKk3jIISZKk3upzEDp9riswh2x7P9n2frLt0hR6e46QJElSn3uEJElSzxmEJElSbxmEJElSbxmEJElSbxmEJElSbxmEJElSbxmEJElSbxmEJElSbxmEJElSby2d6woMwzHHHFMf//jH57oakiRNR3Z2Rd/vpm3Sfbwoe4RuuOGGua6CJElD5/vdrhtqEEryB0m+nuRrST6Q5B5JDk3yhSQbknwoyd3asndvtze0+YcMbOeVrfyKJE8fZp0lSVJ/DC0IJTkQeAmwqqoeCuwGnAi8CXhLVT0AuAk4ta1yKnBTK39LW44kD27rPQQ4BviHJLsNq96SJKk/hj00thRYlmQpcE9gFHgK8OE2/yzguDZ9bLtNm39UkrTyD1bVrVX1HWAD8Jgh11uSJPXA0IJQVV0D/B/ge3QB6BbgEuDmqtraFrsaOLBNHwhc1dbd2pbfZ7B8gnVul+S0JOuSrNu4cePMN0iSpHnA97uZNcyhsb3oenMOBQ4A9qAb2hqKqjq9qlZV1ar99ttvWHcjSdKc8v1uZg1zaOypwHeqamNV3QacAzwB2LMNlQEcBFzTpq8BDgZo8+8DbBosn2AdSZKknTbMIPQ94HFJ7tnO9TkK+AbwaeA5bZmTgI+06fPabdr8T1VVtfIT27fKDgVWABcPsd6SJKknhvaDilX1hSQfBr4EbAW+DJwO/DvwwSSvb2Xvaau8B3hvkg3AjXTfFKOqvp7kbLoQtRV4UVX9dFj1liRJ/ZGu02VxWbVqVa1bt26uqyFJ0nTs9C9L+343bf36ZWlJkqTpMAhJkqTeMghJkqTeMghJkqTeMghJkqTeMghJkqTeGtrvCEmStNhsq22s37Se0c2jjCwfYcU+K1gS+xQWMoOQJEnTsK22cc7l57D63NVs2bqFZUuXseb4NZxw2AmGoQXMR06SpGlYv2n97SEIYMvWLaw+dzXrN62f45ppVxiEJEmahtHNo7eHoDFbtm5hdPPoHNUILrvsMpJM+HfAwQfMWb0WEofGJEmahpHlIyxbuuxOYWjZ0mWMLB+ZszrddtttHHnmkRPOW3vy2lmty0Jlj5AkSdOwYp8VrDl+DcuWLgO4/RyhFfusmOOaaVfYIyRJ0jQsyRJOOOwEDr/v4X5rbBExCEmSNE1LsoSV+65k5b4r57oqmiHGWEmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1FtDC0JJVia5dODvB0l+P8neSc5Psr7936stnyRvT7IhyWVJjhjY1klt+fVJThpWnSVJUr8MLQhV1RVV9YiqegTwKODHwLnAK4ALqmoFcEG7DfAMYEX7Ow14B0CSvYFXA48FHgO8eiw8SZIk7YrZGho7CvhWVV0JHAuc1crPAo5r08cCa6pzEbBnkhHg6cD5VXVjVd0EnA8cM0v1liRJi9hsBaETgQ+06f2rarRNfx/Yv00fCFw1sM7VrWyyckmSpF0y9CCU5G7A/wL+Zfy8qiqgZuh+TkuyLsm6jRs3zsQmJUmadwbf7+a6LovBbPQIPQP4UlVd125f14a8aP+vb+XXAAcPrHdQK5us/E6q6vSqWlVVq/bbb78ZboIkSfPD4PvdXNdlMZiNIPSr3DEsBnAeMPbNr5OAjwyUr27fHnsccEsbQvsEcHSSvdpJ0ke3MkmSpF2ydJgbT7IH8DTgtwaK3wicneRU4Ergua38Y8AzgQ103zA7BaCqbkzyOuCLbbnXVtWNw6y3JEnqh6EGoar6EbDPuLJNdN8iG79sAS+aZDtnAGcMo46SJKm//GVpSZLUW0PtEZIkScOzZLclrD157YTzRg4amd3KLFAGIUmSFqhtP91Gd2aJdpZDY5IkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbcMQpIkqbeGGoSS7Jnkw0m+meTyJI9PsneS85Osb//3assmyduTbEhyWZIjBrZzUlt+fZKThllnSZLUH8PuEXob8PGqehDwcOBy4BXABVW1Arig3QZ4BrCi/Z0GvAMgyd7Aq4HHAo8BXj0WniRJknbF0IJQkvsATwbeA1BVP6mqm4FjgbPaYmcBx7XpY4E11bkI2DPJCPB04PyqurGqbgLOB44ZVr0lSVooli9fPtdVWPCG2SN0KLAR+KckX07y7iR7APtX1Whb5vvA/m36QOCqgfWvbmWTlUuS1GubN2+e6yoseMMMQkuBI4B3VNUjgR9xxzAYAFVVQM3EnSU5Lcm6JOs2btw4E5uUJGneGXy/m+u6LAbDDEJXA1dX1Rfa7Q/TBaPr2pAX7f/1bf41wMED6x/UyiYrv5OqOr2qVlXVqv32229GGyJJ0nwx+H4313VZDIYWhKrq+8BVSVa2oqOAbwDnAWPf/DoJ+EibPg9Y3b499jjgljaE9gng6CR7tZOkj25lkiRJu2TpkLf/YuB9Se4GfBs4hS58nZ3kVOBK4Llt2Y8BzwQ2AD9uy1JVNyZ5HfDFttxrq+rGIddbkiT1QLrTdBaXVatW1bp1Dp1KkhaE7PSKSS3G9/EhmHQf+8vSkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiSptwxCkiQtUMuXL5/rKix4BiFJkhaozZs3z3UVFjyDkCRJ6i2DkCRJ6i2DkCRJ6i2DkCRJ6q2hBqEk303y1SSXJlnXyvZOcn6S9e3/Xq08Sd6eZEOSy5IcMbCdk9ry65OcNMw6S5Kk/piNHqFfrKpHVNWqdvsVwAVVtQK4oN0GeAawov2dBrwDuuAEvBp4LPAY4NVj4UmSJGlXzMXQ2LHAWW36LOC4gfI11bkI2DPJCPB04PyqurGqbgLOB46Z5TpLkqRFaNhBqIBPJrkkyWmtbP+qGm3T3wf2b9MHAlcNrHt1K5usXJIkaZcsHfL2n1hV1yS5L3B+km8OzqyqSlIzcUctaJ0GcL/73W8mNilJ0rwz+H6nXTfUHqGquqb9vx44l+4cn+vakBft//Vt8WuAgwdWP6iVTVY+/r5Or6pVVbVqv/32m+mmSJI0Lwy+3811XRaDoQWhJHskudfYNHA08DXgPGDsm18nAR9p0+cBq9u3xx4H3NKG0D4BHJ1kr3aS9NGtTJIkaZcMc2hsf+DcJGP38/6q+niSLwJnJzkVuBJ4blv+Y8AzgQ3Aj4FTAKrqxiSvA77YlnttVd04xHpLkqSeSNWMnKIzr6xatarWrVs319WQJGk6stMrJrUY38eHYNJ97C9LS5Kk3jIISZKk3jIISZKk3jIISZKk3jIISZKk3jIISZKk3jIISZKk3jIISZKk3truL0snuTvwy8Ahg8tX1WuHVy1JkqThm84lNj4C3AJcAtw63OpIkiTNnukEoYOq6pih10SSJGmWTeccoc8nOXzoNZEkSZplk/YIJfkqUG2ZU5J8m25oLEBV1cNmp4qSJEnDMdXQ2LNnrRaSJElzYNKhsaq6sqquBEaAGwdu3wT8zGxVUJIkaVimc47QO4DNA7c3tzJJkqQFbTpBKFVVYzeqahvT+7aZJEnSvDadIPTtJC9Jsnv7eynw7WFXTJIkadimE4R+G/h54BrgauCxwGnDrJQkSdJsmM4Q10+r6sSh10SSJGmWTadH6KIk/5LkGUky9BpJkiTNkukEoQcCpwOrgfVJ/jLJA4dbLUmSpOHbbhCqzvlV9avAbwInARcnuTDJ44deQ0mSpCHZ7jlCSfYBXgD8OnAd8GLgPOARwL8Ahw6xfpIkSUMznZOl/wt4L3BcVV09UL4uyTuHUy1JkqThm04QWjn4g4qDqupNM1wfSZKkWTOdILQiycuAQwaXr6qnDKtSkiRJs2E6QehfgHcC7wZ+OtzqSJIkzZ7pBKGtVeVFViVJmmeWL18+11VY8KbzO0L/N8nvJhlJsvfY39BrJkmSprR58+a5rsKCN50eoZPa/z8eKCvgZ2e+OpIkSbNnu0GoqvydIEmStChN5wcVdwd+B3hyK1oLvKuqbhtivSRJkoZuOkNj7wB2B/6h3f71VvYbw6qUJEnSbJhOEHp0VT184PanknxlWBWSJEmaLdP51thPk/zc2I0kP4u/JyRJkhaB6fQI/THw6STfBgLcH3jhUGslSZI0C6bzrbELkqwAVraiK6rq1uFWS5Ikafi2OzSW5BK6K89f1v5uTfKBWaibJEnSUE0ahJLcu03eGzglyV8nSSt70NBrJkmSNGRT9Qi9v/3/IfBMuvODPpFkL7pflpYkSVrQJj1HqKqe3SZTVduAlyV5PvA5YM9ZqJskSdJQTefr8+8cm6iq99H9oOInpnsHSXZL8uUkH223D03yhSQbknwoyd1a+d3b7Q1t/iED23hlK78iydOne9+SJElT2W4Qqqp3ASS5b5L7ATcAr9mB+3gpcPnA7TcBb6mqBwA3Aae28lOBm1r5W9pyJHkwcCLwEOAY4B+S7LYD9y9JkjSh6Xxr7JeSrAe+A1zY/n9sOhtPchDwLODd7XaApwAfboucBRzXpo9tt2nzj2rLHwt8sKpurarvABuAx0zn/iVJkqYynaGx1wOPA/67XYn+qcAXprn9twL/G9jWbu8D3FxVW9vtq4ED2/SBwFUAbf4tbfnbyydYR5IkaadNJwjdVlWbgCVJllTVp4FV21spybOB66vqkl2t5HQkOS3JuiTrNm7cOBt3KUnSrBt8v5vruiwG07nExs1JlgOfAd6X5HrgR9NY7wnA/0ryTOAedL9H9DZgzyRLW6/PQcA1bflrgIOBq5MsBe4DbBooHzO4zu2q6nTgdIBVq1b59X5J0qI0+H6XxPe7XTSdHqFjgR8DfwB8HPgW8EvbW6mqXllVB1XVIXQnO3+qqp4PfBp4TlvsJOAjbfq8dps2/1NVVa38xPatskOBFcDF06i3JEnSlKbsEWrfzvpoVf0i3Xk+Z021/DS9HPhgktcDXwbe08rfA7w3yQbgRrrwRFV9PcnZwDeArcCLquqnM1APSZLUc+k6XaZYILkAOKGqbpmdKu26VatW1bp1Dp1KkhaEbH+RSVZManvv4wKm2MfTOUdoM/DVJOczcG5QVb1kBiomSZI0Z6YThM5pf5IkSYvKdoNQVc3EeUGSJEnzznaDUJIVwP8HPJjua/AAVNXPDrFekiRJQzedr8//E/AOum9s/SKwBvjnYVZKkiRpNkwnCC2rqgvovmF2ZVW9hu76YZIkSQvadE6WvjXJEmB9kt+j+1Xn5cOtliRJ0vBNp0fopcA9gZcAjwJewB2/AC1JkrRgTadH6B7AlqraDJwCkOSIodZKkiRpFkynR+gTwKeS3Heg7N1Dqo8kSdKsmU4QugL4a+DCJD/fynb658AlSZLmi+kMjVVVfTTJFcCHkpwBeGETSZK04E2nRygAVbUeeBLwZOBhw6yUJEnSbJjOJTYeOTD9I+C5Se431FpJkiTNgun0CN1FVX1vpisiSZI023YqCEmSJC0GBiFJktRb0/nWGEmeBTyEO199/rXDqpQkSdJs2G6PUJJ3As8DXkz3DbJfAe4/5HpJkiQN3XSGxn6+qlYDN1XVXwCPBx443GpJkiQN33SGxra0/z9OcgCwCRgZXpWk4dpW21i/aT2jm0cZWT7Cin1WsCSeLidJfTSdIPTRJHvSXWbjS3S/Ku21xrQgbattnHP5Oaw+dzVbtm5h2dJlrDl+DSccdoJhSNKCs2TJEpKJr3o1ctAI11517SzXaOFJ1fSvlpHk7sA9quqW4VVp161atarWrVs319XQPHTFDVfwyHc9ki1bt9xetmzpMr78W19m5b4r57Bmknpsp6/fmaSOPPPICeetPXktO/Iev8hNuo+32yOUZDfgWcAhY8snoarePFO1k2bL6ObRO4UggC1btzC6edQgJEk9NJ2hsf8L/A/wVWDbcKsjDdfI8hGWLV12lx6hkeWe9iZJfTSdIHRQVXmRVS0KK/ZZwZrj19zlHKEV+6yY66pJkubAdILQfyQ5uqo+OfTaSEO2JEs44bATOPy+h/utMUnStILQRcC5SZYAt9GdcFRVde+h1kwakiVZwsp9V3pOkCRpWkHozXQ/ovjV8vRzSZK0iExnPOAq4GuGIEmStNhMp0fo28DaJP8B3DpW6NfnJUnSQjedIPSd9ne39idJkrQobDcItQutSpIkLTrT+WXpT9NdX+xOquopQ6mRJEnSLJnO0NjLBqbvAfwysHU41ZEkSZo90xkau2Rc0f9LcvGQ6iNJkjRrpjM0tvfAzSXAo4D7DK1GkiRJs2Q6Q2OX0J0jFLohse8Apw6zUpIkSbNhOkNjh85GRSRJkmbbpL8sneTRSX5m4PbqJB9J8vZxw2WSJEkL0lSX2HgX8BOAJE8G3gisAW4BTh9+1SRJkoZrqqGx3arqxjb9POD0qvpX4F+TXDr0mkmSJA3ZVD1CuyUZC0pHAZ8amDedk6wlSZLmtamC0AeAC5N8BNgCfBYgyQPohsemlOQeSS5O8pUkX0/yF6380CRfSLIhyYeS3K2V373d3tDmHzKwrVe28iuSPH3nmytJknSHSYNQVb0B+CPgTOCJVVUD67x4Gtu+FXhKVT0ceARwTJLHAW8C3lJVDwBu4o6v4p8K3NTK39KWI8mDgROBhwDHAP+QZLcdaKMkSdKEpuoRoqouqqpzq+pHA2X/XVVf2t6Gq7O53dy9/RXwFODDrfws4Lg2fWy7TZt/VJK08g9W1a1V9R1gA/CY6TROkiRpKlMGoV2VZLd2YvX1wPnAt4Cbq2rsWmVXAwe26QOBqwDa/FuAfQbLJ1hHkiRppw01CFXVT6vqEcBBdL04DxrWfSU5Lcm6JOs2btw4rLuRJGlODb7fzXVdFoOhBqExVXUz8Gng8cCeA99GOwi4pk1fAxwM0ObfB9g0WD7BOoP3cXpVraqqVfvtt98wmiFJ0pwbfL+b67osBkMLQkn2S7Jnm14GPA24nC4QPactdhLwkTZ9XrtNm/+pdoL2ecCJ7VtlhwIrgIuHVW9JktQfw/w9oBHgrPYNryXA2VX10STfAD6Y5PXAl4H3tOXfA7w3yQbgRrpvilFVX09yNvANuou+vqiqfjrEekuSpJ4YWhCqqsuAR05Q/m0m+NZXVf0P8CuTbOsNwBtmuo6SJKnfZuUcIUmSpPnIICRJknrLICRJknrLICRJknrLICRJknrLICRJknrLICRJknrLICRJknrLICRJknrLICRJknrLICRJknrLICRJknrLICRJknpraFeflyRJQxZYe/LaiectgSQTzho5aIRrr7p2ePVaQAxCkiQtVAVHnnnkDq82aXjqIYfGJElSb9kjpEVlW21j/ab1jG4eZWT5CCv2WcGSmPclSRMzCGnR2FbbOOfyc1h97mq2bN3CsqXLWHP8Gk447ATDkCRpQr47aNFYv2n97SEIYMvWLaw+dzXrN62f45pJkuYrg5AWjdHNo7eHoDFbtm5hdPPoHNVIkjTfGYS0aIwsH2HZ0mV3Klu2dBkjy0fmqEaSpPnOIKRFY8U+K1hz/Jrbw9DYOUIr9lkxxzWTJM1XniytRWNJlnDCYSdw+H0P91tjkqRpMQhpUVmSJazcdyUr910511WRJC0AflSWJEm9ZRCSJEm9ZRCSJEm9ZRCSJEm9ZRCSJEm9ZRCSJEm9ZRCSJEm9ZRCSJEm9ZRCSJEm9ZRCSJEm9ZRCSJEm9ZRCSJEm9ZRCSJEm95dXntcu21TbWb1rP6OZRRpaPsGKfFSyJGVuSNP8ZhLRLttU2zrn8HFafu5otW7ewbOky1hy/hhMOO8EwJEma93yn0i5Zv2n97SEIYMvWLaw+dzXrN62f45pJkrR9BiHtktHNo7eHoDFbtm5hdPPoHNVIkqTpMwhpl4wsH2HZ0mV3Klu2dBkjy0fmqEaSJE2fQUi7ZMU+K1hz/Jrbw9DYOUIr9lkxxzWTJGn7hnaydJKDgTXA/kABp1fV25LsDXwIOAT4LvDcqropSYC3Ac8EfgycXFVfats6CfjTtunXV9VZw6q3dsySLOGEw07g8Pse7rfGJEkLzjC/NbYV+KOq+lKSewGXJDkfOBm4oKremOQVwCuAlwPPAFa0v8cC7wAe24LTq4FVdIHqkiTnVdVNQ6y7dsCSLGHlvitZue/Kua6KJEk7ZGgf26tqdKxHp6p+CFwOHAgcC4z16JwFHNemjwXWVOciYM8kI8DTgfOr6sYWfs4HjhlWvSVJUn/MyvhFkkOARwJfAPavqrGvFH2fbugMupB01cBqV7eyycolSZJ2ydCDUJLlwL8Cv19VPxicV1VFN9w1E/dzWpJ1SdZt3LhxJjYpSdK8M/h+N9d1WQyGGoSS7E4Xgt5XVee04uvakBft//Wt/Brg4IHVD2plk5XfSVWdXlWrqmrVfvvtN7MNkSRpnhh8v5vruiwGQwtC7Vtg7wEur6o3D8w6DzipTZ8EfGSgfHU6jwNuaUNonwCOTrJXkr2Ao1uZJEnSLhnmt8aeAPw68NUkl7ayPwHeCJyd5FTgSuC5bd7H6L46v4Hu6/OnAFTVjUleB3yxLffaqrpxiPWWJEk9MbQgVFWfAzLJ7KMmWL6AF02yrTOAM2audpIkSf6ytCRJ6jGDkCRJ6i2DkCRJ6i2DkCRJ6i2DkCRJ6q1hfn1ekiQNU2DtyWt3eLUlu9sPMsYgJEnSQlVw5JlH7vBqOxOeFisjoSRJ6i2DkCRJ6i2DkCRJ6i2DkCRJ6i2DkCRJ6i2DkCRJ6i2DkCRJ6i2DkCRJ6i2DkCRJ6i2DkCRJ6i2DkCRJ6i2DkCRJ6i2DkCRJ6i2vPq95bVttY/2m9YxuHmVk+Qgr9lnBkpjfJUkzwyCkeWtbbeOcy89h9bmr2bJ1C8uWLmPN8Ws44bATDEOSpBnhu4nmrfWb1t8eggC2bN3C6nNXs37T+jmumSRpsTAIad4a3Tx6ewgas2XrFkY3j85RjSRJi41BSPPWyPIRli1ddqeyZUuXMbJ8ZI5qJElabAxCmrdW7LOCNcevuT0MjZ0jtGKfFXNcM0nSYuHJ0pq3lmQJJxx2Aoff93C/NSZJGgqDkOa1JVnCyn1XsnLflXNdFUnSIuRHa0mS1FsGIUmS1FsGIUmS1FsGIUmS1FsGIUmS1Ft+a0zS0HjRXEnznUFI0lB40VxJC4FHI0lD4UVzJS0EBiFJQ+FFcyUtBAYhSUPhRXMlLQQGIUlD4UVzJS0EniwtaSi8aK6khcAgJGlovGiupPnOj2aSJKm3hhaEkpyR5PokXxso2zvJ+UnWt/97tfIkeXuSDUkuS3LEwDonteXXJzlpWPWVJEn9M8weoTOBY8aVvQK4oKpWABe02wDPAFa0v9OAd0AXnIBXA48FHgO8eiw8SZIk7aqhBaGq+gxw47jiY4Gz2vRZwHED5WuqcxGwZ5IR4OnA+VV1Y1XdBJzPXcOVJEnSTpntc4T2r6qxX1P7PrB/mz4QuGpguatb2WTlkiRJu2zOTpauqgJqpraX5LQk65Ks27hx40xtVpKkeWXw/W6u67IYzHYQuq4NedH+X9/KrwEOHljuoFY2WfldVNXpVbWqqlbtt99+M15xSZLmg8H3u7muy2Iw278jdB5wEvDG9v8jA+W/l+SDdCdG31JVo0k+AfzlwAnSRwOvnOU6S5I0PwXWnrx2x9dbAklmvDrzxchBI1x71bXTWnZoQSjJB4AjgX2TXE337a83AmcnORW4EnhuW/xjwDOBDcCPgVMAqurGJK8DvtiWe21VjT8BW5Kkfio48swj57oW886OhMOhBaGq+tVJZh01wbIFvGiS7ZwBnDGDVZMkSQL8ZWlJktRjBiFJktRbBiFJktRbBiFJktRbBiFJktRbBiFJktRbBiFJktRbBiFJktRbBiFJktRbBiFJktRbBiFJktRbBiFJktRbQ7voqhaObbWN9ZvWM7p5lJHlI6zYZwVLYkaWJC1+BqGe21bbOOfyc1h97mq2bN3CsqXLWHP8Gk447ITthiEDlCRpofNdq+fWb1p/ewgC2LJ1C6vPXc36TeunXG8sQD3yXY/kF8/6RR75rkdyzuXnsK22zUa1JUmaEQahnhvdPHp7CBqzZesWRjePTrnezgYoSZLmE4NQz40sH2HZ0mV3Klu2dBkjy0emXG9nA9SYbbWNK264grXfXcsVN1xhT5IkaU4YhGbRfHzzX7HPCtYcv+b2MDR2jtCKfVZMud7OBihwWE2SNH94svQs2ZWTkodpSZZwwmEncPh9D9+hk57HAtT49mwvQMHkw2qH3/dwVu67ckbaJUnSdBiEZsnOvPnP1reylmQJK/dduUMhZGcDFEw9rGYQkiTNJoPQLNnRN//52oM0aGcCFNwxrDa4P6Y7rCZJ0kyaH++o89RMntOzo+fULOZvZe3seUmSJM00e4QmMdM9Mjt6Ts1cDB/N5lDczg6rSZI0kwxCk5jpE3p39M1/toePZnsobmeH1SRJmkl+BJ/Erv5OzkTG3vyPPORIVu67csqAMdvDRzMxFDcffx5AkqSp2CM0ibk+oXe2h492dShuIZzcLUnSeL5DTWI+nNC7Iz1Iu2pXfiARFvfJ3ZKkxcseoUn07YTeXfmBRPC3gSRJC5NBaAp9OqF3V4PfXA8lSpK0MxZn94Z2yq4Mxc2HoURJknaUPUKaEX0bSpQkLQ4GIc2YPg0lSpIWBz+uS5Kk3jIISZKk3jIISZKk3vIcoe2YrQuRSpKk2WcQmoKXjZAkaXHz3XwKXjZCkqTFzSA0hZm4Ar1XZJckaf5yaGwKu3rZCIfWJEma33w3nsKuXjbCoTVJkuY3e4SmsKuXjfCK7JKkYdp9991Ze/Laua7GvDNy0PQv+G0Q2o5duWyEV2SXJA3Twx72MNatWzfX1VjQFszQWJJjklyRZEOSV8x1fabDK7JLkjS/LYgeoSS7AX8PPA24GvhikvOq6htzW7OpeUV2SZLmtwURhIDHABuq6tsAST4IHAvM6yAEXpFdkqT5bKF0TRwIXDVw++pWJkmStNMWShDariSnJVmXZN3GjRvnujqSJA2F73cza6EEoWuAgwduH9TKbldVp1fVqqpatd9++81q5SRJmi2+382shRKEvgisSHJokrsBJwLnzXGdJEnSArcgTpauqq1Jfg/4BLAbcEZVfX2OqyVJkha4BRGEAKrqY8DH5roekiRp8VgoQ2OSJEkzziAkSZJ6yyAkSZJ6yyAkSZJ6yyAkSZJ6yyAkSZJ6yyAkSZJ6yyAkSZJ6yyAkSZJ6K1U113WYcUk2AlduZ7F9gRtmoTrzkW3vJ9veT7Z9/ruhqo7ZmRWTfHxn11VnUQah6UiyrqpWzXU95oJtt+19Y9ttuzQZh8YkSVJvGYQkSVJv9TkInT7XFZhDtr2fbHs/2XZpCr09R0iSJKnPPUKSJKnnFlUQSvLdJF9NcmmSda1s7yTnJ1nf/u/VypPk7Uk2JLksyRED2zmpLb8+yUlz1Z7tSXJGkuuTfG2gbMbam+RRbX9uaOtmdls4uUna/pok17TH/9IkzxyY98rWjiuSPH2g/JhWtiHJKwbKD03yhVb+oSR3m73WTS7JwUk+neQbSb6e5KWtfNE/7lO0vQ+P+z2SXJzkK63tf9HKJ6xvkru32xva/EMGtrVD+2Q+mKL9Zyb5zsBj/4hWvmie95oFVbVo/oDvAvuOK/sr4BVt+hXAm9r0M4H/AAI8DvhCK98b+Hb7v1eb3muu2zZJe58MHAF8bRjtBS5uy6at+4y5bvN22v4a4GUTLPtg4CvA3YFDgW8Bu7W/bwE/C9ytLfPgts7ZwIlt+p3A78x1m1tdRoAj2vS9gP9u7Vv0j/sUbe/D4x5geZveHfhCe4wmrC/wu8A72/SJwId2dp/Mh78p2n8m8JwJll80z3v/hv+3qHqEJnEscFabPgs4bqB8TXUuAvZMMgI8HTi/qm6sqpuA84F5+WNVVfUZ4MZxxTPS3jbv3lV1UVUVsGZgW3NukrZP5ljgg1V1a1V9B9gAPKb9baiqb1fVT4APAse2T4JPAT7c1h/cj3Oqqkar6ktt+ofA5cCB9OBxn6Ltk1lMj3tV1eZ2c/f2V0xe38Hnw4eBo1r7dmifDLdV0zdF+yezaJ73Gr7FFoQK+GSSS5Kc1sr2r6rRNv19YP82fSBw1cC6V7eyycoXiplq74Ftenz5fPd7rSv8jLHhIXa87fsAN1fV1nHl80ob7ngk3afjXj3u49oOPXjck+yW5FLgero38G8xeX1vb2Obfwtd+xbscW98+6tq7LF/Q3vs35Lk7q1sUT7vNRyLLQg9saqOAJ4BvCjJkwdntqTfm6/J9a29wDuAnwMeAYwCfzOntRmiJMuBfwV+v6p+MDhvsT/uE7S9F497Vf20qh4BHETXg/Ogua3R7Brf/iQPBV5Jtx8eTTfc9fK5q6EWqkUVhKrqmvb/euBcuoPFda3bk/b/+rb4NcDBA6sf1MomK18oZqq917Tp8eXzVlVd1w6W24B/pHv8YcfbvomuK33puPJ5IcnudEHgfVV1TivuxeM+Udv78riPqaqbgU8Dj2fy+t7exjb/PnTtW/DHvYH2H9OGS6uqbgX+iZ1/7Of1817DtWiCUJI9ktxrbBo4GvgacB4w9s2Ak4CPtOnzgNXt2wWPA25pQwufAI5OslfrYj+6lS0UM9LeNu8HSR7Xzi1YPbCteWksCDTH0z3+0LX9xPZNmkOBFXQnRn4RWNG+eXM3upNKz2s9Kp8GntPWH9yPc6o9Fu8BLq+qNw/MWvSP+2Rt78njvl+SPdv0MuBpdOdITVbfwefDc4BPtfbt0D4ZesOmaZL2f3Mg/IfunJ7Bx35RPO81C6Y6k3oh/dF92+Er7e/rwKta+T7ABcB64D+BvVt5gL+nG2f/KrBqYFsvpDuJcANwyly3bYo2f4BuKOA2ujHtU2eyvcAqugPLt4C/o/0A53z4m6Tt721tu4zuQDgysPyrWjuuYODbIHTfLvnvNu9V455PF7d98i/A3ee6za1eT6Qb9roMuLT9PbMPj/sUbe/D4/4w4MutjV8D/nyq+gL3aLc3tPk/u7P7ZD78TdH+T7XH/mvAP3PHN8sWzfPev+H/+cvSkiSptxbN0JgkSdKOMghJkqTeMghJkqTeMghJkqTeMghJkqTeMghJi1iSpemu2P6gceX7Z+DK25LUVwYhaRa04PH+JN9u18L7ryTH7+S2/mQHFn8F8Naq+ubA+vcG3kr3u0O7JMl3k+y7A8sfkuRr01juY2M/oLcTdfrtJKt3Zl1J/ePvCElD1n6p9vPAWVX1zlZ2f+B/VdXf7sT2NlfV8hmu5k5J8l26H6u7YZrLHwJ8tKoeOsx6SdJ02SMkDd9TgJ+MhSCAqrpyLAS1q2r/dZIvtqto/1YrH0nymSSXJvlakicleSOwrJW9ry33h23+15L8fivbI8m/J/lKK39eK390ks+38ovHLkszJslr27YvTXJNkn9q5f/WerK+nuS08Q0c39OT5GVJXtOmH9Xu7yvAiwaWOTnJOUk+nmR9kr8amHd7T1OSF7S6XprkXUl2a+Wbk7yhbfuiJPu38tckeVmb/s22X7+S5F+T3HMnH0NJi5RBSBq+hwBfmmL+qXTXQno03VW0f7NdB+rX6K6D9Ajg4cClVfUKYEtVPaKqnp/kUcApwGOBx7V1HwkcA1xbVQ9vvS8fb9eQ+hDw0qp6OPBUYMtgRarqz9v9HQncSHepAYAXVtWj6C5D8JIk++xA+/8JeHG7z/EeATwPOBx4XpLBC2KS5LA2/wmtXj8Fnt9m7wFc1Lb7GeA3J9j+OVX16LbM5XT7WpJuZxCSZlmSv289FF9sRUfTXSDyUuALdNcNW0F3IcxTWs/K4VX1wwk290Tg3Kr6UVVtBs4BnkR3faWnJXlTkidV1S3ASmC0qr4IUFU/qKqtE9QvdNdtenNVXdKKX9J6dC6iu3r3imm2dU9gz6r6TCt677hFLqiqW6rqf4BvAPcfN/8o4FHAF9v+OYru+loAPwE+2qYvAQ6ZoAoPTfLZJF+lC1APmU69JfXH0rmugNQDXwd+eexGVb2oDfusa0Wh6zH5xPgVkzwZeBZwZpI3V9Wa6dxhVf13kiPoLqT5+iQXAOdOs76vAa6uqrFhsSPpeo8eX1U/TrKW7qKeg7Zy5w9W4+dP5taB6Z9y12NS6M6teuUE695Wd5zkONG6AGcCx1XVV5KcTNfTJUm3s0dIGr5PAfdI8jsDZYPnqnwC+J0kuwMkeWA7x+f+wHVV9Y/Au4Ej2vK3jS0LfBY4Lsk9k+wBHA98NskBwI+r6p+Bv27rXgGMJHl0u597JblTeEjyS3Sh5yUDxfcBbmoh6EF0Q3DjXQfcN8k+Se4OPBugqm4Gbk7yxLbc8ydYdyoXAM9Jct9Wv73bfpmuewGjbX/t6H1L6gF7hKQhq6pKchzwliT/G9gI/Ah4eVvk3XTDOl9KshfwPeAZdL0Xf5zkNmAzMPaV8NOBy5J8qZ0ndCZw8di2qurLSZ4O/HWSbcBtwO9U1U/aSdN/m2QZ3flBT23bHvOHwIHAxd0IGecBbwB+O8nldGHqognaeFuS17Z6XAN8c2D2KcAZSQr45A7uu28k+VPgk0mWtLa8CLhympv4M7rhxo3t/72mXlxS3/j1eWkeSfKPwG9X1U/nui6S1AcOjUnzyz2Bs+a6EpLUF/YISZKk3rJHSJIk9ZZBSJIk9ZZBSJIk9ZZBSJIk9ZZBSJIk9ZZBSJIk9db/D6I2srIPWW5QAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -954,7 +969,7 @@ }, { "cell_type": "code", - "execution_count": 103, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -967,7 +982,7 @@ " dtype='object')" ] }, - "execution_count": 103, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -978,17 +993,19 @@ }, { "cell_type": "code", - "execution_count": 104, + "execution_count": 29, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -1001,7 +1018,7 @@ }, { "cell_type": "code", - "execution_count": 105, + "execution_count": 30, "metadata": {}, "outputs": [ { @@ -1026,7 +1043,7 @@ "Name: zar, dtype: int64" ] }, - "execution_count": 105, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } @@ -1051,12 +1068,12 @@ }, { "cell_type": "code", - "execution_count": 106, + "execution_count": 31, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1083,12 +1100,12 @@ }, { "cell_type": "code", - "execution_count": 107, + "execution_count": 32, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1106,12 +1123,12 @@ }, { "cell_type": "code", - "execution_count": 108, + "execution_count": 33, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1126,11 +1143,415 @@ "plt.title(\"Suma zarażonych w czasie\")\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['Unnamed: 0.1', 'Interwencje', 'Zatrzymani na gorącym uczynku',\n", + " 'Zatrzymani poszukiwani', 'Zatrzymani nietrzeźwi kierujący',\n", + " 'Wypadki drogowe', 'Zabici w wypadkach', 'Ranni w wypadkach',\n", + " 'temperature', 'temperature_min', 'temperature_max', 'winddirection',\n", + " 'windspeed', 'pressure', 'allbed_mean', 'ICUbed_mean', 'deaths_mean',\n", + " 'admis_mean', 'newICU_mean', 'totdea_mean', 'bedover_mean',\n", + " 'icuover_mean', 'mobility_composite', 'total_tests',\n", + " 'confirmed_infections', 'smp', 'testy', 'testyl', 'zar', 'chor', 'zgo',\n", + " 'wyl', 'pieszo', 'pojazdem', 'hosp', 'kwar', 'kwar_z', 'nadzor', 'date',\n", + " 'zar_log', 'suma', 'diff', 'label', 'faza'],\n", + " dtype='object')" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.columns" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Ploty do prezentacji" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.pairplot(df.loc[:, [\"faza\", \"Interwencje\", \"zar\", \"pieszo\", \"temperature\"]], kind=\"scatter\", hue=\"faza\", palette=\"Set2\", corner = True)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "corr = df.loc[:, [\"faza\", \"Interwencje\", \"zar\", \"pieszo\", \"temperature\"]].corr()\n", + "\n", + "# Generate a mask for the upper triangle\n", + "mask = np.triu(np.ones_like(corr, dtype=bool))\n", + "\n", + "# Set up the matplotlib figure\n", + "f, ax = plt.subplots(figsize=(11, 9))\n", + "\n", + "# Generate a custom diverging colormap\n", + "cmap = sns.diverging_palette(230, 20, as_cmap=True)\n", + "\n", + "# Draw the heatmap with the mask and correct aspect ratio\n", + "sns.heatmap(corr, mask=mask, cmap=cmap, vmax=.3, center=0,\n", + " square=True, linewidths=.5, cbar_kws={\"shrink\": .5})" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
fazaInterwencjezarpieszotemperature
faza1.0000000.3632750.9460590.1248380.627355
Interwencje0.3632751.0000000.3034690.1352580.574821
zar0.9460590.3034691.0000000.0051700.653119
pieszo0.1248380.1352580.0051701.0000000.049458
temperature0.6273550.5748210.6531190.0494581.000000
\n", + "
" + ], + "text/plain": [ + " faza Interwencje zar pieszo temperature\n", + "faza 1.000000 0.363275 0.946059 0.124838 0.627355\n", + "Interwencje 0.363275 1.000000 0.303469 0.135258 0.574821\n", + "zar 0.946059 0.303469 1.000000 0.005170 0.653119\n", + "pieszo 0.124838 0.135258 0.005170 1.000000 0.049458\n", + "temperature 0.627355 0.574821 0.653119 0.049458 1.000000" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "corr" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ARIMA" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "from pandas.plotting import autocorrelation_plot" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "autocorrelation_plot(df.loc[:, \"zar\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [], + "source": [ + "from statsmodels.tsa.arima.model import ARIMA, ARIMAResults\n", + "from matplotlib import pyplot\n", + "df.index = pd.to_datetime(df.index)\n", + "series = pd.Series(df.loc[:, \"zar\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/pk/miniconda3/envs/corona-analysis-1/lib/python3.8/site-packages/statsmodels/tsa/statespace/sarimax.py:966: UserWarning: Non-stationary starting autoregressive parameters found. Using zeros as starting parameters.\n", + " warn('Non-stationary starting autoregressive parameters'\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " SARIMAX Results \n", + "==============================================================================\n", + "Dep. Variable: zar No. Observations: 77\n", + "Model: ARIMA(10, 1, 0) Log Likelihood -434.900\n", + "Date: Sun, 11 Jul 2021 AIC 891.800\n", + "Time: 20:44:47 BIC 917.438\n", + "Sample: 03-31-2020 HQIC 902.046\n", + " - 05-31-2020 \n", + "Covariance Type: opg \n", + "==============================================================================\n", + " coef std err z P>|z| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "ar.L1 0.2797 0.096 2.923 0.003 0.092 0.467\n", + "ar.L2 0.3875 0.121 3.204 0.001 0.150 0.625\n", + "ar.L3 0.1111 0.170 0.652 0.514 -0.223 0.445\n", + "ar.L4 -0.0012 0.129 -0.009 0.993 -0.253 0.251\n", + "ar.L5 0.0270 0.166 0.163 0.870 -0.298 0.352\n", + "ar.L6 0.1159 0.162 0.716 0.474 -0.202 0.433\n", + "ar.L7 0.1979 0.175 1.132 0.258 -0.145 0.541\n", + "ar.L8 -0.0360 0.154 -0.234 0.815 -0.338 0.266\n", + "ar.L9 -0.0840 0.192 -0.437 0.662 -0.461 0.293\n", + "ar.L10 -0.0133 0.134 -0.099 0.921 -0.277 0.250\n", + "sigma2 5237.5946 850.730 6.157 0.000 3570.195 6904.994\n", + "===================================================================================\n", + "Ljung-Box (L1) (Q): 0.15 Jarque-Bera (JB): 6.33\n", + "Prob(Q): 0.70 Prob(JB): 0.04\n", + "Heteroskedasticity (H): 7.14 Skew: 0.37\n", + "Prob(H) (two-sided): 0.00 Kurtosis: 4.21\n", + "===================================================================================\n", + "\n", + "Warnings:\n", + "[1] Covariance matrix calculated using the outer product of gradients (complex-step).\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 0\n", + "count 77.000000\n", + "mean 14.572279\n", + "std 70.839854\n", + "min -138.266728\n", + "25% -13.565511\n", + "50% 14.875748\n", + "75% 39.552829\n", + "max 251.114475\n" + ] + } + ], + "source": [ + "series.index = series.index.to_period('M')\n", + "# fit model\n", + "model = ARIMA(series, order=(10,1,0))\n", + "model_fit = model.fit()\n", + "# summary of fit model\n", + "print(model_fit.summary())\n", + "# line plot of residuals\n", + "residuals = pd.DataFrame(model_fit.resid)\n", + "residuals.plot()\n", + "pyplot.show()\n", + "# density plot of residuals\n", + "residuals.plot(kind='kde')\n", + "pyplot.show()\n", + "# summary stats of residuals\n", + "print(residuals.describe())" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2026-08 19603.707474\n", + "Freq: M, dtype: float64" + ] + }, + "execution_count": 95, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_fit.forecast()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1144,7 +1565,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" + "version": "3.8.10" } }, "nbformat": 4, From 31efba7946af4ec89891567e6fcaa48eb1227b1b Mon Sep 17 00:00:00 2001 From: Piotr Krawiec Date: Fri, 16 Jul 2021 16:10:02 +0200 Subject: [PATCH 19/24] add about us --- presentation.md | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/presentation.md b/presentation.md index f014c60..9df1daa 100644 --- a/presentation.md +++ b/presentation.md @@ -7,5 +7,22 @@ abstract: | Lorem ipsum dolor sit amet --- -# Document Title +# O nas + +Jesteśmy studentami Politechniki Rzeszowskiej na kierunku Inżynieria i analiza danych, +a także członkami nowo stworzonego koła uczenia maszynowego. + + +# Nasz cel + +Chcemy pokazać to, co udało nam się odkryć w trakcie realizacji pierwszego Hackathonu +realizowanego w naszym kole, a dotyczył on pandemii. Naszym celem było znalezienie, +reguł asocjacyjnych i ciekawych zależności w danych z zachowań, które docelowo miały +nam posłużyć do lepszego zrozumienia sposobu rozprzestrzeniania się koronawirusa Sars-Cov-2 +i przewidywania ilości zachorowań. + +# Dane + +Jeszcze, gdy zaczynaliśmy, liczba zachorowań nie przekraczała 500 osób dziennie (był to +okres od marca do maja 2020). From d16515b8bd348e14994717f5b2bf529547f783bf Mon Sep 17 00:00:00 2001 From: Piotr Krawiec Date: Fri, 16 Jul 2021 16:14:39 +0200 Subject: [PATCH 20/24] add comment --- presentation.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/presentation.md b/presentation.md index 9df1daa..23e9967 100644 --- a/presentation.md +++ b/presentation.md @@ -11,7 +11,7 @@ abstract: | Jesteśmy studentami Politechniki Rzeszowskiej na kierunku Inżynieria i analiza danych, a także członkami nowo stworzonego koła uczenia maszynowego. - +[//]: # (Dodać logo koła naukowego) # Nasz cel From 32fd28b0121e960e96a3fb5193cb95835c3a64fa Mon Sep 17 00:00:00 2001 From: Piotr Krawiec Date: Sun, 18 Jul 2021 14:51:29 +0200 Subject: [PATCH 21/24] expand introduction --- presentation.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/presentation.md b/presentation.md index 23e9967..fec20c3 100644 --- a/presentation.md +++ b/presentation.md @@ -19,7 +19,11 @@ Chcemy pokazać to, co udało nam się odkryć w trakcie realizacji pierwszego H realizowanego w naszym kole, a dotyczył on pandemii. Naszym celem było znalezienie, reguł asocjacyjnych i ciekawych zależności w danych z zachowań, które docelowo miały nam posłużyć do lepszego zrozumienia sposobu rozprzestrzeniania się koronawirusa Sars-Cov-2 -i przewidywania ilości zachorowań. +i przewidywania ilości zachorowań. + +Pokażemy, w jaki sposób pracowaliśmy, jakich technik używaliśmy i jak zdobyliśmy +dane, których używaliśmy. Mamy nadzieję, że są wśród was studenci, których +zainteresujemy naszą pracą i dołączą do naszego koła naukowego. # Dane From ce890f1f1cd334f3d687dc7ccb53dcc736665014 Mon Sep 17 00:00:00 2001 From: Piotr Krawiec Date: Mon, 19 Jul 2021 10:16:13 +0200 Subject: [PATCH 22/24] split slides --- presentation.md | 24 ++++++++++++++++++++---- 1 file changed, 20 insertions(+), 4 deletions(-) diff --git a/presentation.md b/presentation.md index c1d0027..3793ea8 100644 --- a/presentation.md +++ b/presentation.md @@ -7,14 +7,21 @@ abstract: | Lorem ipsum dolor sit amet --- -# Źródła danych +# Jak znaleźć źródła danych? -To było pierwszym sporym wyzwaniem w naszym projekcie, ponieważ szczególnie na -początku pandemii dostęp do szczegółowych danych nie był tak prosty, ponieważ: +To było pierwszym pytaniem jakie zadaliśmy sobie w naszym projekcie, ponieważ szczególnie na +początku pandemii dostęp do szczegółowych danych nie był tak prosty. Powodów było kilka: - na stronie ministerstwa publikowane były wyłącznie dane z danego dnia. - publicznie dostępne dane dotyczące wielu krajów nie zawierały podziału na województwa. + +A nas szczególnie interesowały dane właśnie z podziałem na województwa, ewentualnie +na jeszcze mniejsze jednostki podziału terytorialnego. + +--- + +# Źródła danych Na szczęście udało nam się znaleźć inne źródła, tj. strony tworzone przez ludzi, którzy codziennie sami zbierali te dane i udostępniali je w formie wykresów. @@ -27,6 +34,8 @@ Do głównych źródeł danych zaliczyć możemy: - koronawirusunas.pl - policja.pl +--- + # Techniki zbierania danych Główną techniką wykorzystywaną przez nas wył web scraping, stworzyliśmy skrypty, @@ -35,11 +44,18 @@ które pozostałe dane były udostępnione publicznie w formie skompresowanych plików, także aktualizowanych codziennie. +--- + # Jak pracowaliśmy z danymi Te dane musiały zostac sprowadzone do wspólnego formatu, tak aby wszystkie stworzone wykresy i analizy można było odtwarzać natychmiast po aktualizacji -danych. Do tego wykorzystaliśmy pythona i Jupyterlab. +danych, ponieważ te zmieniały się z dnia na dzień wraz z rozwojem pandemii. +Do tego wykorzystaliśmy pythona i Jupyterlab. + +--- + +# Jak pracowaliśmy z danymi Z pomoca jupyterlab można stworzyć interaktywne notatniki, które działają krok po kroku, jeden z nich służył wyłącznie do pobrania danych ze wszystkich źródeł From 59682d64b9112f3a028325979181a11447a75074 Mon Sep 17 00:00:00 2001 From: Piotr Krawiec Date: Mon, 19 Jul 2021 10:42:02 +0200 Subject: [PATCH 23/24] reformat and add Dane slide --- presentation.md | 52 ++++++++++++++++++++++++++----------------------- 1 file changed, 28 insertions(+), 24 deletions(-) diff --git a/presentation.md b/presentation.md index 99d6f08..e8c3d28 100644 --- a/presentation.md +++ b/presentation.md @@ -9,44 +9,48 @@ abstract: | # O nas -Jesteśmy studentami Politechniki Rzeszowskiej na kierunku Inżynieria i analiza danych, -a także członkami nowo stworzonego koła uczenia maszynowego. +Jesteśmy studentami Politechniki Rzeszowskiej na kierunku Inżynieria i analiza +danych, a także członkami nowo stworzonego koła uczenia maszynowego. [//]: # (Dodać logo koła naukowego) --- # Nasz cel -Chcemy pokazać to, co udało nam się odkryć w trakcie realizacji pierwszego Hackathonu -realizowanego w naszym kole, a dotyczył on pandemii. Naszym celem było znalezienie, -reguł asocjacyjnych i ciekawych zależności w danych z zachowań, które docelowo miały -nam posłużyć do lepszego zrozumienia sposobu rozprzestrzeniania się koronawirusa Sars-Cov-2 -i przewidywania ilości zachorowań. +Chcemy pokazać to, co udało nam się odkryć w trakcie realizacji pierwszego +Hackathonu realizowanego w naszym kole, a dotyczył on pandemii. Naszym celem +było znalezienie, reguł asocjacyjnych i ciekawych zależności w danych z +zachowań, które docelowo miały nam posłużyć do lepszego zrozumienia sposobu +rozprzestrzeniania się koronawirusa Sars-Cov-2 i przewidywania ilości +zachorowań. -Pokażemy, w jaki sposób pracowaliśmy, jakich technik używaliśmy i jak zdobyliśmy -dane, których używaliśmy. Mamy nadzieję, że są wśród was studenci, których +Pokażemy, w jaki sposób pracowaliśmy, jakich technik używaliśmy i jak zdobyliśmy +dane, których używaliśmy. Mamy nadzieję, że są wśród was studenci, których zainteresujemy naszą pracą i dołączą do naszego koła naukowego. --- # Dane -Jeszcze, gdy zaczynaliśmy, liczba zachorowań nie przekraczała 500 osób dziennie (był to -okres od marca do maja 2020). +Jeszcze, gdy zaczynaliśmy, liczba zachorowań nie przekraczała 500 osób +dziennie (był to okres od marca do maja 2020), wtedy kolejnymi falami określano +niewielkie z perspektywy czasu wzrosty zakażeń. (Tutaj będzie wykres zakażeń z +marca 2020). --- # Jak znaleźć źródła danych? -To było pierwszym pytaniem, jakie zadaliśmy sobie w naszym projekcie, ponieważ szczególnie na -początku pandemii dostęp do szczegółowych danych nie był tak prosty. Powodów było kilka: +To było pierwszym pytaniem, jakie zadaliśmy sobie w naszym projekcie, ponieważ +szczególnie na początku pandemii dostęp do szczegółowych danych nie był tak +prosty. Powodów było kilka: - na stronie ministerstwa publikowane były wyłącznie dane z danego dnia. - publicznie dostępne dane dotyczące wielu krajów nie zawierały podziału na województwa. - -A nas szczególnie interesowały dane właśnie z podziałem na województwa, ewentualnie -na jeszcze mniejsze jednostki podziału terytorialnego. + +A nas szczególnie interesowały dane właśnie z podziałem na województwa, +ewentualnie na jeszcze mniejsze jednostki podziału terytorialnego. --- @@ -54,8 +58,9 @@ na jeszcze mniejsze jednostki podziału terytorialnego. Na szczęście udało nam się znaleźć inne źródła, tj. strony tworzone przez ludzi, którzy codziennie sami zbierali te dane i udostępniali je w formie wykresów. -Przykładem takiej strony jest koronawirusunas.pl . Dzięki danym na niej zawartym -udało nam się przeprowadzić. +Przykładem takiej strony jest koronawirusunas.pl . Dzięki uprzejmości jej +twórców udało nam się pobrać dane na niej zawarte i przeprowadzić wszystkie +analizy. Do głównych źródeł danych zaliczyć możemy: @@ -68,10 +73,9 @@ Do głównych źródeł danych zaliczyć możemy: # Techniki zbierania danych Główną techniką wykorzystywaną przez nas wył web scraping, stworzyliśmy skrypty, -które -(oczywiście za zgodą właścicieli portali) pobierały z nich bieżące dane. Z kolei -pozostałe dane były udostępnione publicznie w formie skompresowanych plików, -także aktualizowanych codziennie. +które (oczywiście za zgodą właścicieli portali) pobierały z nich bieżące dane. Z +kolei pozostałe dane były udostępnione publicznie w formie skompresowanych +plików, także aktualizowanych codziennie. --- @@ -79,8 +83,8 @@ także aktualizowanych codziennie. Te dane musiały zostac sprowadzone do wspólnego formatu, tak aby wszystkie stworzone wykresy i analizy można było odtwarzać natychmiast po aktualizacji -danych, ponieważ te zmieniały się z dnia na dzień wraz z rozwojem pandemii. -Do tego wykorzystaliśmy pythona i Jupyterlab. +danych, ponieważ te zmieniały się z dnia na dzień wraz z rozwojem pandemii. Do +tego wykorzystaliśmy pythona i Jupyterlab. --- From a767b861be0c0fdea1989dd58316d6837a62d968 Mon Sep 17 00:00:00 2001 From: Piotr Krawiec Date: Mon, 19 Jul 2021 11:22:38 +0200 Subject: [PATCH 24/24] requested changes #1 --- presentation.md | 42 +++++++++++++++--------------------------- 1 file changed, 15 insertions(+), 27 deletions(-) diff --git a/presentation.md b/presentation.md index e8c3d28..f484d66 100644 --- a/presentation.md +++ b/presentation.md @@ -10,55 +10,48 @@ abstract: | # O nas Jesteśmy studentami Politechniki Rzeszowskiej na kierunku Inżynieria i analiza -danych, a także członkami nowo stworzonego koła uczenia maszynowego. +danych, a także członkami nowo stworzonego koła uczenia maszynowego. Chcemy +pokazać to, co udało nam się odkryć w trakcie realizacji pierwszego Hackathonu +realizowanego w naszym kole, a dotyczył on pandemii. [//]: # (Dodać logo koła naukowego) ---- - # Nasz cel -Chcemy pokazać to, co udało nam się odkryć w trakcie realizacji pierwszego -Hackathonu realizowanego w naszym kole, a dotyczył on pandemii. Naszym celem -było znalezienie, reguł asocjacyjnych i ciekawych zależności w danych z -zachowań, które docelowo miały nam posłużyć do lepszego zrozumienia sposobu -rozprzestrzeniania się koronawirusa Sars-Cov-2 i przewidywania ilości +Naszym celem było znalezienie, reguł asocjacyjnych i ciekawych zależności w +danych z zachorwań, które docelowo miały nam posłużyć do lepszego zrozumienia +sposobu rozprzestrzeniania się koronawirusa SARS-COV-2 i przewidywania ilości zachorowań. Pokażemy, w jaki sposób pracowaliśmy, jakich technik używaliśmy i jak zdobyliśmy dane, których używaliśmy. Mamy nadzieję, że są wśród was studenci, których zainteresujemy naszą pracą i dołączą do naszego koła naukowego. ---- - # Dane Jeszcze, gdy zaczynaliśmy, liczba zachorowań nie przekraczała 500 osób dziennie (był to okres od marca do maja 2020), wtedy kolejnymi falami określano -niewielkie z perspektywy czasu wzrosty zakażeń. (Tutaj będzie wykres zakażeń z -marca 2020). +niewielkie z perspektywy czasu wzrosty zakażeń. ---- +![Tutaj będzie wykres zakażeń z marca 2020](img/obrazek.png) # Jak znaleźć źródła danych? -To było pierwszym pytaniem, jakie zadaliśmy sobie w naszym projekcie, ponieważ -szczególnie na początku pandemii dostęp do szczegółowych danych nie był tak -prosty. Powodów było kilka: +To było pierwszym pytanie, jakie zadaliśmy sobie w naszym projekcie. Szczególnie +na początku pandemii dostęp do szczegółowych danych nie był tak prosty. Powodów +było kilka: - na stronie ministerstwa publikowane były wyłącznie dane z danego dnia. - publicznie dostępne dane dotyczące wielu krajów nie zawierały podziału na województwa. -A nas szczególnie interesowały dane właśnie z podziałem na województwa, -ewentualnie na jeszcze mniejsze jednostki podziału terytorialnego. - ---- +A szczególnie interesowały nas dane z podziałem na województwa, ewentualnie na +jeszcze mniejsze jednostki podziału terytorialnego. # Źródła danych Na szczęście udało nam się znaleźć inne źródła, tj. strony tworzone przez ludzi, którzy codziennie sami zbierali te dane i udostępniali je w formie wykresów. -Przykładem takiej strony jest koronawirusunas.pl . Dzięki uprzejmości jej +Przykładem takiej strony jest . Dzięki uprzejmości jej twórców udało nam się pobrać dane na niej zawarte i przeprowadzić wszystkie analizy. @@ -68,7 +61,6 @@ Do głównych źródeł danych zaliczyć możemy: - koronawirusunas.pl - policja.pl ---- # Techniki zbierania danych @@ -77,8 +69,6 @@ które (oczywiście za zgodą właścicieli portali) pobierały z nich bieżące kolei pozostałe dane były udostępnione publicznie w formie skompresowanych plików, także aktualizowanych codziennie. ---- - # Jak pracowaliśmy z danymi Te dane musiały zostac sprowadzone do wspólnego formatu, tak aby wszystkie @@ -86,8 +76,6 @@ stworzone wykresy i analizy można było odtwarzać natychmiast po aktualizacji danych, ponieważ te zmieniały się z dnia na dzień wraz z rozwojem pandemii. Do tego wykorzystaliśmy pythona i Jupyterlab. ---- - # Jak pracowaliśmy z danymi Z pomoca jupyterlab można stworzyć interaktywne notatniki, które działają krok @@ -97,4 +85,4 @@ w osobnym notatniku, co umożliwiło nam zapanowanie nad projektem. Oczywiście korzystanie z notatników też ma swoje wady, kolejne zmiany utrzymywane w systemie kontroli wersji Git nie są czytalne. -![](img/zar.png) \ No newline at end of file +![Wykres zarażeń województwa + Polska](img/zar.png) \ No newline at end of file