markdown
stringlengths 0
1.02M
| code
stringlengths 0
832k
| output
stringlengths 0
1.02M
| license
stringlengths 3
36
| path
stringlengths 6
265
| repo_name
stringlengths 6
127
|
|---|---|---|---|---|---|
1. Introduction to Feature SelectionFeature selection is the process of selecting a subset of relevant features (variables, predictors) for use in model construction. It is used for three reasons:* simplification of models to make them easier to interpret by researchers/users,* shorter training times,* enhanced generalization by reducing overfittingThe central premise when using a feature selection technique is that the data contains many features that are either redundant or irrelevant, and can thus be removed without incurring much loss of information.There are three main categories of feature selection algorithms: wrappers, filters and embedded methods. [1] This tutorial will mainly focuses on one of the well-known embedded methods Lasso and its variants. 2. Introduction to Lasso 2.1 What's LassoLasso is one of the embedded methods for feature selection. Embedded methods are a group of techniques which perform feature selection as part of the model construction process.Lasso penalizes the regressin coefficients in a linear model with an L1 penalty. Lasso can shrinking many of coefficients to zero and leads to sparse results. From this point of view, any features which have non-zero regression coefficients are 'selected' by the Lasso.The loss function of a linear model with L1 penalty will have the following form:$\frac{1}{2} \sum_{n=1}^{N}\{t_n - w^T\phi(x_n)\}^2 + \frac{\alpha}{2} \sum_{j=1}^{M} |w_j|$The first part is the square loss function. The second part is the L1 penalty $\frac{\alpha}{2} \sum_{j=1}^{M} |w_j|$, in which M is the total number of features, $w$ is the coefficient vector, $\alpha$ controls how much L1 penalty the contributes to the overall loss and how many features will be selected. L1 penalty can also be used to improve the generalization of the model because it penalty the model complexity by $\sum_{j=1}^{M} |w_j|$ in the loss function. 2.2 Why Lasso Can be Used for Feature SelectionFirstly, if all the features are in the same scale. The coefficients of a linear model can represents how important the corresponding feature is. In **Exp. 1**, I simulate a regression problem with three features (in the same scale). The regression target y is a linear combination of the features plus some guassion noise.$y = 0 * x_0 + 1 * x_1 + 2 * x_2 + noise$ So from the setup of experiment 1, we can see that the importance of different features is$x_2 > x_1 > x_0$ | # set the random seed
rng = np.random.RandomState(0) | _____no_output_____ | MIT | 2016/tutorial_final/75/Feature Selection Tutorial.ipynb | zeromtmu/practicaldatascience.github.io |
**Exp. 1** | # Exp 1
n_samples = 10000
n_features = 3
noise_level = 0.2
X = rng.rand(n_samples, n_features)
coef = np.zeros(n_features)
coef[0] = 0.0
coef[1] = 1.0
coef[2] = 2.0
y = np.dot(X, coef) + noise_level * rng.normal(size=n_samples)
lr = LinearRegression()
lr.fit(X, y)
print 'Exp. 1, coefficient of linear regression\n%s' % str(lr.coef_)
lr = Lasso(alpha=0.001)
lr.fit(X, y)
print 'Exp. 1, coefficient of lasso\n%s' % str(lr.coef_) | Exp. 1, coefficient of linear regression
[-0.01119616 0.99446444 1.99559463]
Exp. 1, coefficient of lasso
[-0. 0.98258754 1.98367942]
| MIT | 2016/tutorial_final/75/Feature Selection Tutorial.ipynb | zeromtmu/practicaldatascience.github.io |
As we can see from **Exp. 1**, we can easily find the feature importances from the coefficient of the trained model.And an important characteristic of the L1 penalty is that it will leads to sparse models. Sparse models means the weight of unimportant/irrelevent features will shrink to 0. In **Exp. 1**, the first feature $x_0$ is actually have nothing to do with our target. Its coefficient in the linear regression model is a very small value (still have some small contribution to the target, not exactly irrelevant). However, Lasso will directly shrink its coefficient to 0, which indicates that it's actually an irrelevant feature. Here is another example shows how lasso performs when there are lots of irrelevant features. **Exp. 2** is also a regression problem with 50 features. However only 5 of them are relevant to the target ($x_0 - x_4$). **Exp. 2** Some help functions:* plot_sel_path: plot how will the coefficients for relevant and irrelevant features change with different $\alpha$ setting | def plot_sel_path(X, y, coef, method='Lasso'):
"""Plot feature selection result
"""
if method == 'Lasso':
# alpha_grid, _, scores_path = lars_path(X, y, method='lasso', eps=0.05)
alpha_grid, scores_path, _ = lasso_path(X, y, eps=0.001)
elif method == 'Stability':
alpha_grid, scores_path = lasso_stability_path(X, y, scaling=0.3, eps=0.001)
plt.figure()
hg = plt.plot(alpha_grid[1:] , scores_path[coef != 0].T[1:], 'r')
hb = plt.plot(alpha_grid[1:] , scores_path[coef == 0].T[1:], 'k')
ymin, ymax = plt.ylim()
plt.xlabel(r'$(\alpha / \alpha_{max})$')
plt.ylabel('Score for each feature')
plt.axis('tight')
plt.legend((hg[0], hb[0]), ('relevant features', 'irrelevant features'),
loc='best')
# Exp. 2
n_samples = 10000
n_features = 50
n_relevant_features = 5
noise_level = 0.2
X = rng.rand(n_samples, n_features)
coef = np.zeros(n_features)
coef[:n_relevant_features] = rng.rand(n_relevant_features)
y = np.dot(X, coef)
y += noise_level * rng.normal(size=n_samples)
print 'Exp. 2, coefficients setting for the relevant features\n %s' % str(coef[:n_relevant_features])
plot_sel_path(X, y, coef, "Lasso") | Exp. 2, coefficients setting for the relevant features
[ 0.5754498 0.93597176 0.66245048 0.32697755 0.4974818 ]
| MIT | 2016/tutorial_final/75/Feature Selection Tutorial.ipynb | zeromtmu/practicaldatascience.github.io |
As we can see from the results, although lots of irrelevant features are given to the model. Lasso will shrink their coefficients to 0 very quickly. 2.4 Drawbacks of LassoThere are some well-known limitations of Lasso, including1. Lasso will tend to select an individual variable out of a group of highly correlated features,2. even when the correlation between features is not too high, the conditions under which L1-penalized methods consistently select “good” features can be restrictive in general. 3. Variants of LassoThere are lots of variants of Lasso that try to overcome some of the drawbacks.One of the interesting work is Stability Selection. Sometimes, it's also called Randomized Lasso. It works by subsampling the training data and computing a Lasso estimate where the penalty of a random subset of coefficients has been scaled. Bolasso (Bootstrapped Lasso) is very similar, which using bootstraping to conduct random sampling.By performing this double randomization several times, the method assigns high scores to features that are repeatedly selected across randomizations. In short, features selected more often are considered good features. In **Exp. 3**, we generate some coherent features for a regression problem. Since there are some corelation between the features. Lasso will fail to select all relevant features. **Exp. 3** Some help function* gen_simulation_dataset: generate some coherent random features for a regression problem | def gen_simulation_dataset(n_features=50, n_relevant_features=3,
noise_level=0.2, coef_min=0.2, n_samples=10000,
rng=np.random.RandomState(0), conditioning=1):
block_size = n_relevant_features
# The coefficients of our model
coef = np.zeros(n_features)
coef[:n_relevant_features] = coef_min + rng.rand(n_relevant_features)
# The correlation of our design: variables correlated by blocs of 3
corr = np.zeros((n_features, n_features))
for i in range(0, n_features, block_size):
corr[i:i + block_size, i:i + block_size] = 1 - conditioning
corr.flat[::n_features + 1] = 1
corr = linalg.cholesky(corr)
#
X = rng.normal(size=(n_samples, n_features))
X = np.dot(X, corr)
# Keep [Wainwright2006] (26c) constant
X[:n_relevant_features] /= np.abs(
linalg.svdvals(X[:n_relevant_features])).max()
X = StandardScaler().fit_transform(X.copy())
# The output variable
y = np.dot(X, coef)
y /= np.std(y)
# We scale the added noise as a function of the average correlation
# between the design and the output variable
y += noise_level * rng.normal(size=n_samples)
return X, y, coef
# Exp 3
X, y, coef = gen_simulation_dataset(n_samples=500, rng=rng, conditioning=1e-4)
print 'Exp. 3, coefficients of the relevant features\n%s' % str(coef[coef!=0])
plot_sel_path(X, y, coef, 'Lasso')
plot_sel_path(X, y, coef, 'Stability') | Exp. 3, coefficients of the relevant features
[ 0.42871572 0.31671741 0.69989626]
| MIT | 2016/tutorial_final/75/Feature Selection Tutorial.ipynb | zeromtmu/practicaldatascience.github.io |
As we can see from the results, Lasso will fail to select all the relevant features if there are some corelation between the features. However, Randomized Lasso or Stability Selection will overcome such drawback and select all relevant features. 4. Real DatasetIn this section, we will conduct some experiments to see how Lasso and Randomized Lasso performed on a real dataset. In **Exp. 4**, I am using the same dataset in the contest for assignment 4. So you can download the dataset from the course website [link](http://www.datasciencecourse.org/hw/4/data.tar.gz). I use the tiidf as the features and them conduct feature selection on top of it using Lasso. **Exp. 4** | def read(idx):
f_X = 'data/X'+str(idx)+'.txt'
f_Y = 'data/Y'+str(idx)+'.txt'
f = open(f_X, 'r')
x = []
for l in f:
x.append(l)
f.close()
f = open(f_Y, 'r')
y = []
for l in f:
y.append(int(l))
f.close()
return x, y
x_all = []
y_all = []
for i in range(1, 9):
x, y = read(i)
x_all.extend(x)
y_all.extend(y)
x_true = []
x_false = []
for i in range(len(y_all)):
if y_all[i] == 1:
x_true.append(x_all[i])
else:
x_false.append(x_all[i])
print len(x_all), len(y_all), len(x_true), len(x_false) | 80000 80000 36326 43674
| MIT | 2016/tutorial_final/75/Feature Selection Tutorial.ipynb | zeromtmu/practicaldatascience.github.io |
After loading the whole dataset, we transfer it into tfidf matrix. | from natural_language_processing import tfidf
tfidf_all, words_all = tfidf(x_all)
print tfidf_all.shape | (80000, 1245607)
| MIT | 2016/tutorial_final/75/Feature Selection Tutorial.ipynb | zeromtmu/practicaldatascience.github.io |
So there are about 1245607 features in total. | from sklearn.feature_selection import SelectFromModel
from sklearn.svm import LinearSVC
X = tfidf_all
y = y_all
lsvc = LinearSVC(C=0.02, penalty="l1", dual=False).fit(X, y)
model = SelectFromModel(lsvc, prefit=True, threshold='mean')
X_new = model.transform(X)
print X_new.shape
mask = model.get_support()
print 'Number of feature selected'
print np.sum(mask)
print 'After feature selection'
lsvc.fit(X_new, y)
y_pred = lsvc.predict(X_new)
print np.sum(y_pred != y) / float(len(y)) | (80000, 1307)
Number of feature selected
1307
After feature selection
0.0002
| MIT | 2016/tutorial_final/75/Feature Selection Tutorial.ipynb | zeromtmu/practicaldatascience.github.io |
Make a bar plot of the months in which movies with "Christmas" in their title tend to be released in the USA. | r = release_dates
r = r[(r.title.str.contains("Christmas", re.IGNORECASE, regex=True)) &
(r.country == "USA")
]
r = r.groupby(r.date.dt.month).size()
r.plot(kind='bar', xlabel="month") | _____no_output_____ | MIT | Exercises-5.ipynb | zazke/pycon-pandas-tutorial |
Make a bar plot of the months in which movies whose titles start with "The Hobbit" are released in the USA. | r = release_dates
r = r[(r.title.str.contains("The Hobbit")) &
(r.country == "USA")
]
r = r.groupby(r.date.dt.month).size()
r
r.plot(kind='bar', xlabel="month") | _____no_output_____ | MIT | Exercises-5.ipynb | zazke/pycon-pandas-tutorial |
Make a bar plot of the day of the week on which movies with "Romance" in their title tend to be released in the USA. | r = release_dates
r = r[(r.title.str.contains("Romance")) &
(r.country == "USA")
]
r = r.groupby(r.date.dt.dayofweek).size()
r
r.plot(kind='bar', xlabel="dayofweek (0=Monday)") | _____no_output_____ | MIT | Exercises-5.ipynb | zazke/pycon-pandas-tutorial |
Make a bar plot of the day of the week on which movies with "Action" in their title tend to be released in the USA. | r = release_dates
r = r[(r.title.str.contains("Action")) &
(r.country == "USA")
]
r = r.groupby(r.date.dt.dayofweek).size()
r
r.plot(kind='bar', xlabel="dayofweek (0=Monday)") | _____no_output_____ | MIT | Exercises-5.ipynb | zazke/pycon-pandas-tutorial |
On which date was each Judi Dench movie from the 1990s released in the USA? | release_dates.columns
c = cast
c = c[(c.name == 'Judi Dench') &
(c.year // 10 * 10 == 1990)]
c = c.merge(release_dates, on=['title', 'year'])
c = c[(c.country == 'USA')]
c
# data not available | _____no_output_____ | MIT | Exercises-5.ipynb | zazke/pycon-pandas-tutorial |
In which months do films with Judi Dench tend to be released in the USA? | c.groupby(c.date.dt.month).size() | _____no_output_____ | MIT | Exercises-5.ipynb | zazke/pycon-pandas-tutorial |
November (11月) and December (12月) In which months do films with Tom Cruise tend to be released in the USA? | c = cast
c = c[(c.name == 'Tom Cruise')]
c = c.merge(release_dates, on=['title', 'year'])
c = c[(c.country == 'USA')]
c.head()
c.groupby(c.date.dt.month).size() | _____no_output_____ | MIT | Exercises-5.ipynb | zazke/pycon-pandas-tutorial |
TAXI! | mitexto = "el perro de san roque no tiene rabo"
help(str)
str.title(mitexto) | _____no_output_____ | MIT | pythonUPVX32.ipynb | Coldang/pythonMoocCompanion |
pero **mitexto** es de tipo str podriamos tal vez... | mitexto.title() | _____no_output_____ | MIT | pythonUPVX32.ipynb | Coldang/pythonMoocCompanion |
encadenando llamadas | mitexto.replace('san','mr').title() | _____no_output_____ | MIT | pythonUPVX32.ipynb | Coldang/pythonMoocCompanion |
Build Your First QA System[](https://colab.research.google.com/github/deepset-ai/haystack/blob/master/tutorials/Tutorial1_Basic_QA_Pipeline.ipynb)Question Answering can be used in a variety of use cases. A very common one: Using it to navigate through complex knowledge bases or long documents ("search setting").A "knowledge base" could for example be your website, an internal wiki or a collection of financial reports. In this tutorial we will work on a slightly different domain: "Game of Thrones". Let's see how we can use a bunch of Wikipedia articles to answer a variety of questions about the marvellous seven kingdoms. Prepare environment Colab: Enable the GPU runtimeMake sure you enable the GPU runtime to experience decent speed in this tutorial.**Runtime -> Change Runtime type -> Hardware accelerator -> GPU** | # Make sure you have a GPU running
!nvidia-smi
# Install the latest release of Haystack in your own environment
#! pip install farm-haystack
# Install the latest master of Haystack
!pip install grpcio-tools==1.34.1
!pip install git+https://github.com/deepset-ai/haystack.git
# If you run this notebook on Google Colab, you might need to
# restart the runtime after installing haystack.
from haystack.preprocessor.cleaning import clean_wiki_text
from haystack.preprocessor.utils import convert_files_to_dicts, fetch_archive_from_http
from haystack.reader.farm import FARMReader
from haystack.reader.transformers import TransformersReader
from haystack.utils import print_answers | _____no_output_____ | Apache-2.0 | tutorials/Tutorial1_Basic_QA_Pipeline.ipynb | tcapilla/haystack |
Document StoreHaystack finds answers to queries within the documents stored in a `DocumentStore`. The current implementations of `DocumentStore` include `ElasticsearchDocumentStore`, `FAISSDocumentStore`, `SQLDocumentStore`, and `InMemoryDocumentStore`.**Here:** We recommended Elasticsearch as it comes preloaded with features like [full-text queries](https://www.elastic.co/guide/en/elasticsearch/reference/current/full-text-queries.html), [BM25 retrieval](https://www.elastic.co/elasticon/conf/2016/sf/improved-text-scoring-with-bm25), and [vector storage for text embeddings](https://www.elastic.co/guide/en/elasticsearch/reference/7.6/dense-vector.html).**Alternatives:** If you are unable to setup an Elasticsearch instance, then follow the [Tutorial 3](https://github.com/deepset-ai/haystack/blob/master/tutorials/Tutorial3_Basic_QA_Pipeline_without_Elasticsearch.ipynb) for using SQL/InMemory document stores.**Hint**: This tutorial creates a new document store instance with Wikipedia articles on Game of Thrones. However, you can configure Haystack to work with your existing document stores. Start an Elasticsearch serverYou can start Elasticsearch on your local machine instance using Docker. If Docker is not readily available in your environment (e.g. in Colab notebooks), then you can manually download and execute Elasticsearch from source. | # Recommended: Start Elasticsearch using Docker via the Haystack utility function
from haystack.utils import launch_es
launch_es()
# In Colab / No Docker environments: Start Elasticsearch from source
! wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-7.9.2-linux-x86_64.tar.gz -q
! tar -xzf elasticsearch-7.9.2-linux-x86_64.tar.gz
! chown -R daemon:daemon elasticsearch-7.9.2
import os
from subprocess import Popen, PIPE, STDOUT
es_server = Popen(['elasticsearch-7.9.2/bin/elasticsearch'],
stdout=PIPE, stderr=STDOUT,
preexec_fn=lambda: os.setuid(1) # as daemon
)
# wait until ES has started
! sleep 30
# Connect to Elasticsearch
from haystack.document_store.elasticsearch import ElasticsearchDocumentStore
document_store = ElasticsearchDocumentStore(host="localhost", username="", password="", index="document") | _____no_output_____ | Apache-2.0 | tutorials/Tutorial1_Basic_QA_Pipeline.ipynb | tcapilla/haystack |
Preprocessing of documentsHaystack provides a customizable pipeline for: - converting files into texts - cleaning texts - splitting texts - writing them to a Document StoreIn this tutorial, we download Wikipedia articles about Game of Thrones, apply a basic cleaning function, and index them in Elasticsearch. | # Let's first fetch some documents that we want to query
# Here: 517 Wikipedia articles for Game of Thrones
doc_dir = "data/article_txt_got"
s3_url = "https://s3.eu-central-1.amazonaws.com/deepset.ai-farm-qa/datasets/documents/wiki_gameofthrones_txt.zip"
fetch_archive_from_http(url=s3_url, output_dir=doc_dir)
# Convert files to dicts
# You can optionally supply a cleaning function that is applied to each doc (e.g. to remove footers)
# It must take a str as input, and return a str.
dicts = convert_files_to_dicts(dir_path=doc_dir, clean_func=clean_wiki_text, split_paragraphs=True)
# We now have a list of dictionaries that we can write to our document store.
# If your texts come from a different source (e.g. a DB), you can of course skip convert_files_to_dicts() and create the dictionaries yourself.
# The default format here is:
# {
# 'text': "<DOCUMENT_TEXT_HERE>",
# 'meta': {'name': "<DOCUMENT_NAME_HERE>", ...}
#}
# (Optionally: you can also add more key-value-pairs here, that will be indexed as fields in Elasticsearch and
# can be accessed later for filtering or shown in the responses of the Pipeline)
# Let's have a look at the first 3 entries:
print(dicts[:3])
# Now, let's write the dicts containing documents to our DB.
document_store.write_documents(dicts) | _____no_output_____ | Apache-2.0 | tutorials/Tutorial1_Basic_QA_Pipeline.ipynb | tcapilla/haystack |
Initalize Retriever, Reader, & Pipeline RetrieverRetrievers help narrowing down the scope for the Reader to smaller units of text where a given question could be answered.They use some simple but fast algorithm.**Here:** We use Elasticsearch's default BM25 algorithm**Alternatives:**- Customize the `ElasticsearchRetriever`with custom queries (e.g. boosting) and filters- Use `TfidfRetriever` in combination with a SQL or InMemory Document store for simple prototyping and debugging- Use `EmbeddingRetriever` to find candidate documents based on the similarity of embeddings (e.g. created via Sentence-BERT)- Use `DensePassageRetriever` to use different embedding models for passage and query (see Tutorial 6) | from haystack.retriever.sparse import ElasticsearchRetriever
retriever = ElasticsearchRetriever(document_store=document_store)
# Alternative: An in-memory TfidfRetriever based on Pandas dataframes for building quick-prototypes with SQLite document store.
# from haystack.retriever.sparse import TfidfRetriever
# retriever = TfidfRetriever(document_store=document_store) | _____no_output_____ | Apache-2.0 | tutorials/Tutorial1_Basic_QA_Pipeline.ipynb | tcapilla/haystack |
ReaderA Reader scans the texts returned by retrievers in detail and extracts the k best answers. They are basedon powerful, but slower deep learning models.Haystack currently supports Readers based on the frameworks FARM and Transformers.With both you can either load a local model or one from Hugging Face's model hub (https://huggingface.co/models).**Here:** a medium sized RoBERTa QA model using a Reader based on FARM (https://huggingface.co/deepset/roberta-base-squad2)**Alternatives (Reader):** TransformersReader (leveraging the `pipeline` of the Transformers package)**Alternatives (Models):** e.g. "distilbert-base-uncased-distilled-squad" (fast) or "deepset/bert-large-uncased-whole-word-masking-squad2" (good accuracy)**Hint:** You can adjust the model to return "no answer possible" with the no_ans_boost. Higher values mean the model prefers "no answer possible" FARMReader | # Load a local model or any of the QA models on
# Hugging Face's model hub (https://huggingface.co/models)
reader = FARMReader(model_name_or_path="deepset/roberta-base-squad2", use_gpu=True) | _____no_output_____ | Apache-2.0 | tutorials/Tutorial1_Basic_QA_Pipeline.ipynb | tcapilla/haystack |
TransformersReader | # Alternative:
# reader = TransformersReader(model_name_or_path="distilbert-base-uncased-distilled-squad", tokenizer="distilbert-base-uncased", use_gpu=-1) | _____no_output_____ | Apache-2.0 | tutorials/Tutorial1_Basic_QA_Pipeline.ipynb | tcapilla/haystack |
PipelineWith a Haystack `Pipeline` you can stick together your building blocks to a search pipeline.Under the hood, `Pipelines` are Directed Acyclic Graphs (DAGs) that you can easily customize for your own use cases.To speed things up, Haystack also comes with a few predefined Pipelines. One of them is the `ExtractiveQAPipeline` that combines a retriever and a reader to answer our questions.You can learn more about `Pipelines` in the [docs](https://haystack.deepset.ai/docs/latest/pipelinesmd). | from haystack.pipeline import ExtractiveQAPipeline
pipe = ExtractiveQAPipeline(reader, retriever) | _____no_output_____ | Apache-2.0 | tutorials/Tutorial1_Basic_QA_Pipeline.ipynb | tcapilla/haystack |
Voilà! Ask a question! | # You can configure how many candidates the reader and retriever shall return
# The higher top_k_retriever, the better (but also the slower) your answers.
prediction = pipe.run(
query="Who is the father of Arya Stark?", params={"Retriever": {"top_k": 10}, "Reader": {"top_k": 5}}
)
# prediction = pipe.run(query="Who created the Dothraki vocabulary?", params={"Reader": {"top_k": 5}})
# prediction = pipe.run(query="Who is the sister of Sansa?", params={"Reader": {"top_k": 5}})
print_answers(prediction, details="minimal") | _____no_output_____ | Apache-2.0 | tutorials/Tutorial1_Basic_QA_Pipeline.ipynb | tcapilla/haystack |
 Dicas e Truques de Ciência de Dados Baby Steps em Ciência de Dados **Python Crash Course**
Strings | data = 'Cientista de Dados'
print(data)
print(len(data))
data[10:] | _____no_output_____ | MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
Números | # Numbers
value = 123
value
type(value)
print(value) | _____no_output_____ | MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
Boleanos | # Boolean
a = True
b = False
print(a,b)
# Multiple Assignment
a, b, c = 1, 2, 3
print(a, b,c)
# No value
a = None
print(a) | None
| MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
Flow Control
If-Then-Else Condition Example | idade = 21
if idade >= 18:
print('maior de idade')
else:
print('menor de idade')
idade = 39
if idade < 12:
print('crianca')
elif idade < 18:
print('adolescente')
elif idade < 39:
print('maduro')
elif idade < 60:
print('adulto')
else:
print('idoso') | adulto
| MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
For-Loop Example | # For-Loop
for i in range(10):
print(i) | _____no_output_____ | MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
While-Loop Example | # While-Loop
e = 5
while e <= 100:
print(e)
e += 10 | _____no_output_____ | MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
Estrutura de Dados Tupla | tupla = (1, 2, 3)
print(tupla)
type(tupla) | _____no_output_____ | MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
Lista
|
mylist = [1, 2, 3]
print("O índice ZERO é o número: %d" % mylist[0])
type(mylist)
mylist[0]
mylist.append(4)
print("List Length: %d" % len(mylist))
for value in mylist:
print(value)
| _____no_output_____ | MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
Dicionário | mydict = {'a': 1, 'b': 2, 'c': 3}
print("O valor da chave 'a' é igual: %d" % mydict['a'])
mydict['a'] = 11
mydict['a'] = 11
print("A value: %d" % mydict['a'])
print("Keys: %s" % mydict.keys())
print("Values: %s" % mydict.values())
for key in mydict.keys():
print(mydict[key]) | 11
2
3
| MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
Functions | # Sum function
def mysum(x, y):
return x + y
def myfun (x,y):
return x+y
print(myfun)
# Test sum function
myfun(1,3)
# Sum function
def myexp(x, y):
return x**y
myexp(3,3) | _____no_output_____ | MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
**NumPy Crash Course**
Create Array (matriz)
matrizes são tensores com 2 dimensões (**tensores de rank 2**). | # define an array
import numpy
mylist = [1, 2, 3]
myarray = numpy.array(mylist)
print(myarray)
print(myarray.shape) | [1 2 3]
(3,)
| MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
Acessando os dados do Array (matriz) | # access values
import numpy
mylist = [[1, 2, 3], [3, 4, 5]]
myarray = numpy.array(mylist)
print(myarray)
print(myarray.shape)
print("Primeira linha: %s" % myarray[0])
print("última linha: %s" % myarray[-1])
print("Qual elemento está na Posição dessa consulta? A Resposta é %s" % myarray[0, 2])
print("Quais elementos estão na coluna dessa consulta? A Resposta é %s" % myarray[:, 2]) | Quais elementos estão na coluna dessa consulta? A Resposta é [3 5]
| MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
Arithmetic | # arithmetic
import numpy
myarray1 = numpy.array([2, 2, 2])
myarray2 = numpy.array([3, 3, 3])
print("Soma: %s" % (myarray1 + myarray2))
print("Multiplicação: %s" % (myarray1 * myarray2)) | Soma: [5 5 5]
Multiplicação: [6 6 6]
| MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
O vetor n-dimensional (tensor)
O NumPy é uma biblioteca para a linguagem Python com funções para se trabalhar com **computação numérica**. Seu **principal objeto é o vetor n-dimensional, ou ndarray**. Um vetor n-dimensional também é conhecido pelo nome **tensor**.
A principal característica do ndarray é que ele deve ser homogêneo, ou seja, diferentemente do objeto lista, todos os seus elementos devem ser do mesmo tipo. | #cria um vetor
import numpy as np
v = np.array([1,2,3,4])
print(v)
print(v.dtype)
v = np.array([1,2,3,4], dtype='float64')
print(v.dtype) | float64
| MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
Os tensores NumPy também possuem um atributo chamado shape. Esse atributo indica a forma do tensor, por exemplo: | print(v.shape) | (4,)
| MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
Neste caso, o tensor v possui 1 dimensão (ou eixo) com 4 elementos. Um tensor unidimensional corresponde a um vetor. Podemos também criar um tensor bidimensional (uma matriz) usando o atributo shape: | # Alterando a dimensão do tensor
v = np.array([1,2,3,4])
v.shape = (2,2)
print(v) | [[1 2]
[3 4]]
| MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
Reshape
Outra forma útil de mudar o shape de um tensor é simplesmente utilizando a função reshape: | v = np.array([1,2,3,4]).reshape(2,2)
print(v)
| [[1 2]
[3 4]]
| MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
**ndim** (eixos ou dimensões do tensor) e **size** (total de elementos/registros)
O número de eixos (ou dimensões) de um tensor é dado pelo atributo ndim, enquanto o número total de elementos é dado por size: | v = np.array(range(9)).reshape(1,3,3)
v
print('Shape = ', v.shape)
print('Número de dimensões = ', v.ndim)
print('Número de elementos = ', v.size)
print('\n\n Veja abaixo o Tensor v \n\n', v)
| Shape = (1, 3, 3)
Número de dimensões = 3
Número de elementos = 9
Veja abaixo o Tensor v
[[[0 1 2]
[3 4 5]
[6 7 8]]]
| MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
**Matplotlib Crash Course**
 Line Plot | # basic line plot
import matplotlib.pyplot as plt
import numpy
myarray = numpy.array([1, 2, 3])
plt.plot(myarray)
plt.xlabel('Data')
plt.ylabel('Faturamento')
plt.show() | _____no_output_____ | MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
Scatter Plot | # basic scatter plot
import matplotlib.pyplot as plt
import numpy
vendas = numpy.array([1, 2, 3, 4, 8, 16 ])
faturamento = numpy.array([2, 4, 6, 8, 10, 12])
plt.scatter(vendas,faturamento)
plt.xlabel('vendas')
plt.ylabel('faturamento')
plt.show()
fig, ax = plt.subplots()
size = 0.3
vals = np.array([[60., 32.], [37., 40.], [29., 10.]])
cmap = plt.get_cmap("tab20c")
outer_colors = cmap(np.arange(3)*4)
inner_colors = cmap([1, 2, 5, 6, 9, 10])
ax.pie(vals.sum(axis=1), radius=1, colors=outer_colors,
wedgeprops=dict(width=size, edgecolor='w'))
ax.pie(vals.flatten(), radius=1-size, colors=inner_colors,
wedgeprops=dict(width=size, edgecolor='w'))
ax.set(aspect="equal", title='Pie plot with `ax.pie`')
plt.show()
import matplotlib.pyplot as plt
from matplotlib.patches import ConnectionPatch
import numpy as np
# make figure and assign axis objects
fig = plt.figure(figsize=(9, 5))
ax1 = fig.add_subplot(121)
ax2 = fig.add_subplot(122)
fig.subplots_adjust(wspace=0)
# pie chart parameters
ratios = [.27, .56, .17]
labels = ['Alta Renda', 'Baixa renda', 'Classe Média']
explode = [0.1, 0, 0]
# rotate so that first wedge is split by the x-axis
angle = -180 * ratios[0]
ax1.pie(ratios, autopct='%1.1f%%', startangle=angle,
labels=labels, explode=explode)
# bar chart parameters
xpos = 0
bottom = 0
ratios = [.33, .54, .07, .06]
width = .2
colors = [[.1, .3, .5], [.1, .3, .3], [.1, .3, .7], [.1, .3, .9]]
for j in range(len(ratios)):
height = ratios[j]
ax2.bar(xpos, height, width, bottom=bottom, color=colors[j])
ypos = bottom + ax2.patches[j].get_height() / 2
bottom += height
ax2.text(xpos, ypos, "%d%%" % (ax2.patches[j].get_height() * 100),
ha='center')
ax2.set_title('Faixa Etária - Alta Renda')
ax2.legend(('50-65', 'acima 65', '35-49', 'abaixo 35'))
ax2.axis('off')
ax2.set_xlim(- 2.5 * width, 2.5 * width)
# use ConnectionPatch to draw lines between the two plots
# get the wedge data
theta1, theta2 = ax1.patches[0].theta1, ax1.patches[0].theta2
center, r = ax1.patches[0].center, ax1.patches[0].r
bar_height = sum([item.get_height() for item in ax2.patches])
# draw top connecting line
x = r * np.cos(np.pi / 180 * theta2) + center[0]
y = r * np.sin(np.pi / 180 * theta2) + center[1]
con = ConnectionPatch(xyA=(-width / 2, bar_height), coordsA=ax2.transData,
xyB=(x, y), coordsB=ax1.transData)
con.set_color([0, 0, 0])
con.set_linewidth(4)
ax2.add_artist(con)
# draw bottom connecting line
x = r * np.cos(np.pi / 180 * theta1) + center[0]
y = r * np.sin(np.pi / 180 * theta1) + center[1]
con = ConnectionPatch(xyA=(-width / 2, 0), coordsA=ax2.transData,
xyB=(x, y), coordsB=ax1.transData)
con.set_color([0, 0, 0])
ax2.add_artist(con)
con.set_linewidth(4)
plt.show()
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('fivethirtyeight')
x = np.linspace(0, 10)
# Fixing random state for reproducibility
np.random.seed(7)
fig, ax = plt.subplots()
ax.plot(x, np.sin(x) + x + np.random.randn(50))
ax.plot(x, np.sin(x) + 0.5 * x + np.random.randn(50))
ax.plot(x, np.sin(x) + 2 * x + np.random.randn(50))
ax.plot(x, np.sin(x) - 0.5 * x + np.random.randn(50))
ax.plot(x, np.sin(x) - 2 * x + np.random.randn(50))
ax.plot(x, np.sin(x) + np.random.randn(50))
ax.set_title("'fivethirtyeight' é o Estilo do Gráfico")
plt.show() | _____no_output_____ | MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
**Eletroencefalograma**
é um exame que avalia a atividade elétrica espontânea do cérebro. Para tanto, o teste, também conhecido pela abreviação EEG, amplifica os impulsos elétricos cerebrais e os registra, a fim de detectar anormalidades neurológicas. | import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cbook as cbook
import matplotlib.cm as cm
from matplotlib.collections import LineCollection
from matplotlib.ticker import MultipleLocator
fig = plt.figure("MRI_with_EEG")
# Load the MRI data (256x256 16 bit integers)
with cbook.get_sample_data('s1045.ima.gz') as dfile:
im = np.frombuffer(dfile.read(), np.uint16).reshape((256, 256))
# Plot the MRI image
ax0 = fig.add_subplot(2, 2, 1)
ax0.imshow(im, cmap=cm.gray)
ax0.axis('off')
# Plot the histogram of MRI intensity
ax1 = fig.add_subplot(2, 2, 2)
im = np.ravel(im)
im = im[np.nonzero(im)] # Ignore the background
im = im / (2**16 - 1) # Normalize
ax1.hist(im, bins=100)
ax1.xaxis.set_major_locator(MultipleLocator(0.4))
ax1.minorticks_on()
ax1.set_yticks([])
ax1.set_xlabel('Intensity (a.u.)')
ax1.set_ylabel('MRI density')
# Load the EEG data
n_samples, n_rows = 800, 4
with cbook.get_sample_data('eeg.dat') as eegfile:
data = np.fromfile(eegfile, dtype=float).reshape((n_samples, n_rows))
t = 10 * np.arange(n_samples) / n_samples
# Plot the EEG
ticklocs = []
ax2 = fig.add_subplot(2, 1, 2)
ax2.set_xlim(0, 10)
ax2.set_xticks(np.arange(10))
dmin = data.min()
dmax = data.max()
dr = (dmax - dmin) * 0.7 # Crowd them a bit.
y0 = dmin
y1 = (n_rows - 1) * dr + dmax
ax2.set_ylim(y0, y1)
segs = []
for i in range(n_rows):
segs.append(np.column_stack((t, data[:, i])))
ticklocs.append(i * dr)
offsets = np.zeros((n_rows, 2), dtype=float)
offsets[:, 1] = ticklocs
lines = LineCollection(segs, offsets=offsets, transOffset=None)
ax2.add_collection(lines)
# Set the yticks to use axes coordinates on the y axis
ax2.set_yticks(ticklocs)
ax2.set_yticklabels(['PG3', 'PG5', 'PG7', 'PG9'])
ax2.set_xlabel('Time (s)')
plt.tight_layout()
plt.show()
from mpl_toolkits.mplot3d import axes3d
import matplotlib.pyplot as plt
from matplotlib import cm
fig = plt.figure()
ax = fig.gca(projection='3d')
X, Y, Z = axes3d.get_test_data(0.05)
# Plot the 3D surface
ax.plot_surface(X, Y, Z, rstride=8, cstride=8, alpha=0.3)
# Plot projections of the contours for each dimension. By choosing offsets
# that match the appropriate axes limits, the projected contours will sit on
# the 'walls' of the graph
cset = ax.contourf(X, Y, Z, zdir='z', offset=-100, cmap=cm.coolwarm)
cset = ax.contourf(X, Y, Z, zdir='x', offset=-40, cmap=cm.coolwarm)
cset = ax.contourf(X, Y, Z, zdir='y', offset=40, cmap=cm.coolwarm)
ax.set_xlim(-40, 40)
ax.set_ylim(-40, 40)
ax.set_zlim(-100, 100)
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
plt.show() | _____no_output_____ | MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
**Pandas Crash Course**
 **Series**: Uma série é um array unidimensional onde as linhas e colunas podem ser rotuladas. | # series
import numpy as np
import pandas as pd
myarray = np.array([1, 2, 3])
rownames = ['Kiwi', 'Marlos', 'Bruno']
myseries = pd.Series(myarray, index=rownames)
print(myseries)
print(myseries['Marlos'])
| _____no_output_____ | MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
**Dataframe** | # dataframe
import numpy as np
import pandas as pd
myarray = np.array([[10, 9, 7], [5, 5, 8], [1,1,1]])
rownames = ['Marlos', 'Kiwi','Oliveira']
colnames = ['Geografia', 'Matemática', 'Biologia']
mydataframe = pd.DataFrame(myarray, index=rownames, columns=colnames)
print(mydataframe)
#Quantidade de linhas
mydataframe.value_counts().sum()
mydataframe.Biologia.mean()
mydataframe.Biologia.median()
df = pd.read_csv('/content/bank-full.csv',delimiter=';' )
df
df.head()
df.describe()
df.balance.sum()
df.y.value_counts()
| _____no_output_____ | MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
**Resumão**
 Você acaba de colocar o pé nesse MAR que é o **Python**.
Você descobriu a sintaxe básica e o uso do Python e 3 bibliotecas Python principais usadas para inicira os trabalhos de aprendizado de máquina:
* **NumPy**
* **Matplotlib**
* **Pandas**
Agora você conhece sintaxe e informações de uso suficientes para ler e entender o código Python para aprendizado de máquina e para começar a criar seus próprios scripts.
Simbóra!
Fim Valeu! Links - Ciência dos Dados https://linktr.ee/cienciadosdados YouTube - Mais Aulas como essa no YouTube https://www.youtube.com/watch?v=IaIc5oHd3II&t=1569s | from IPython.core.display import HTML
HTML('<iframe width="380" height="200" src="https://www.youtube.com/embed/W9iktBS67Iw" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>') | _____no_output_____ | MIT | Crash_Course_Python_Parte_2.ipynb | Adrianacms/Hello-Word |
Ensemble Learning Initial Imports | import warnings
warnings.filterwarnings('ignore')
import numpy as np
import pandas as pd
from pathlib import Path
from collections import Counter
from sklearn.metrics import balanced_accuracy_score
from sklearn.metrics import confusion_matrix
from imblearn.metrics import classification_report_imbalanced | _____no_output_____ | ADSL | Starter_Code/credit_risk_ensemble.ipynb | willhua531/HW-Classification |
Read the CSV and Perform Basic Data Cleaning | # Load the data
file_path = Path('Resources/LoanStats_2019Q1.csv')
df = pd.read_csv(file_path)
# Preview the data
df.head() | _____no_output_____ | ADSL | Starter_Code/credit_risk_ensemble.ipynb | willhua531/HW-Classification |
Split the Data into Training and Testing | # Create our features
df_encoded = pd.get_dummies(df, columns = ['home_ownership', 'verification_status', 'issue_d',
'pymnt_plan', 'hardship_flag', 'debt_settlement_flag',
'initial_list_status', 'next_pymnt_d', 'application_type'])
df_encoded
X = df_encoded.drop(columns = 'loan_status')
# Create our target
y = df_encoded['loan_status']
X.describe()
# Check the balance of our target values
# YOUR CODE HERE
y.value_counts()
# Split the X and y into X_train, X_test, y_train, y_test
# YOUR CODE HERE
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state =1, stratify =y)
Counter(y_train) | _____no_output_____ | ADSL | Starter_Code/credit_risk_ensemble.ipynb | willhua531/HW-Classification |
Data Pre-ProcessingScale the training and testing data using the `StandardScaler` from `sklearn`. Remember that when scaling the data, you only scale the features data (`X_train` and `X_testing`). | # Create the StandardScaler instance
from sklearn.preprocessing import StandardScaler
# YOUR CODE HERE
scaler = StandardScaler()
# Fit the Standard Scaler with the training data
# When fitting scaling functions, only train on the training dataset
# YOUR CODE HERE
X_scaler = scaler.fit(X_train)
# Scale the training and testing data
# YOUR CODE HERE
X_train_scaled = X_scaler.transform(X_train)
X_test_scaled = X_scaler.transform(X_test) | _____no_output_____ | ADSL | Starter_Code/credit_risk_ensemble.ipynb | willhua531/HW-Classification |
Ensemble LearnersIn this section, you will compare two ensemble algorithms to determine which algorithm results in the best performance. You will train a Balanced Random Forest Classifier and an Easy Ensemble classifier . For each algorithm, be sure to complete the folliowing steps:1. Train the model using the training data. 2. Calculate the balanced accuracy score from sklearn.metrics.3. Display the confusion matrix from sklearn.metrics.4. Generate a classication report using the `imbalanced_classification_report` from imbalanced-learn.5. For the Balanced Random Forest Classifier only, print the feature importance sorted in descending order (most important feature to least important) along with the feature scoreNote: Use a random state of 1 for each algorithm to ensure consistency between tests Balanced Random Forest Classifier | # Resample the training data with the BalancedRandomForestClassifier
# YOUR CODE HERE
from imblearn.ensemble import BalancedRandomForestClassifier
brf = BalancedRandomForestClassifier(n_estimators=100, random_state=1)
brf.fit(X_train, y_train)
# Calculated the balanced accuracy score
# YOUR CODE HERE
y_pred = brf.predict(X_test)
balanced_accuracy_score(y_test, y_pred)
# Display the confusion matrix
# YOUR CODE HERE
confusion_matrix(y_test, y_pred)
# Print the imbalanced classification report
# YOUR CODE HERE
from imblearn.metrics import classification_report_imbalanced
print(classification_report_imbalanced(y_test, y_pred))
# List the features sorted in descending order by feature importance
# YOUR CODE HERE
importances = brf.feature_importances_
sorted(zip(importances, X.columns), reverse = True)
| _____no_output_____ | ADSL | Starter_Code/credit_risk_ensemble.ipynb | willhua531/HW-Classification |
Easy Ensemble Classifier | # Train the Classifier
# YOUR CODE HERE
from imblearn.ensemble import EasyEnsembleClassifier
eec = EasyEnsembleClassifier(random_state = 0)
eec.fit(X_train, y_train)
# Calculated the balanced accuracy score
# YOUR CODE HERE
y_pred_eec = eec.predict(X_test)
balanced_accuracy_score(y_test, y_pred_eec)
# Display the confusion matrix
# YOUR CODE HERE
confusion_matrix(y_test, y_pred_eec)
# Print the imbalanced classification report
# YOUR CODE HERE
print(classification_report_imbalanced(y_test, y_pred_eec)) | pre rec spe f1 geo iba sup
high_risk 0.06 0.91 0.93 0.12 0.92 0.84 87
low_risk 1.00 0.93 0.91 0.96 0.92 0.85 17118
avg / total 0.99 0.93 0.91 0.96 0.92 0.85 17205
| ADSL | Starter_Code/credit_risk_ensemble.ipynb | willhua531/HW-Classification |
In this post, I define a class to model the behavior of ahydrogen atom. In the process, I get to solve integrals like the following numerically to test my code:$$ \int_0^{\pi} \int_0^{2\pi} \lvert Y_{l, m_l} \rvert ^2 \sin \theta d \theta d \phi = 1 $$This post consists of a arge block of Python code up front, and then explanations and plots below. Let's get started! Define a class for the hydrogenic atomThis Python class has wavefunctions and energies. It is based on Chapter 10 of *Physical Chemistry, 8th Ed* by Atkins and De Paula. The goal of the Python class is to reproduce some of the plots and reproduce results with numeric integration found in Chapter 10. | import numpy as np
import matplotlib.pyplot as plt
from matplotlib import cm
from math import exp, sqrt, pi, cos, sin
from scipy.integrate import dblquad, tplquad, quad
import cmath
class HydrogenicAtom:
"""
This class models the wavefunctions and energy levels of a hydrogenic atom.
It assumes an infinitely heavy nucleus, so the mass is that of the
electron.
Masses are in kg, distances are in m
This whole class uses complex numbers and math functions.
"""
def __init__(self, n=1, l=0, ml=0, z=1):
"""
This sets some instance attributes and a few constant used throughout the
class.
Leave z at 1 for hydrogen.
Parameters
----------
n: int
Principal quantum number.
l: int
Orbital angular momentum quantum number.
ml: int
Magnetic quantum number.
z: int
Number of protons in the nucleus. Defaults to 1.
"""
self.a0 = 5.29e-11 # m
self.me = 9.10938356e-31 # kg
self.e0 = 8.85418782e-12 # Permitivity of free space
self.e_charge = 1.60217662e-19 # Coulombs, charge of electron
self.hbar = 1.054571817e-34 # Reduced Planck's constant
self.n = n
self.l = l
self.ml = ml
self.z = z
def rho(self, r):
"""
Calculates the rho part of the radial function. It assumes an infinitely
heavy nucleus.
From Atkins and de Paula, Table 10.1, page 324
Parameters
----------
r: float
The distance, in meters being calculated
Returns
-------
float
The value of rho.
"""
return (2 * self.z / self.n / self.a0) * r
def radial(self, r):
"""
The radial part of the wavefunction
Parameters
----------
r: float
Radius, in meters
Returns
-------
complex
The value of the radial wavefunction, which only uses the real
part of the complex value.
Raises
------
Exception
Raises an exception for invalid n and l
"""
za32 = (self.z / self.a0) ** (3/2)
rho = self.rho(r)
exp_rho = exp(-rho / 2.0)
if self.n == 1 and self.l == 0: # 1s orbital
return 2 * za32 * exp_rho
elif self.n == 2 and self.l == 0: # 2s orbital
return (1.0 / sqrt(8)) * za32 * (2.0 - rho) * exp_rho
elif self.n == 2 and self.l == 1: # 2p orbital
return (1.0 / sqrt(24)) * za32 * rho * exp_rho
elif self.n == 3 and self.l == 0:
return (1.0 / sqrt(243)) * za32 * (6.0 - 6 * rho + rho ** 2) * exp_rho
elif self.n == 3 and self.l == 1:
return (1.0 / sqrt(486)) * za32 * (4.0 - rho) * rho * exp_rho
elif self.n == 3 and self.l == 2:
return (1.0 / sqrt(2430)) * za32 * rho ** 2 * exp_rho
else:
raise Exception(f'No radial function for {self.n} and {self.l}')
def spherical_harmonic(self, theta, phi):
"""
Find the value of the spherical harmonic given an quantum numbers
l, ml and coordinates theta, phi.
From Atkins and de Paula, Table 9.3, page 302
Parameters
----------
theta: float
Theta coordinate, from 0 to pi
phi: float
Phi coordinate, from 0 to 2*pi
Returns
-------
complex
The value of the spherical harmonic, which is a complex value
Raises
------
Exception
Raises an Exception for an invalid combination of l and ml
"""
if self.l == 0 and self.ml == 0:
return sqrt(1 / 4.0 / pi)
elif self.l == 1 and self.ml == 0:
return sqrt(3.0 / 4.0 / pi) * cos(theta)
elif self.l == 1 and self.ml == 1:
return -sqrt(3.0 / 8.0 / pi) * sin(theta) * cmath.exp(1j * phi)
elif self.l == 1 and self.ml == -1:
return -sqrt(3.0 / 8.0 / pi) * sin(theta) * cmath.exp(-1j * phi)
elif self.l == 2 and self.ml == 0:
return sqrt(5.0 / 16.0 / pi) * (3 * cos(theta)** 2 - 1)
elif self.l == 2 and self.ml == 1:
return -sqrt(15.0 / 8.0 / pi) * cos(theta) * sin(theta) * cmath.exp(1j * phi)
elif self.l == 2 and self.ml == -1:
return sqrt(15.0 / 8.0 / pi) * cos(theta) * sin(theta) * cmath.exp(-1j * phi)
elif self.l == 2 and self.ml == 2:
return sqrt(15.0 / 32.0 / pi) * sin(theta) ** 2 * cmath.exp(2j * phi)
elif self.l == 2 and self.ml == -2:
return sqrt(15.0 / 32.0 / pi) * sin(theta) ** 2 * cmath.exp(-2j * phi)
elif self.l == 3 and self.ml == 0:
return sqrt(7.0 / 16.0 / pi) * (5 * cos(theta) ** 3 - 3 * cos(theta))
elif self.l == 3 and self.ml == 1:
return -sqrt(21.0 / 64.0 / pi) * (5 * cos(theta) ** 2 - 1) * sin(theta) * cmath.exp(1j * phi)
elif self.l == 3 and self.ml == -1:
return sqrt(21.0 / 64.0 / pi) * (5 * cos(theta) ** 2 - 1) * sin(theta) * cmath.exp(-1j * phi)
elif self.l == 3 and self.ml == 2:
return sqrt(105.0 / 32.0 / pi) * sin(theta) ** 2 * cos(theta) * cmath.exp(2j * phi)
elif self.l == 3 and self.ml == -2:
return sqrt(105.0 / 32.0 / pi) * sin(theta) ** 2 * cos(theta) * cmath.exp(-2j * phi)
elif self.l == 3 and self.ml == 3:
return -sqrt(35.0 / 64.0 / pi) * sin(theta) ** 3 * cmath.exp(3j * phi)
elif self.l == 3 and self.ml == -3:
return sqrt(35.0 / 64.0 / pi) * sin(theta) ** 3 * cmath.exp(-3j * phi)
else:
raise Exception(f'No equation for l={self.l} and ml={self.ml}')
def wavefunction(self, r, theta, phi):
"""
Returns the value of the wavefunction at the given location.
Parameters
----------
r: float
The r value, from 0 to infinity
theta: float
The theta value, from 0 to pi
phi: float
The phi value, from 0 to 2*pi
Returns
-------
complex
The complex value of the wavefunction.
"""
return self.radial(r) * self.spherical_harmonic(theta, phi)
def energy(self):
"""
This calcuates the energy in Joules of the electron at the n level of this
atoms configuration.
It makes the infinite mas approximation for the nucleus, so the mass in
the expression is that of the electron.
From page 324 of Atkins and de Paula
Returns
-------
float, float
First float is energy level in joules, second float is energy level in eV
"""
ev_per_joule = 6.242e+18
numerator = self.z**2 * self.me * self.e_charge**4
denominator = 32 * pi**2 * self.e0**2 * self.hbar**2 * self.n**2
value = numerator / denominator
joules = -value
ev = joules * ev_per_joule
return joules, ev
def mean_orbital_radius(self):
"""
Returns the mean orbital radius of the given state of this atom.
It does this by integration.
Returns
-------
float
The mean orbital radius
"""
second_point_guess = 10 * self.n * self.a0
def integrand(r):
return r**3 * self.radial(r)**2
radius, _ = quad(integrand, 0, 1, points=[0, second_point_guess])
return radius | _____no_output_____ | BSD-2-Clause | notebooks/hydrogenic_atom.ipynb | akey7/basic-quantum-models |
Check the spherical harmonicsMake sure all the spherical harmonics are normalized. That means each of the the spherical harmonic functions must stasify the following expression:$$ \int_0^{\pi} \int_0^{2\pi} \lvert Y_{l, m_l} \rvert ^2 \sin \theta d \theta d \phi = 1 $$The next block of code takes the spherical harmonic for each parameter set of l and ml and numerically integrates it to ensure that the result is 1.0, within floating point precision. A report of the parameters and the results follows, and they all integrate to approximately 1.0! Success! | parameters = [
{ 'n': 3, 'l': 0, 'ml': 0 },
{ 'n': 3, 'l': 1, 'ml': 0 },
{ 'n': 3, 'l': 1, 'ml': 1 },
{ 'n': 3, 'l': 1, 'ml': -1 },
{ 'n': 3, 'l': 2, 'ml': 0 },
{ 'n': 3, 'l': 2, 'ml': 1 },
{ 'n': 3, 'l': 2, 'ml': -1 },
{ 'n': 3, 'l': 2, 'ml': 2 },
{ 'n': 3, 'l': 2, 'ml': -2 },
{ 'n': 3, 'l': 3, 'ml': 0 },
{ 'n': 3, 'l': 3, 'ml': 1 },
{ 'n': 3, 'l': 3, 'ml': -1 },
{ 'n': 3, 'l': 3, 'ml': 2 },
{ 'n': 3, 'l': 3, 'ml': -2 },
{ 'n': 3, 'l': 3, 'ml': 3 },
{ 'n': 3, 'l': 3, 'ml': -3 }
]
for p in parameters:
ha = HydrogenicAtom(n=p['n'], l=p['l'], ml=p['ml'])
def integrand(phi,theta):
value = ha.spherical_harmonic(theta, phi)
return abs(value) ** 2 * sin(theta).real
p['result'], _ = dblquad(integrand, 0, pi, 0, 2 * pi)
for p in parameters:
print(p) | {'n': 3, 'l': 0, 'ml': 0, 'result': 0.9999999999999999}
{'n': 3, 'l': 1, 'ml': 0, 'result': 1.0}
{'n': 3, 'l': 1, 'ml': 1, 'result': 0.9999999999999999}
{'n': 3, 'l': 1, 'ml': -1, 'result': 0.9999999999999999}
{'n': 3, 'l': 2, 'ml': 0, 'result': 1.0000000000000002}
{'n': 3, 'l': 2, 'ml': 1, 'result': 1.0}
{'n': 3, 'l': 2, 'ml': -1, 'result': 1.0}
{'n': 3, 'l': 2, 'ml': 2, 'result': 1.0}
{'n': 3, 'l': 2, 'ml': -2, 'result': 1.0}
{'n': 3, 'l': 3, 'ml': 0, 'result': 1.0}
{'n': 3, 'l': 3, 'ml': 1, 'result': 1.0000000000000002}
{'n': 3, 'l': 3, 'ml': -1, 'result': 1.0000000000000002}
{'n': 3, 'l': 3, 'ml': 2, 'result': 0.9999999999999998}
{'n': 3, 'l': 3, 'ml': -2, 'result': 0.9999999999999998}
{'n': 3, 'l': 3, 'ml': 3, 'result': 1.0000000000000004}
{'n': 3, 'l': 3, 'ml': -3, 'result': 1.0000000000000004}
| BSD-2-Clause | notebooks/hydrogenic_atom.ipynb | akey7/basic-quantum-models |
Plots of the radial functionsFigure 1 has plots of the radial functions for various combinations of n and l. Some of the subplots are blank because there is no corresponding radial function for their position on the chart. | fig, axs = plt.subplots(nrows=3, ncols=3, figsize=(12, 15))
# Just so I can access instance variables in an instance to make the dictionary.
ha = HydrogenicAtom()
yscaler = (ha.z / ha.a0)**(3/2)
parameters = [
{'n': 1, 'l': 0, 'x_scaler': 5, 'yscaler': yscaler },
{'n': 2, 'l': 0, 'x_scaler': 15, 'yscaler': yscaler },
{'n': 3, 'l': 0, 'x_scaler': 20, 'yscaler': yscaler },
{'n': 2, 'l': 1, 'x_scaler': 15, 'yscaler': yscaler },
{'n': 3, 'l': 1, 'x_scaler': 30, 'yscaler': yscaler },
{'n': 3, 'l': 2, 'x_scaler': 30, 'yscaler': yscaler }
]
for p in parameters:
row = p['n'] - 1
col = p['l']
ha = HydrogenicAtom(n=p['n'], l=p['l'])
xs = np.linspace(0, ha.a0 * p['x_scaler'], 100)
xs_labels = xs / ha.a0 # so that the x axis is labeled in units of a0
ys = [ha.radial(r) / p['yscaler'] for r in xs]
ax = axs[row, col]
ax.set_title(f'n={p["n"]}, l={p["l"]}', color='b')
ax.set_xlim(min(xs_labels), max(xs_labels))
if col == 0:
ax.set_ylabel('r/((Z/a0)**(3/2))', color='b')
ax.set_xlabel('r/a0')
ax.axhline(0.0, color='r')
ax.plot(xs_labels, ys)
axs[0, 1].set_title('intentionally blank')
axs[0, 2].set_title('intentionally blank')
axs[1, 2].set_title('intentionally blank') | _____no_output_____ | BSD-2-Clause | notebooks/hydrogenic_atom.ipynb | akey7/basic-quantum-models |
Hydrogen energy levelsNote how the levels pack closer together at higher energy levels. The lowest energy, -13.6 eV, is the ground state of the hydrogen atom. All the energies are negative, which means they refer to bound states where the nucleus holds the electron. | ys = []
for n in range(1, 10):
ha = HydrogenicAtom(n=n)
_, ev = ha.energy()
ys.append((n, round(ev, 2)))
fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(2, 10))
ax.set_ylim(-14.0, 0.0)
ax.set_xticks([])
ax.set_ylabel('eV', size=20, color='b')
ax.set_title('Hydrogen Energy Levels, n=1 to n=9', size=20, color='b')
for y in ys:
ax.axhline(y[1], color='r') | _____no_output_____ | BSD-2-Clause | notebooks/hydrogenic_atom.ipynb | akey7/basic-quantum-models |
By numeric integration, what is the mean radius of 1s orbital?In this section, I follow the integral given in Example 10.2 that will find the mean radius of an orbital: $$ \langle r \rangle = \int_0^{\infty} r^3 R_{n,l}^2 dr $$I integrate it numerically with the `quad` function from `scipy.integrate`. The `points` argument to `quad` tells the function the r values that the value ies within. To help the `quad` numeri integration function out, I took a guess that the mean radius is going to be within \\(10 \times a_0 \times n\\) radii of the nucleus. Also, I took 1 meter as the "infinity" for integration in this case. | ha = HydrogenicAtom(n=1, l=0, ml=0)
def integrand(r):
return r**3 * ha.radial(r)**2
quad(integrand, 0, 1, points=[0, 10 * ha.a0 * ha.n]) | _____no_output_____ | BSD-2-Clause | notebooks/hydrogenic_atom.ipynb | akey7/basic-quantum-models |
The first element of the tuple above is the result of the integration, and the second element is the estimated error of the integration. Below is the solution to the analytical integration solution given by the book. It matches the numeric integration! | 3 * ha.a0 / 2 | _____no_output_____ | BSD-2-Clause | notebooks/hydrogenic_atom.ipynb | akey7/basic-quantum-models |
What about the 3s orbital? First numeric integration, then the numeric solution from the book. | ha = HydrogenicAtom(n=3, l=0, ml=0)
def integrand(r):
return r**3 * ha.radial(r)**2
quad(integrand, 0, 1, points=[0, 10 * ha.a0 * ha.n])
27 * ha.a0 / 2 | _____no_output_____ | BSD-2-Clause | notebooks/hydrogenic_atom.ipynb | akey7/basic-quantum-models |
What about the 3p orbital? | ha = HydrogenicAtom(n=3, l=1, ml=0)
def integrand(r):
return r**3 * ha.radial(r)**2
quad(integrand, 0, 1, points=[0, 10 * ha.a0 * ha.n])
25 * ha.a0 / 2 | _____no_output_____ | BSD-2-Clause | notebooks/hydrogenic_atom.ipynb | akey7/basic-quantum-models |
Overall, the numerical integration and the guess about where the interesting parts of the integration are worked out fairly well for these examples. What is the mean radius of each orbital?Make some plots of the mean radius of each orbital. Red circles are s orbitals, green squares are p orbitals, blue diamonds are d orbitals. Note that the radii of d < p < s for each level n. | parameters = [
{'n': 1, 'l': 0 },
{'n': 2, 'l': 0 },
{'n': 2, 'l': 1 },
{'n': 3, 'l': 0 },
{'n': 3, 'l': 1 },
{'n': 3, 'l': 2 }
]
for p in parameters:
ha = HydrogenicAtom(n=p['n'], l=p['l'])
p['mean_radius_a0'] = ha.mean_orbital_radius() / ha.a0
fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(5, 5))
for p in parameters:
x = p['n']
y = p['mean_radius_a0']
if p['l'] == 0:
color = 'r'
marker = 'o'
label = 's'
elif p['l'] == 1:
color = 'g'
marker = 's'
label = 'p'
else:
color = 'b'
marker = 'd'
label = 'd'
ax.scatter(x, y, marker=marker, color=color, s=200)
ax.set_xticks([1, 2, 3])
ax.set_xlabel('n')
ax.set_ylabel('r / a0')
ax.set_title('Relative mean orbital radii') | _____no_output_____ | BSD-2-Clause | notebooks/hydrogenic_atom.ipynb | akey7/basic-quantum-models |
ReferenceThis example is taken from the book [DL with Python](https://www.manning.com/books/deep-learning-with-python) by F. Chollet. It explains how to retrain a pre-trained CNN classifierAll the notebooks from the book are available for free on [Github](https://github.com/fchollet/deep-learning-with-python-notebooks)If you like to run the example locally follow the instructions provided on [Keras website](https://keras.io/installation)--- | import keras
keras.__version__ | Using TensorFlow backend.
| MIT | samples/notebooks/week04-03-using-a-pretrained-convnet.ipynb | gu-ma/ba_218_comppx_h1901 |
Using a pre-trained convnetThis notebook contains the code sample found in Chapter 5, Section 3 of [Deep Learning with Python](https://www.manning.com/books/deep-learning-with-python?a_aid=keras&a_bid=76564dff). Note that the original text features far more content, in particular further explanations and figures: in this notebook, you will only find source code and related comments.----A common and highly effective approach to deep learning on small image datasets is to leverage a pre-trained network. A pre-trained network is simply a saved network previously trained on a large dataset, typically on a large-scale image classification task. If this original dataset is large enough and general enough, then the spatial feature hierarchy learned by the pre-trained network can effectively act as a generic model of our visual world, and hence its features can prove useful for many different computer vision problems, even though these new problems might involve completely different classes from those of the original task. For instance, one might train a network on ImageNet (where classes are mostly animals and everyday objects) and then re-purpose this trained network for something as remote as identifying furniture items in images. Such portability of learned features across different problems is a key advantage of deep learning compared to many older shallow learning approaches, and it makes deep learning very effective for small-data problems.In our case, we will consider a large convnet trained on the ImageNet dataset (1.4 million labeled images and 1000 different classes). ImageNet contains many animal classes, including different species of cats and dogs, and we can thus expect to perform very well on our cat vs. dog classification problem.We will use the VGG16 architecture, developed by Karen Simonyan and Andrew Zisserman in 2014, a simple and widely used convnet architecture for ImageNet. Although it is a bit of an older model, far from the current state of the art and somewhat heavier than many other recent models, we chose it because its architecture is similar to what you are already familiar with, and easy to understand without introducing any new concepts. This may be your first encounter with one of these cutesie model names -- VGG, ResNet, Inception, Inception-ResNet, Xception... you will get used to them, as they will come up frequently if you keep doing deep learning for computer vision.There are two ways to leverage a pre-trained network: *feature extraction* and *fine-tuning*. We will cover both of them. Let's start with feature extraction. Feature extractionFeature extraction consists of using the representations learned by a previous network to extract interesting features from new samples. These features are then run through a new classifier, which is trained from scratch.As we saw previously, convnets used for image classification comprise two parts: they start with a series of pooling and convolution layers, and they end with a densely-connected classifier. The first part is called the "convolutional base" of the model. In the case of convnets, "feature extraction" will simply consist of taking the convolutional base of a previously-trained network, running the new data through it, and training a new classifier on top of the output.Why only reuse the convolutional base? Could we reuse the densely-connected classifier as well? In general, it should be avoided. The reason is simply that the representations learned by the convolutional base are likely to be more generic and therefore more reusable: the feature maps of a convnet are presence maps of generic concepts over a picture, which is likely to be useful regardless of the computer vision problem at hand. On the other end, the representations learned by the classifier will necessarily be very specific to the set of classes that the model was trained on -- they will only contain information about the presence probability of this or that class in the entire picture. Additionally, representations found in densely-connected layers no longer contain any information about _where_ objects are located in the input image: these layers get rid of the notion of space, whereas the object location is still described by convolutional feature maps. For problems where object location matters, densely-connected features would be largely useless.Note that the level of generality (and therefore reusability) of the representations extracted by specific convolution layers depends on the depth of the layer in the model. Layers that come earlier in the model extract local, highly generic feature maps (such as visual edges, colors, and textures), while layers higher-up extract more abstract concepts (such as "cat ear" or "dog eye"). So if your new dataset differs a lot from the dataset that the original model was trained on, you may be better off using only the first few layers of the model to do feature extraction, rather than using the entire convolutional base.In our case, since the ImageNet class set did contain multiple dog and cat classes, it is likely that it would be beneficial to reuse the information contained in the densely-connected layers of the original model. However, we will chose not to, in order to cover the more general case where the class set of the new problem does not overlap with the class set of the original model. Let's put this in practice by using the convolutional base of the VGG16 network, trained on ImageNet, to extract interesting features from our cat and dog images, and then training a cat vs. dog classifier on top of these features.The VGG16 model, among others, comes pre-packaged with Keras. You can import it from the `keras.applications` module. Here's the list of image classification models (all pre-trained on the ImageNet dataset) that are available as part of `keras.applications`:* Xception* InceptionV3* ResNet50* VGG16* VGG19* MobileNetLet's instantiate the VGG16 model: | from keras.applications import VGG16
conv_base = VGG16(weights='imagenet',
include_top=False,
input_shape=(150, 150, 3)) | _____no_output_____ | MIT | samples/notebooks/week04-03-using-a-pretrained-convnet.ipynb | gu-ma/ba_218_comppx_h1901 |
We passed three arguments to the constructor:* `weights`, to specify which weight checkpoint to initialize the model from* `include_top`, which refers to including or not the densely-connected classifier on top of the network. By default, this densely-connected classifier would correspond to the 1000 classes from ImageNet. Since we intend to use our own densely-connected classifier (with only two classes, cat and dog), we don't need to include it.* `input_shape`, the shape of the image tensors that we will feed to the network. This argument is purely optional: if we don't pass it, then the network will be able to process inputs of any size.Here's the detail of the architecture of the VGG16 convolutional base: it's very similar to the simple convnets that you are already familiar with. | conv_base.summary() | _________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
input_1 (InputLayer) (None, 150, 150, 3) 0
_________________________________________________________________
block1_conv1 (Conv2D) (None, 150, 150, 64) 1792
_________________________________________________________________
block1_conv2 (Conv2D) (None, 150, 150, 64) 36928
_________________________________________________________________
block1_pool (MaxPooling2D) (None, 75, 75, 64) 0
_________________________________________________________________
block2_conv1 (Conv2D) (None, 75, 75, 128) 73856
_________________________________________________________________
block2_conv2 (Conv2D) (None, 75, 75, 128) 147584
_________________________________________________________________
block2_pool (MaxPooling2D) (None, 37, 37, 128) 0
_________________________________________________________________
block3_conv1 (Conv2D) (None, 37, 37, 256) 295168
_________________________________________________________________
block3_conv2 (Conv2D) (None, 37, 37, 256) 590080
_________________________________________________________________
block3_conv3 (Conv2D) (None, 37, 37, 256) 590080
_________________________________________________________________
block3_pool (MaxPooling2D) (None, 18, 18, 256) 0
_________________________________________________________________
block4_conv1 (Conv2D) (None, 18, 18, 512) 1180160
_________________________________________________________________
block4_conv2 (Conv2D) (None, 18, 18, 512) 2359808
_________________________________________________________________
block4_conv3 (Conv2D) (None, 18, 18, 512) 2359808
_________________________________________________________________
block4_pool (MaxPooling2D) (None, 9, 9, 512) 0
_________________________________________________________________
block5_conv1 (Conv2D) (None, 9, 9, 512) 2359808
_________________________________________________________________
block5_conv2 (Conv2D) (None, 9, 9, 512) 2359808
_________________________________________________________________
block5_conv3 (Conv2D) (None, 9, 9, 512) 2359808
_________________________________________________________________
block5_pool (MaxPooling2D) (None, 4, 4, 512) 0
=================================================================
Total params: 14,714,688
Trainable params: 14,714,688
Non-trainable params: 0
_________________________________________________________________
| MIT | samples/notebooks/week04-03-using-a-pretrained-convnet.ipynb | gu-ma/ba_218_comppx_h1901 |
The final feature map has shape `(4, 4, 512)`. That's the feature on top of which we will stick a densely-connected classifier.At this point, there are two ways we could proceed: * Running the convolutional base over our dataset, recording its output to a Numpy array on disk, then using this data as input to a standalone densely-connected classifier similar to those you have seen in the first chapters of this book. This solution is very fast and cheap to run, because it only requires running the convolutional base once for every input image, and the convolutional base is by far the most expensive part of the pipeline. However, for the exact same reason, this technique would not allow us to leverage data augmentation at all.* Extending the model we have (`conv_base`) by adding `Dense` layers on top, and running the whole thing end-to-end on the input data. This allows us to use data augmentation, because every input image is going through the convolutional base every time it is seen by the model. However, for this same reason, this technique is far more expensive than the first one.We will cover both techniques. Let's walk through the code required to set-up the first one: recording the output of `conv_base` on our data and using these outputs as inputs to a new model.We will start by simply running instances of the previously-introduced `ImageDataGenerator` to extract images as Numpy arrays as well as their labels. We will extract features from these images simply by calling the `predict` method of the `conv_base` model. | import os
import numpy as np
from keras.preprocessing.image import ImageDataGenerator
base_dir = '/Users/guillaume/Downloads/datasets/small/'
train_dir = os.path.join(base_dir, 'train')
validation_dir = os.path.join(base_dir, 'validation')
test_dir = os.path.join(base_dir, 'test')
datagen = ImageDataGenerator(rescale=1./255)
batch_size = 20
def extract_features(directory, sample_count):
features = np.zeros(shape=(sample_count, 4, 4, 512))
labels = np.zeros(shape=(sample_count))
generator = datagen.flow_from_directory(
directory,
target_size=(150, 150),
batch_size=batch_size,
class_mode='binary')
i = 0
for inputs_batch, labels_batch in generator:
features_batch = conv_base.predict(inputs_batch)
features[i * batch_size : (i + 1) * batch_size] = features_batch
labels[i * batch_size : (i + 1) * batch_size] = labels_batch
i += 1
if i * batch_size >= sample_count:
# Note that since generators yield data indefinitely in a loop,
# we must `break` after every image has been seen once.
break
return features, labels
train_features, train_labels = extract_features(train_dir, 2000)
validation_features, validation_labels = extract_features(validation_dir, 1000)
test_features, test_labels = extract_features(test_dir, 1000) | Found 2000 images belonging to 2 classes.
Found 1000 images belonging to 2 classes.
Found 1000 images belonging to 2 classes.
| MIT | samples/notebooks/week04-03-using-a-pretrained-convnet.ipynb | gu-ma/ba_218_comppx_h1901 |
The extracted features are currently of shape `(samples, 4, 4, 512)`. We will feed them to a densely-connected classifier, so first we must flatten them to `(samples, 8192)`: | train_features = np.reshape(train_features, (2000, 4 * 4 * 512))
validation_features = np.reshape(validation_features, (1000, 4 * 4 * 512))
test_features = np.reshape(test_features, (1000, 4 * 4 * 512)) | _____no_output_____ | MIT | samples/notebooks/week04-03-using-a-pretrained-convnet.ipynb | gu-ma/ba_218_comppx_h1901 |
At this point, we can define our densely-connected classifier (note the use of dropout for regularization), and train it on the data and labels that we just recorded: | from keras import models
from keras import layers
from keras import optimizers
model = models.Sequential()
model.add(layers.Dense(256, activation='relu', input_dim=4 * 4 * 512))
model.add(layers.Dropout(0.5))
model.add(layers.Dense(1, activation='sigmoid'))
model.compile(optimizer=optimizers.RMSprop(lr=2e-5),
loss='binary_crossentropy',
metrics=['acc'])
history = model.fit(train_features, train_labels,
epochs=30,
batch_size=20,
validation_data=(validation_features, validation_labels)) | _____no_output_____ | MIT | samples/notebooks/week04-03-using-a-pretrained-convnet.ipynb | gu-ma/ba_218_comppx_h1901 |
Training is very fast, since we only have to deal with two `Dense` layers -- an epoch takes less than one second even on CPU.Let's take a look at the loss and accuracy curves during training: | import matplotlib.pyplot as plt
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(len(acc))
plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.legend()
plt.figure()
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.show() | _____no_output_____ | MIT | samples/notebooks/week04-03-using-a-pretrained-convnet.ipynb | gu-ma/ba_218_comppx_h1901 |
We reach a validation accuracy of about 90%, much better than what we could achieve in the previous section with our small model trained from scratch. However, our plots also indicate that we are overfitting almost from the start -- despite using dropout with a fairly large rate. This is because this technique does not leverage data augmentation, which is essential to preventing overfitting with small image datasets.Now, let's review the second technique we mentioned for doing feature extraction, which is much slower and more expensive, but which allows us to leverage data augmentation during training: extending the `conv_base` model and running it end-to-end on the inputs. Note that this technique is in fact so expensive that you should only attempt it if you have access to a GPU: it is absolutely intractable on CPU. If you cannot run your code on GPU, then the previous technique is the way to go.Because models behave just like layers, you can add a model (like our `conv_base`) to a `Sequential` model just like you would add a layer. So you can do the following: | from keras import models
from keras import layers
model = models.Sequential()
model.add(conv_base)
model.add(layers.Flatten())
model.add(layers.Dense(256, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid')) | _____no_output_____ | MIT | samples/notebooks/week04-03-using-a-pretrained-convnet.ipynb | gu-ma/ba_218_comppx_h1901 |
This is what our model looks like now: | model.summary() | _________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
vgg16 (Model) (None, 4, 4, 512) 14714688
_________________________________________________________________
flatten_1 (Flatten) (None, 8192) 0
_________________________________________________________________
dense_3 (Dense) (None, 256) 2097408
_________________________________________________________________
dense_4 (Dense) (None, 1) 257
=================================================================
Total params: 16,812,353
Trainable params: 16,812,353
Non-trainable params: 0
_________________________________________________________________
| MIT | samples/notebooks/week04-03-using-a-pretrained-convnet.ipynb | gu-ma/ba_218_comppx_h1901 |
As you can see, the convolutional base of VGG16 has 14,714,688 parameters, which is very large. The classifier we are adding on top has 2 million parameters.Before we compile and train our model, a very important thing to do is to freeze the convolutional base. "Freezing" a layer or set of layers means preventing their weights from getting updated during training. If we don't do this, then the representations that were previously learned by the convolutional base would get modified during training. Since the `Dense` layers on top are randomly initialized, very large weight updates would be propagated through the network, effectively destroying the representations previously learned.In Keras, freezing a network is done by setting its `trainable` attribute to `False`: | print('This is the number of trainable weights '
'before freezing the conv base:', len(model.trainable_weights))
conv_base.trainable = False
print('This is the number of trainable weights '
'after freezing the conv base:', len(model.trainable_weights)) | This is the number of trainable weights after freezing the conv base: 4
| MIT | samples/notebooks/week04-03-using-a-pretrained-convnet.ipynb | gu-ma/ba_218_comppx_h1901 |
With this setup, only the weights from the two `Dense` layers that we added will be trained. That's a total of four weight tensors: two per layer (the main weight matrix and the bias vector). Note that in order for these changes to take effect, we must first compile the model. If you ever modify weight trainability after compilation, you should then re-compile the model, or these changes would be ignored.Now we can start training our model, with the same data augmentation configuration that we used in our previous example: | from keras.preprocessing.image import ImageDataGenerator
train_datagen = ImageDataGenerator(
rescale=1./255,
rotation_range=40,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
fill_mode='nearest')
# Note that the validation data should not be augmented!
test_datagen = ImageDataGenerator(rescale=1./255)
train_generator = train_datagen.flow_from_directory(
# This is the target directory
train_dir,
# All images will be resized to 150x150
target_size=(150, 150),
batch_size=20,
# Since we use binary_crossentropy loss, we need binary labels
class_mode='binary')
validation_generator = test_datagen.flow_from_directory(
validation_dir,
target_size=(150, 150),
batch_size=20,
class_mode='binary')
model.compile(loss='binary_crossentropy',
optimizer=optimizers.RMSprop(lr=2e-5),
metrics=['acc'])
history = model.fit_generator(
train_generator,
steps_per_epoch=100,
epochs=30,
validation_data=validation_generator,
validation_steps=50,
verbose=2)
model.save('cats_and_dogs_small_3.h5') | _____no_output_____ | MIT | samples/notebooks/week04-03-using-a-pretrained-convnet.ipynb | gu-ma/ba_218_comppx_h1901 |
Let's plot our results again: | acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(len(acc))
plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.legend()
plt.figure()
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.show() | _____no_output_____ | MIT | samples/notebooks/week04-03-using-a-pretrained-convnet.ipynb | gu-ma/ba_218_comppx_h1901 |
As you can see, we reach a validation accuracy of about 96%. This is much better than our small convnet trained from scratch. Fine-tuningAnother widely used technique for model reuse, complementary to feature extraction, is _fine-tuning_. Fine-tuning consists in unfreezing a few of the top layers of a frozen model base used for feature extraction, and jointly training both the newly added part of the model (in our case, the fully-connected classifier) and these top layers. This is called "fine-tuning" because it slightly adjusts the more abstract representations of the model being reused, in order to make them more relevant for the problem at hand. We have stated before that it was necessary to freeze the convolution base of VGG16 in order to be able to train a randomly initialized classifier on top. For the same reason, it is only possible to fine-tune the top layers of the convolutional base once the classifier on top has already been trained. If the classified wasn't already trained, then the error signal propagating through the network during training would be too large, and the representations previously learned by the layers being fine-tuned would be destroyed. Thus the steps for fine-tuning a network are as follow:* 1) Add your custom network on top of an already trained base network.* 2) Freeze the base network.* 3) Train the part you added.* 4) Unfreeze some layers in the base network.* 5) Jointly train both these layers and the part you added.We have already completed the first 3 steps when doing feature extraction. Let's proceed with the 4th step: we will unfreeze our `conv_base`, and then freeze individual layers inside of it.As a reminder, this is what our convolutional base looks like: | conv_base.summary() | _________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
input_1 (InputLayer) (None, 150, 150, 3) 0
_________________________________________________________________
block1_conv1 (Conv2D) (None, 150, 150, 64) 1792
_________________________________________________________________
block1_conv2 (Conv2D) (None, 150, 150, 64) 36928
_________________________________________________________________
block1_pool (MaxPooling2D) (None, 75, 75, 64) 0
_________________________________________________________________
block2_conv1 (Conv2D) (None, 75, 75, 128) 73856
_________________________________________________________________
block2_conv2 (Conv2D) (None, 75, 75, 128) 147584
_________________________________________________________________
block2_pool (MaxPooling2D) (None, 37, 37, 128) 0
_________________________________________________________________
block3_conv1 (Conv2D) (None, 37, 37, 256) 295168
_________________________________________________________________
block3_conv2 (Conv2D) (None, 37, 37, 256) 590080
_________________________________________________________________
block3_conv3 (Conv2D) (None, 37, 37, 256) 590080
_________________________________________________________________
block3_pool (MaxPooling2D) (None, 18, 18, 256) 0
_________________________________________________________________
block4_conv1 (Conv2D) (None, 18, 18, 512) 1180160
_________________________________________________________________
block4_conv2 (Conv2D) (None, 18, 18, 512) 2359808
_________________________________________________________________
block4_conv3 (Conv2D) (None, 18, 18, 512) 2359808
_________________________________________________________________
block4_pool (MaxPooling2D) (None, 9, 9, 512) 0
_________________________________________________________________
block5_conv1 (Conv2D) (None, 9, 9, 512) 2359808
_________________________________________________________________
block5_conv2 (Conv2D) (None, 9, 9, 512) 2359808
_________________________________________________________________
block5_conv3 (Conv2D) (None, 9, 9, 512) 2359808
_________________________________________________________________
block5_pool (MaxPooling2D) (None, 4, 4, 512) 0
=================================================================
Total params: 14,714,688
Trainable params: 0
Non-trainable params: 14,714,688
_________________________________________________________________
| MIT | samples/notebooks/week04-03-using-a-pretrained-convnet.ipynb | gu-ma/ba_218_comppx_h1901 |
We will fine-tune the last 3 convolutional layers, which means that all layers up until `block4_pool` should be frozen, and the layers `block5_conv1`, `block5_conv2` and `block5_conv3` should be trainable.Why not fine-tune more layers? Why not fine-tune the entire convolutional base? We could. However, we need to consider that:* Earlier layers in the convolutional base encode more generic, reusable features, while layers higher up encode more specialized features. It is more useful to fine-tune the more specialized features, as these are the ones that need to be repurposed on our new problem. There would be fast-decreasing returns in fine-tuning lower layers.* The more parameters we are training, the more we are at risk of overfitting. The convolutional base has 15M parameters, so it would be risky to attempt to train it on our small dataset.Thus, in our situation, it is a good strategy to only fine-tune the top 2 to 3 layers in the convolutional base.Let's set this up, starting from where we left off in the previous example: | conv_base.trainable = True
set_trainable = False
for layer in conv_base.layers:
if layer.name == 'block5_conv1':
set_trainable = True
if set_trainable:
layer.trainable = True
else:
layer.trainable = False | _____no_output_____ | MIT | samples/notebooks/week04-03-using-a-pretrained-convnet.ipynb | gu-ma/ba_218_comppx_h1901 |
Now we can start fine-tuning our network. We will do this with the RMSprop optimizer, using a very low learning rate. The reason for using a low learning rate is that we want to limit the magnitude of the modifications we make to the representations of the 3 layers that we are fine-tuning. Updates that are too large may harm these representations.Now let's proceed with fine-tuning: | model.compile(loss='binary_crossentropy',
optimizer=optimizers.RMSprop(lr=1e-5),
metrics=['acc'])
history = model.fit_generator(
train_generator,
steps_per_epoch=100,
epochs=100,
validation_data=validation_generator,
validation_steps=50)
model.save('cats_and_dogs_small_4.h5') | _____no_output_____ | MIT | samples/notebooks/week04-03-using-a-pretrained-convnet.ipynb | gu-ma/ba_218_comppx_h1901 |
Let's plot our results using the same plotting code as before: | acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(len(acc))
plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.legend()
plt.figure()
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.show() | _____no_output_____ | MIT | samples/notebooks/week04-03-using-a-pretrained-convnet.ipynb | gu-ma/ba_218_comppx_h1901 |
These curves look very noisy. To make them more readable, we can smooth them by replacing every loss and accuracy with exponential moving averages of these quantities. Here's a trivial utility function to do this: | def smooth_curve(points, factor=0.8):
smoothed_points = []
for point in points:
if smoothed_points:
previous = smoothed_points[-1]
smoothed_points.append(previous * factor + point * (1 - factor))
else:
smoothed_points.append(point)
return smoothed_points
plt.plot(epochs,
smooth_curve(acc), 'bo', label='Smoothed training acc')
plt.plot(epochs,
smooth_curve(val_acc), 'b', label='Smoothed validation acc')
plt.title('Training and validation accuracy')
plt.legend()
plt.figure()
plt.plot(epochs,
smooth_curve(loss), 'bo', label='Smoothed training loss')
plt.plot(epochs,
smooth_curve(val_loss), 'b', label='Smoothed validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.show() | _____no_output_____ | MIT | samples/notebooks/week04-03-using-a-pretrained-convnet.ipynb | gu-ma/ba_218_comppx_h1901 |
These curves look much cleaner and more stable. We are seeing a nice 1% absolute improvement.Note that the loss curve does not show any real improvement (in fact, it is deteriorating). You may wonder, how could accuracy improve if the loss isn't decreasing? The answer is simple: what we display is an average of pointwise loss values, but what actually matters for accuracy is the distribution of the loss values, not their average, since accuracy is the result of a binary thresholding of the class probability predicted by the model. The model may still be improving even if this isn't reflected in the average loss.We can now finally evaluate this model on the test data: | test_generator = test_datagen.flow_from_directory(
test_dir,
target_size=(150, 150),
batch_size=20,
class_mode='binary')
test_loss, test_acc = model.evaluate_generator(test_generator, steps=50)
print('test acc:', test_acc) | Found 1000 images belonging to 2 classes.
test acc: 0.967999992371
| MIT | samples/notebooks/week04-03-using-a-pretrained-convnet.ipynb | gu-ma/ba_218_comppx_h1901 |
WebApp Covid19dynstat - using Dash/JupyterDash@author: Jens Henrik Göbbert @mail: [email protected] The `jupyter-dash` package makes it easy to develop Plotly Dash apps from the Jupyter Notebook and JupyterLab.Just replace the standard `dash.Dash` class with the `jupyter_dash.JupyterDash` subclass. before publish- set correct asset_url- set cache_time=86400- use app.run_server(mode="external") | import dash
import dash_core_components as dcc
import dash_html_components as html
import dash_bootstrap_components as dbc
from dash.dependencies import Input, Output, State
import dash_player
from flask_caching import Cache
import os
import pandas as pd
#print(dcc.__version__) | _____no_output_____ | BSD-3-Clause | covid19/covid19dynstat-dash.ipynb | FZJ-JSC/jupyter-jsc-dashboads |
When running in JupyterHub (or Binder), call the `infer_jupyter_config` function to detect the proxy configuration. This will detect the proper request_pathname_prefix and server_url values to use when displaying Dash apps. For example: - server_url = `https://jupyter-jsc.fz-juelich.de` - request_pathname_prefix = `/user/[email protected]/jureca_login/` For details please check the source here https://github.com/plotly/jupyter-dash/blob/v0.2.1.post1/jupyter_dash/comms.pyL33 | from jupyter_dash import JupyterDash
JupyterDash.infer_jupyter_proxy_config() | _____no_output_____ | BSD-3-Clause | covid19/covid19dynstat-dash.ipynb | FZJ-JSC/jupyter-jsc-dashboads |
**Attention:** I have to run this cell twice: first press play, wait a bit and hit play again while it still shows `[*]` Create a Dash Flask serverRequests the browser to load Bootstrap | from pathlib import Path
# create app
app = JupyterDash(__name__,
external_stylesheets=[dbc.themes.BOOTSTRAP],
update_title=None,
suppress_callback_exceptions=True, # because of multi-page setup
)
# config app
app.title = 'Covid-19-Interaktionsmodell'
cache_dir = "./cache"
Path(cache_dir).mkdir(parents=True, exist_ok=True)
cache = Cache(app.server, config={
'CACHE_TYPE': 'filesystem',
'CACHE_DIR': cache_dir,
#'CACHE_THRESHOLD': 10000, # max. no. items stored before deletion starts (only for SimpleCache and FileSystemCache)
## try 'redis' if you want to use a database for caching
#'CACHE_TYPE': 'redis'
#'CACHE_REDIS_URL': os.environ.get('REDIS_URL', '')
})
cache_timeout=1 #86400 # on day in secounds
# clear cache to avoid any strange behaviour on restart while developing
cache.clear()
# start the server
server = app.server
from datetime import datetime as dt, timedelta
# set the base-url to the assets directory
asset_url="https://jupyter-jsc.fz-juelich.de" + os.environ['JUPYTERHUB_SERVICE_PREFIX'] + "proxy/8050/assets/"
#asset_url=app.get_asset_url('assets') + "/"
print(asset_url)
metadata = pd.read_csv("assets/metadata.csv")
#for index, row in metadata.iterrows():
# print(row['countyId'])
deltadays = 25
min_date=dt(2020, 3, 26).date()
max_date=dt(2020, 3, 31).date() # dt.today().date()
init_date=dt(2020, 3, 26).date() # dt.today().date()
init_date=init_date -timedelta(days=deltadays)
init_assets_dir = init_date.strftime('%Y_%m_%d') + "/"
#print(init_assets_dir)
init_countyid=11001
def get_assets_dir(date):
date = dt.strptime(date.split(' ')[0], '%Y-%m-%d')
assets_dir = (date -timedelta(days=deltadays)).strftime('%Y_%m_%d') + "/"
return assets_dir | _____no_output_____ | BSD-3-Clause | covid19/covid19dynstat-dash.ipynb | FZJ-JSC/jupyter-jsc-dashboads |
Create interactive map of Germany | ## load & initialize static data
# => tuple-list 'counties_geojson'
# => dataframe 'counties_metadf'
import json
# Landkreis-Geometrie vom RKI:
# https://npgeo-corona-npgeo-de.hub.arcgis.com/datasets/917fc37a709542548cc3be077a786c17_0 -> ShapeFile
# https://mapshaper.org -> GEOJSON
with open('assets/DE-Landkreise_RKI.geojson.json') as json_file:
counties_geojson = json.load(json_file)
# 'id' must be the unique identifier of the shapes (required by plotly.Choroplethmapbox)
for i, feat in enumerate(counties_geojson['features']):
feat['id'] = i
counties_metadf = pd.DataFrame(data={
# geoid must match county-shape-ids in json file (must start with 0 and increase with no missing one)
'geoids' : [feat['id'] for feat in counties_geojson['features']],
'names' : [feat['properties'].get('GEN') for feat in counties_geojson['features']],
'cca' : [feat['properties'].get('RS') for feat in counties_geojson['features']],
})
# test
#counties_metadf.loc[counties_metadf['cca']=='03159'] # data of Göttingen
#counties_metadf.to_csv('counties_metadata.csv', index=False)
## load dynamic data
# => dataframe 'inf'
import plotly.graph_objects as go
from numpy import nan
def create_map(mapcsv_path, colName):
infArr=[]
try:
# read number of infections from csv file
mapcsv = pd.read_csv(mapcsv_path)
#print(mapcsv.loc[mapcsv['countyID'] == 3159]) # test with Göttingen
# create (correctly sorted) dataframe from no.infections
# loop over all counties and read no.infections from mapcsv
for feat in counties_geojson['features']: # same loop as for df (important)
cca_str = feat['properties'].get('RS')
if cca_str is not None:
# read model value for this county from mapcsv
cca_valuedf = mapcsv.loc[mapcsv['countyID']==int(cca_str), colName] #'newInf100k']
cca_value = next(iter(cca_valuedf), 0.0)
infArr.append(cca_value)
else:
infArr.append(0.0)
except: #IOError as e:
print("File not found: " + mapcsv_path)
for feat in counties_geojson['features']:
infArr.append(nan)
counties_infdf = pd.DataFrame(data={'infections': infArr})
# test
#print(inf['infections'][91]) # data of Freiburg
#inf.to_csv('countyInfections_metadata.csv', index=False)
# create figure
mapfig = go.Figure(go.Choroplethmapbox(
geojson=counties_geojson,
locations=counties_metadf.geoids,
z=counties_infdf.infections,
text=counties_metadf.names,
colorscale="Jet",
colorbar=dict(thickness=20, ticklen=3, title="Neuinfektionen pro 100.000 Einwohner und Tag", titleside="right"),
zmin=0, zmax=10,
marker_opacity=0.5, marker_line_width=0,
hovertemplate=
"<b>%{text}</b><br>" +
"%{z:.2f}<br>" +
"<extra></extra>",)
)
mapfig.update_layout(
uirevision=True, # keep zoom,panning, etc. when updating
autosize=True,
#legend=dict(
# # Adjust click behavior
# itemclick="toggleothers",
# itemdoubleclick="toggle",
#),
#xaxis=dict(
# autorange='reversed',
# fixedrange=True
#),
#yaxis=dict(
# autorange='reversed',
# fixedrange=True
#),
width=500, height=450,
mapbox_style="carto-positron", # https://plotly.com/python/mapbox-layers/
mapbox_zoom=4.5,
mapbox_center = {"lat": 51.30, "lon": 10.45},
margin={"r":0,"t":0,"l":0,"b":0})
return mapfig
init_mapfig_bstim = create_map("assets/figures/" + init_assets_dir + "map.csv", 'newInf100k')
init_mapfig_rki = create_map("assets/figures/" + init_assets_dir + "map.csv", 'newInf100k_RKI')
init_mapfig_bstim.show(config={"displayModeBar": False, "showTips": False, "modeBarButtonsToRemove": ['toImage']}) # "staticPlot": True}) | _____no_output_____ | BSD-3-Clause | covid19/covid19dynstat-dash.ipynb | FZJ-JSC/jupyter-jsc-dashboads |
Define the top navigation bar | #####################
# Disclaimer
#####################
disclaimer_modal = html.Div(
[
dcc.Markdown(
f"""
-----
##### BSTIM-Covid19
-----
Aktuelle Daten und Vorhersage der täglich gemeldeten Neuinfektionen mit COVID-19 für Landkreise in Deutschland.
Das Model beschreibt die zeitliche Entwicklung der Neuinfektionen in einen Zeitraum von mehreren Wochen.
Es betrachtet dazu nicht nur die wahrscheinlichste Entwicklung oder die mittlere Entwicklung, sondern schätzt die Wahrscheinlichkeit für verschiedene Szenarien ab, die mit der aktuellen Datenlage kompatibel sind.
Zudem wird die räumlich-zeitliche Komponente des Infektionsgeschehens geschätzt und als sogenannter "Interaktionskernel" dargestellt.
Die Arbeit basiert auf einer Adaption des [BSTIM Models](https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0225838#pone.0225838.ref009), angepasst an die COVID-19 Situation.
Das Model beschreibt die tagesaktuellen Meldedaten basierend auf den [Daten](https://npgeo-corona-npgeo-de.hub.arcgis.com/datasets/dd4580c810204019a7b8eb3e0b329dd6_0/data?orderBy=Meldedatum) des RKI.
Alle hier präsentierten Ergebnisse resultieren aus einer Modellierung basierend auf statistischen Methoden.
Sie bilden damit nicht das reale Geschehen, sondern Schätzungen ab, die von der wirklichen Situation abweichen können.
Dies ist bei der Interpretation der Ergebnisse zu berücksichtigen.
Ebenso ist zu beachten, dass die Qualität dieser statistischen Methoden maßgeblich von der Qualität der zugrunde liegenden Daten abhängt.
"""
),
html.Span(
children=[
dbc.Button("Disclaimer", id="disclaimer_modal_open", outline=True, color="secondary", className="mt-0"),
],
style={
"float": 'right',
"marginTop": 0,
"marginBottom": 10,
},
),
dbc.Modal(
id="disclaimer_modal",
size="xl",
children=[
dbc.ModalHeader("Disclaimer"),
dbc.ModalBody(
children=[
dcc.Markdown(
f"""
Für die Gesamtzahl der Infektionen pro Bundesland/Landkreis werden die den Gesundheitsämtern nach Infektionsschutzgesetz gemeldeten Fälle verwendet,
die dem RKI bis zum jeweiligen Tag um 0 Uhr übermittelt wurden.
Für die Analyse wird das Meldedatum verwendet, s. [Details zu den Daten](https://experience.arcgis.com/experience/478220a4c454480e823b17327b2bf1d4)
Da es in dem Verfahren zu Differenzen zwischen Erkrankungsdatum und Meldedatum, sowie Verzögerungen in dem Meldeprozess geben kann,
ist die Analyse der Fallzahlen der letzten Woche bereits eine Vorhersage, die auf einer Schätzung basiert.
Alle hier präsentierten Ergebnisse basieren auf statistischen Methoden und bilden damit nicht das reale Geschehen, sondern Schätzungen ab, die von der wirklichen Situation abweichen können.
Dies ist bei der Interpretation der Ergebnisse zu berücksichtigen.
Die hier präsentierten Forschungsergebnisse basieren auf einer neuen Methodik die bisher nicht für COVID-19 eingesetzt wurde.
Die Validierung der Ergebnisse wird mit wachsender Menge an Daten in den kommenden Monaten fortgeführt.
Für eine detailliertere Analyse der COVID-19-Fälle verweisen wir auf den [täglichen Lagebericht des RKI](https://www.rki.de/DE/Content/InfAZ/N/Neuartiges_Coronavirus/Situationsberichte/Gesamt.html).
"""
),
]
),
dbc.ModalFooter(
dbc.Button("Schließen", id="disclaimer_modal_close", className="ml-auto")
),
],
),
]
)
@app.callback(
Output("disclaimer_modal", "is_open"),
[Input("disclaimer_modal_open", "n_clicks"), Input("disclaimer_modal_close", "n_clicks")],
[State("disclaimer_modal", "is_open")],
)
def toggle_modal(n1, n2, is_open):
if n1 or n2:
return not is_open
return is_open
#####################
# Impressum
#####################
impressum_modal = html.Div(
[
dbc.Button("Impressum", id="impressum_modal_open", outline=True, color="secondary", className="mr-1"),
dbc.Modal(
id="impressum_modal",
size="xl",
children=[
dbc.ModalHeader("Impressum und Haftungsausschluss"),
dbc.ModalBody(
children=[
dcc.Markdown(
f"""
## Impressum
Das Projekt covid19dynstat ist ein gemeinsames Projekt des Institutes für Kognitionswissenschaft der Universität Osnabrück und des Jülich Supercomputing Centre am Forschungszentrum Jülich.
### Inhaltlicher und wissenschaftlicher Kontakt
Prof. Dr. Gordon Pipa
Institut für Kognitionswissenschaft
Wachsbleiche 27
49090 Osnabrück
Mailadresse: [email protected]
## Haftungsausschluss
### Inhalt der eigenen Seiten
Wir haben die Internet-Seiten des Projektes covid19dynstat sorgfältig zusammengestellt.
Allerdings übernehmen wir keine Gewähr oder Haftung für die Aktualität, Vollständigkeit und Richtigkeit der angebotenen Informationen.
### Links auf externe Web-Seiten
Die Internet-Seiten des Projektes covid19dynstat enthalten Links auf die Web-Seiten Dritter.
Diese Links auf die Web-Seiten Dritter stellen keine Zustimmung zu deren Inhalt dar.
Das Projekt covid19dynstat hat keinen Einfluss auf die aktuelle oder zukünftige Gestaltung dieser Seiten.
Wir übernehmen daher keine Haftung für die Verfügbarkeit oder den Inhalt solcher Web-Seiten und keine Haftung für Schäden, die aus der Nutzung solcher Inhalte entstehen.
## Hoster
Die Webseiten des Projektes covid19dynstat werden gehostet am
Forschungszentrum Jülich GmbH
Wilhelm-Johnen-Straße
52428 Jülich
#### Postanschrift:
52425 Jülich
#### Lieferanschrift:
Leo-Brandt-Straße
52428 Jülich
Eingetragen im Handelsregister des Amtsgerichts Düren Nr. HR B 3498
Umsatzsteuer-Id-Nr. gem. § 27 a Umsatzsteuergesetz: DE 122624631
Steuer-Nr.: 213/5700/0033
#### Geschäftsführung:
- Prof. Dr.-Ing. Wolfgang Marquardt (Vorsitzender)
- Karsten Beneke (Stellvertr. Vorsitzender)
- Prof. Dr. Harald Bolt
#### Vorsitzender des Aufsichtsrats:
Ministerialdirektor Volker Rieke
#### Kontakt:
Telefon-Sammel-Nr. 02461 61-0
Telefax-Sammel-Nr. 02461 61-8100
Internet: http://www.fz-juelich.de
Mailadresse: [email protected]
"""
),
]
),
dbc.ModalFooter(
dbc.Button("Schließen", id="impressum_modal_close", className="ml-auto")
),
],
),
]
)
@app.callback(
Output("impressum_modal", "is_open"),
[Input("impressum_modal_open", "n_clicks"), Input("impressum_modal_close", "n_clicks")],
[State("impressum_modal", "is_open")],
)
def toggle_modal(n1, n2, is_open):
if n1 or n2:
return not is_open
return is_open
#####################
# Datenschutzerklärung
#####################
datenschutz_modal = html.Div(
[
dbc.Button("Datenschutz", id="datenschutz_modal_open", outline=True, color="secondary", className="mr-1"),
dbc.Modal(
id="datenschutz_modal",
size="xl",
children=[
dbc.ModalHeader("Datenschutzerklärung"),
dbc.ModalBody(
children=[
dcc.Markdown(
f"""
## Datenschutzerklärung
Wir freuen uns sehr über Ihr Interesse an unserem Projekt.
Datenschutz hat einen besonders hohen Stellenwert für das Projekt BSTIM-Covid19.
Eine Nutzung der Internetseiten des Projekts BSTIM-Covid19 ist grundsätzlich ohne jede Angabe personenbezogener Daten möglich.
Sofern eine betroffene Person besondere Services unseres Projekts über unsere Internetseite in Anspruch nehmen möchte, könnte jedoch eine Verarbeitung personenbezogener Daten erforderlich werden.
Ist die Verarbeitung personenbezogener Daten erforderlich und besteht für eine solche Verarbeitung keine gesetzliche Grundlage, holen wir generell eine Einwilligung der betroffenen Person ein.
Die Verarbeitung personenbezogener Daten, beispielsweise des Namens, der Anschrift, E-Mail-Adresse oder Telefonnummer einer betroffenen Person, erfolgt stets im Einklang mit der Datenschutz-Grundverordnung und in Übereinstimmung mit den für das Projekt BSTIM-Covid19 geltenden landesspezifischen Datenschutzbestimmungen.
Mittels dieser Datenschutzerklärung möchte unser Projekt die Öffentlichkeit über Art, Umfang und Zweck der von uns erhobenen, genutzten und verarbeiteten personenbezogenen Daten informieren.
Ferner werden betroffene Personen mittels dieser Datenschutzerklärung über die ihnen zustehenden Rechte aufgeklärt.
Das Projekt BSTIM-Covid19 hat als für die Verarbeitung Verantwortlicher zahlreiche technische und organisatorische Maßnahmen umgesetzt, um einen möglichst lückenlosen Schutz der über diese Internetseite verarbeiteten personenbezogenen Daten sicherzustellen.
Dennoch können Internetbasierte Datenübertragungen grundsätzlich Sicherheitslücken aufweisen, sodass ein absoluter Schutz nicht gewährleistet werden kann. Aus diesem Grund steht es jeder betroffenen Person frei, personenbezogene Daten auch auf alternativen Wegen, beispielsweise telefonisch, an uns zu übermitteln.
### 1. Begriffsbestimmungen
Die Datenschutzerklärung des Projekts BSTIM-Covid19 beruht auf den Begrifflichkeiten, die durch den Europäischen Richtlinien- und Verordnungsgeber beim Erlass der Datenschutz-Grundverordnung (DSGVO) verwendet wurden.
Unsere Datenschutzerklärung soll sowohl für die Öffentlichkeit als auch für unsere Kunden und Geschäftspartner einfach lesbar und verständlich sein. Um dies zu gewährleisten, möchten wir vorab die verwendeten Begrifflichkeiten erläutern.
Wir verwenden in dieser Datenschutzerklärung unter anderem die folgenden Begriffe:
#### a) personenbezogene Daten
Personenbezogene Daten sind alle Informationen, die sich auf eine identifizierte oder identifizierbare natürliche Person (im Folgenden „betroffene Person“) beziehen.
Als identifizierbar wird eine natürliche Person angesehen, die direkt oder indirekt, insbesondere mittels Zuordnung zu einer Kennung wie einem Namen, zu einer Kennnummer, zu Standortdaten, zu einer Online-Kennung oder zu einem oder mehreren besonderen Merkmalen, die Ausdruck der physischen, physiologischen, genetischen, psychischen, wirtschaftlichen, kulturellen oder sozialen Identität dieser natürlichen Person sind, identifiziert werden kann.
#### b) betroffene Person
Betroffene Person ist jede identifizierte oder identifizierbare natürliche Person, deren personenbezogene Daten von dem für die Verarbeitung Verantwortlichen verarbeitet werden.
#### c) Verarbeitung
Verarbeitung ist jeder mit oder ohne Hilfe automatisierter Verfahren ausgeführte Vorgang oder jede solche Vorgangsreihe im Zusammenhang mit personenbezogenen Daten wie das Erheben, das Erfassen, die Organisation, das Ordnen, die Speicherung, die Anpassung oder Veränderung, das Auslesen, das Abfragen, die Verwendung, die Offenlegung durch Übermittlung, Verbreitung oder eine andere Form der Bereitstellung, den Abgleich oder die Verknüpfung, die Einschränkung, das Löschen oder die Vernichtung.
#### d) Einschränkung der Verarbeitung
Einschränkung der Verarbeitung ist die Markierung gespeicherter personenbezogener Daten mit dem Ziel, ihre künftige Verarbeitung einzuschränken.
#### e) Profiling
Profiling ist jede Art der automatisierten Verarbeitung personenbezogener Daten, die darin besteht, dass diese personenbezogenen Daten verwendet werden, um bestimmte persönliche Aspekte, die sich auf eine natürliche Person beziehen, zu bewerten, insbesondere, um Aspekte bezüglich Arbeitsleistung, wirtschaftlicher Lage, Gesundheit, persönlicher Vorlieben, Interessen, Zuverlässigkeit, Verhalten, Aufenthaltsort oder Ortswechsel dieser natürlichen Person zu analysieren oder vorherzusagen.
#### f) Pseudonymisierung
Pseudonymisierung ist die Verarbeitung personenbezogener Daten in einer Weise, auf welche die personenbezogenen Daten ohne Hinzuziehung zusätzlicher Informationen nicht mehr einer spezifischen betroffenen Person zugeordnet werden können, sofern diese zusätzlichen Informationen gesondert aufbewahrt werden und technischen und organisatorischen Maßnahmen unterliegen, die gewährleisten, dass die personenbezogenen Daten nicht einer identifizierten oder identifizierbaren natürlichen Person zugewiesen werden.
#### g) Verantwortlicher oder für die Verarbeitung Verantwortlicher
Verantwortlicher oder für die Verarbeitung Verantwortlicher ist die natürliche oder juristische Person, Behörde, Einrichtung oder andere Stelle, die allein oder gemeinsam mit anderen über die Zwecke und Mittel der Verarbeitung von personenbezogenen Daten entscheidet.
Sind die Zwecke und Mittel dieser Verarbeitung durch das Unionsrecht oder das Recht der Mitgliedstaaten vorgegeben, so kann der Verantwortliche beziehungsweise können die bestimmten Kriterien seiner Benennung nach dem Unionsrecht oder dem Recht der Mitgliedstaaten vorgesehen werden.
#### h) Auftragsverarbeiter
Auftragsverarbeiter ist eine natürliche oder juristische Person, Behörde, Einrichtung oder andere Stelle, die personenbezogene Daten im Auftrag des Verantwortlichen verarbeitet.
#### i) Empfänger
Empfänger ist eine natürliche oder juristische Person, Behörde, Einrichtung oder andere Stelle, der personenbezogene Daten offengelegt werden, unabhängig davon, ob es sich bei ihr um einen Dritten handelt oder nicht.
Behörden, die im Rahmen eines bestimmten Untersuchungsauftrags nach dem Unionsrecht oder dem Recht der Mitgliedstaaten möglicherweise personenbezogene Daten erhalten, gelten jedoch nicht als Empfänger.
#### j) Dritter
Dritter ist eine natürliche oder juristische Person, Behörde, Einrichtung oder andere Stelle außer der betroffenen Person, dem Verantwortlichen, dem Auftragsverarbeiter und den Personen, die unter der unmittelbaren Verantwortung des Verantwortlichen oder des Auftragsverarbeiters befugt sind, die personenbezogenen Daten zu verarbeiten.
#### k) Einwilligung
Einwilligung ist jede von der betroffenen Person freiwillig für den bestimmten Fall in informierter Weise und unmissverständlich abgegebene Willensbekundung in Form einer Erklärung oder einer sonstigen eindeutigen bestätigenden Handlung, mit der die betroffene Person zu verstehen gibt, dass sie mit der Verarbeitung der sie betreffenden personenbezogenen Daten einverstanden ist.
### 2. Name und Anschrift des für die Verarbeitung Verantwortlichen
Verantwortlicher im Sinne der Datenschutz-Grundverordnung, sonstiger in den Mitgliedstaaten der Europäischen Union geltenden Datenschutzgesetze und anderer Bestimmungen mit datenschutzrechtlichem Charakter ist:
Projekt BSTIM-Covid19
Prof. Dr. Gordon Pipa
Institut für Kognitionswissenschaft
Wachsbleiche 27
49090 Osnabrück
Mailadresse: [email protected]
#### a) Hoster
Die Webseiten des Projekts BSTIM-Covid19 werden gehostet von der
Forschungszentrum Jülich GmbH
Wilhelm-Johnen-Straße
52428 Jülich
Germany
### 3. Name und Anschrift des Datenschutzbeauftragten
Der Datenschutzbeauftragte des für die Verarbeitung Verantwortlichen ist:
Frank Rinkens
Forschungszentrum Jülich GmbH
Wilhelm-Johnen-Strasse
52428 Jülich
Deutschland
Tel.: +49 2461 61-9005
Website: [www.fz-juelich.de](https://www.fz-juelich.de)
E-Mail: [email protected]
Jede betroffene Person kann sich jederzeit bei allen Fragen und Anregungen zum Datenschutz direkt an unseren Datenschutzbeauftragten wenden.
### 4. Cookies
Die Internetseiten des Projekts BSTIM-Covid19 verwenden Cookies.
Cookies sind Textdateien, welche über einen Internetbrowser auf einem Computersystem abgelegt und gespeichert werden.
Zahlreiche Internetseiten und Server verwenden Cookies. Viele Cookies enthalten eine sogenannte Cookie-ID. Eine Cookie-ID ist eine eindeutige Kennung des Cookies.
Sie besteht aus einer Zeichenfolge, durch welche Internetseiten und Server dem konkreten Internetbrowser zugeordnet werden können, in dem das Cookie gespeichert wurde.
Dies ermöglicht es den besuchten Internetseiten und Servern, den individuellen Browser der betroffenen Person von anderen Internetbrowsern, die andere Cookies enthalten, zu unterscheiden.
Ein bestimmter Internetbrowser kann über die eindeutige Cookie-ID wiedererkannt und identifiziert werden.
Durch den Einsatz von Cookies kann das Projekt BSTIM-Covid19 den Nutzern dieser Internetseite nutzerfreundlichere Services bereitstellen, die ohne die Cookie-Setzung nicht möglich wären.
Mittels eines Cookies können die Informationen und Angebote auf unserer Internetseite im Sinne des Benutzers optimiert werden. Cookies ermöglichen uns, wie bereits erwähnt, die Benutzer unserer Internetseite wiederzuerkennen.
Zweck dieser Wiedererkennung ist es, den Nutzern die Verwendung unserer Internetseite zu erleichtern.
Der Benutzer einer Internetseite, die Cookies verwendet, muss beispielsweise nicht bei jedem Besuch der Internetseite erneut seine Zugangsdaten eingeben, weil dies von der Internetseite und dem auf dem Computersystem des Benutzers abgelegten Cookie übernommen wird.
Ein weiteres Beispiel ist das Cookie eines Warenkorbes im Online-Shop. Der Online-Shop merkt sich die Artikel, die ein Kunde in den virtuellen Warenkorb gelegt hat, über ein Cookie.
Die betroffene Person kann die Setzung von Cookies durch unsere Internetseite jederzeit mittels einer entsprechenden Einstellung des genutzten Internetbrowsers verhindern und damit der Setzung von Cookies dauerhaft widersprechen.
Ferner können bereits gesetzte Cookies jederzeit über einen Internetbrowser oder andere Softwareprogramme gelöscht werden.
Dies ist in allen gängigen Internetbrowsern möglich. Deaktiviert die betroffene Person die Setzung von Cookies in dem genutzten Internetbrowser, sind unter Umständen nicht alle Funktionen unserer Internetseite vollumfänglich nutzbar.
### 5. Erfassung von allgemeinen Daten und Informationen
Die Internetseite des Projekts BSTIM-Covid19 erfasst mit jedem Aufruf der Internetseite durch eine betroffene Person oder ein automatisiertes System eine Reihe von allgemeinen Daten und Informationen.
Diese allgemeinen Daten und Informationen werden in den Logfiles des Servers gespeichert.
Erfasst werden können die
(1) verwendeten Browsertypen und Versionen,
(2) das vom zugreifenden System verwendete Betriebssystem,
(3) die Internetseite, von welcher ein zugreifendes System auf unsere Internetseite gelangt (sogenannte Referrer),
(4) die Unterwebseiten, welche über ein zugreifendes System auf unserer Internetseite angesteuert werden,
(5) das Datum und die Uhrzeit eines Zugriffs auf die Internetseite,
(6) eine Internet-Protokoll-Adresse (IP-Adresse),
(7) der Internet-Service-Provider des zugreifenden Systems und
(8) sonstige ähnliche Daten und Informationen, die der Gefahrenabwehr im Falle von Angriffen auf unsere informationstechnologischen Systeme dienen.
Bei der Nutzung dieser allgemeinen Daten und Informationen zieht das Projekt BSTIM-Covid19 keine Rückschlüsse auf die betroffene Person.
Diese Informationen werden vielmehr benötigt, um
(1) die Inhalte unserer Internetseite korrekt auszuliefern,
(2) die dauerhafte Funktionsfähigkeit unserer informationstechnologischen Systeme und der Technik unserer Internetseite zu gewährleisten sowie
(3) um Strafverfolgungsbehörden im Falle eines Cyberangriffes die zur Strafverfolgung notwendigen Informationen bereitzustellen.
Diese anonym erhobenen Daten und Informationen werden durch das Projekt BSTIM-Covid19 daher einerseits statistisch und ferner mit dem Ziel ausgewertet, den Datenschutz und die Datensicherheit in unserem Projekt zu erhöhen, um letztlich ein optimales Schutzniveau für die von uns verarbeiteten personenbezogenen Daten sicherzustellen.
Die anonymen Daten der Server-Logfiles werden getrennt von allen durch eine betroffene Person angegebenen personenbezogenen Daten gespeichert.
### 6. Kontaktmöglichkeit über die Internetseite
Die Internetseite des Projekts BSTIM-Covid19 enthält aufgrund von gesetzlichen Vorschriften Angaben, die eine schnelle elektronische Kontaktaufnahme zu unserem Projekt sowie eine unmittelbare Kommunikation mit uns ermöglichen, was ebenfalls eine allgemeine Adresse der sogenannten elektronischen Post (E-Mail-Adresse) umfasst.
Sofern eine betroffene Person per E-Mail oder über ein Kontaktformular den Kontakt mit dem für die Verarbeitung Verantwortlichen aufnimmt, werden die von der betroffenen Person übermittelten personenbezogenen Daten automatisch gespeichert.
Solche auf freiwilliger Basis von einer betroffenen Person an den für die Verarbeitung Verantwortlichen übermittelten personenbezogenen Daten werden für Zwecke der Bearbeitung oder der Kontaktaufnahme zur betroffenen Person gespeichert.
Es erfolgt keine Weitergabe dieser personenbezogenen Daten an Dritte.
### 7. Routinemäßige Löschung und Sperrung von personenbezogenen Daten
Der für die Verarbeitung Verantwortliche verarbeitet und speichert personenbezogene Daten der betroffenen Person nur für den Zeitraum, der zur Erreichung des Speicherungszwecks erforderlich ist oder sofern dies durch den Europäischen Richtlinien- und Verordnungsgeber oder einen anderen Gesetzgeber in Gesetzen oder Vorschriften, welchen der für die Verarbeitung Verantwortliche unterliegt, vorgesehen wurde.
Entfällt der Speicherungszweck oder läuft eine vom Europäischen Richtlinien- und Verordnungsgeber oder einem anderen zuständigen Gesetzgeber vorgeschriebene Speicherfrist ab, werden die personenbezogenen Daten routinemäßig und entsprechend den gesetzlichen Vorschriften gesperrt oder gelöscht.
### 8. Rechte der betroffenen Person
#### a) Recht auf Bestätigung
Jede betroffene Person hat das vom Europäischen Richtlinien- und Verordnungsgeber eingeräumte Recht, von dem für die Verarbeitung Verantwortlichen eine Bestätigung darüber zu verlangen, ob sie betreffende personenbezogene Daten verarbeitet werden.
Möchte eine betroffene Person dieses Bestätigungsrecht in Anspruch nehmen, kann sie sich hierzu jederzeit an den für die Verarbeitung Verantwortlichen wenden.
#### b) Recht auf Auskunft
Jede von der Verarbeitung personenbezogener Daten betroffene Person hat das vom Europäischen Richtlinien- und Verordnungsgeber gewährte Recht, jederzeit von dem für die Verarbeitung Verantwortlichen unentgeltliche Auskunft über die zu seiner Person gespeicherten personenbezogenen Daten und eine Kopie dieser Auskunft zu erhalten.
Ferner hat der Europäische Richtlinien- und Verordnungsgeber der betroffenen Person Auskunft über folgende Informationen zugestanden:
- die Verarbeitungszwecke
- die Kategorien personenbezogener Daten, die verarbeitet werden
- die Empfänger oder Kategorien von Empfängern, gegenüber denen die personenbezogenen Daten offengelegt worden sind oder noch offengelegt werden, insbesondere bei Empfängern in Drittländern oder bei internationalen Organisationen
- falls möglich die geplante Dauer, für die die personenbezogenen Daten gespeichert werden, oder, falls dies nicht möglich ist, die Kriterien für die Festlegung dieser Dauer
- das Bestehen eines Rechts auf Berichtigung oder Löschung der sie betreffenden personenbezogenen Daten oder auf Einschränkung der Verarbeitung durch den Verantwortlichen oder eines Widerspruchsrechts gegen diese Verarbeitung
- das Bestehen eines Beschwerderechts bei einer Aufsichtsbehörde
- wenn die personenbezogenen Daten nicht bei der betroffenen Person erhoben werden: Alle verfügbaren Informationen über die Herkunft der Daten
- das Bestehen einer automatisierten Entscheidungsfindung einschließlich Profiling gemäß Artikel 22 Abs.1 und 4 DSGVO und — zumindest in diesen Fällen — aussagekräftige Informationen über die involvierte Logik sowie die Tragweite und die angestrebten Auswirkungen einer derartigen Verarbeitung für die betroffene Person
Ferner steht der betroffenen Person ein Auskunftsrecht darüber zu, ob personenbezogene Daten an ein Drittland oder an eine internationale Organisation übermittelt wurden.
Sofern dies der Fall ist, so steht der betroffenen Person im Übrigen das Recht zu, Auskunft über die geeigneten Garantien im Zusammenhang mit der Übermittlung zu erhalten.
Möchte eine betroffene Person dieses Auskunftsrecht in Anspruch nehmen, kann sie sich hierzu jederzeit an den für die Verarbeitung Verantwortlichen wenden.
#### c) Recht auf Berichtigung
Jede von der Verarbeitung personenbezogener Daten betroffene Person hat das, vom Europäischen Richtlinien- und Verordnungsgeber gewährte Recht, die unverzügliche Berichtigung sie betreffender unrichtiger personenbezogener Daten zu verlangen.
Ferner steht der betroffenen Person das Recht zu, unter Berücksichtigung der Zwecke der Verarbeitung, die Vervollständigung unvollständiger personenbezogener Daten — auch mittels einer ergänzenden Erklärung — zu verlangen.
Möchte eine betroffene Person dieses Berichtigungsrecht in Anspruch nehmen, kann sie sich hierzu jederzeit an den für die Verarbeitung Verantwortlichen wenden.
#### d) Recht auf Löschung (Recht auf Vergessen werden)
Jede von der Verarbeitung personenbezogener Daten betroffene Person hat das vom Europäischen Richtlinien- und Verordnungsgeber gewährte Recht, von dem Verantwortlichen zu verlangen, dass die sie betreffenden personenbezogenen Daten unverzüglich gelöscht werden, sofern einer der folgenden Gründe zutrifft und soweit die Verarbeitung nicht erforderlich ist:
- Die personenbezogenen Daten wurden für solche Zwecke erhoben oder auf sonstige Weise verarbeitet, für welche sie nicht mehr notwendig sind.
- Die betroffene Person widerruft ihre Einwilligung, auf die sich die Verarbeitung gemäß Art. 6 Abs. 1 Buchstabe a DSGVO oder Art. 9 Abs. 2 Buchstabe a DSGVO stützte, und es fehlt an einer anderweitigen Rechtsgrundlage für die Verarbeitung.
- Die betroffene Person legt gemäß Art. 21 Abs. 1 DSGVO Widerspruch gegen die Verarbeitung ein, und es liegen keine vorrangigen berechtigten Gründe für die Verarbeitung vor, oder die betroffene Person legt gemäß Art. 21 Abs. 2 DSGVO Widerspruch gegen die Verarbeitung ein.
- Die personenbezogenen Daten wurden unrechtmäßig verarbeitet.
- Die Löschung der personenbezogenen Daten ist zur Erfüllung einer rechtlichen Verpflichtung nach dem Unionsrecht oder dem Recht der Mitgliedstaaten erforderlich, dem der Verantwortliche unterliegt.
- Die personenbezogenen Daten wurden in Bezug auf angebotene Dienste der Informationsgesellschaft gemäß Art. 8 Abs. 1 DSGVO erhoben.
Sofern einer der oben genannten Gründe zutrifft und eine betroffene Person die Löschung von personenbezogenen Daten, die beim Projekt BSTIM-Covid19 gespeichert sind, veranlassen möchte, kann sie sich hierzu jederzeit an den für die Verarbeitung Verantwortlichen wenden.
Ein Mitarbeiter des Projekts BSTIM-Covid19 wird veranlassen, dass dem Löschverlangen unverzüglich nachgekommen wird.
Wurden die personenbezogenen Daten vom Projekt BSTIM-Covid19 öffentlich gemacht und ist unser Projekt als Verantwortlicher gemäß Art. 17 Abs. 1 DSGVO zur Löschung der personenbezogenen Daten verpflichtet, so trifft das Projekt BSTIM-Covid19 unter Berücksichtigung der verfügbaren Technologie und der Implementierungskosten angemessene Maßnahmen, auch technischer Art, um andere für die Datenverarbeitung Verantwortliche, welche die veröffentlichten personenbezogenen Daten verarbeiten, darüber in Kenntnis zu setzen, dass die betroffene Person von diesen anderen für die Datenverarbeitung Verantwortlichen die Löschung sämtlicher Links zu diesen personenbezogenen Daten oder von Kopien oder Replikationen dieser personenbezogenen Daten verlangt hat, soweit die Verarbeitung nicht erforderlich ist. Ein Mitarbeiter des Projekts BSTIM-Covid19 wird im Einzelfall das Notwendige veranlassen.
#### e) Recht auf Einschränkung der Verarbeitung
Jede von der Verarbeitung personenbezogener Daten betroffene Person hat das vom Europäischen Richtlinien- und Verordnungsgeber gewährte Recht, von dem Verantwortlichen die Einschränkung der Verarbeitung zu verlangen, wenn eine der folgenden Voraussetzungen gegeben ist:
- Die Richtigkeit der personenbezogenen Daten wird von der betroffenen Person bestritten, und zwar für eine Dauer, die es dem Verantwortlichen ermöglicht, die Richtigkeit der personenbezogenen Daten zu überprüfen.
- Die Verarbeitung ist unrechtmäßig, die betroffene Person lehnt die Löschung der personenbezogenen Daten ab und verlangt stattdessen die Einschränkung der Nutzung der personenbezogenen Daten.
- Der Verantwortliche benötigt die personenbezogenen Daten für die Zwecke der Verarbeitung nicht länger, die betroffene Person benötigt sie jedoch zur Geltendmachung, Ausübung oder Verteidigung von Rechtsansprüchen.
- Die betroffene Person hat Widerspruch gegen die Verarbeitung gem. Art. 21 Abs. 1 DSGVO eingelegt und es steht noch nicht fest, ob die berechtigten Gründe des Verantwortlichen gegenüber denen der betroffenen Person überwiegen.
Sofern eine der oben genannten Voraussetzungen gegeben ist und eine betroffene Person die Einschränkung von personenbezogenen Daten, die beim Projekt BSTIM-Covid19 gespeichert sind, verlangen möchte, kann sie sich hierzu jederzeit an den für die Verarbeitung Verantwortlichen wenden. Ein Mitarbeiter des Projekts BSTIM-Covid19 wird die Einschränkung der Verarbeitung veranlassen.
#### f) Recht auf Datenübertragbarkeit
Jede von der Verarbeitung personenbezogener Daten betroffene Person hat das vom Europäischen Richtlinien- und Verordnungsgeber gewährte Recht, die sie betreffenden personenbezogenen Daten, welche durch die betroffene Person einem Verantwortlichen bereitgestellt wurden, in einem strukturierten, gängigen und maschinenlesbaren Format zu erhalten. Sie hat außerdem das Recht, diese Daten einem anderen Verantwortlichen ohne Behinderung durch den Verantwortlichen, dem die personenbezogenen Daten bereitgestellt wurden, zu übermitteln, sofern die Verarbeitung auf der Einwilligung gemäß Art. 6 Abs. 1 Buchstabe a DSGVO oder Art. 9 Abs. 2 Buchstabe a DSGVO oder auf einem Vertrag gemäß Art. 6 Abs. 1 Buchstabe b DSGVO beruht und die Verarbeitung mithilfe automatisierter Verfahren erfolgt, sofern die Verarbeitung nicht für die Wahrnehmung einer Aufgabe erforderlich ist, die im öffentlichen Interesse liegt oder in Ausübung öffentlicher Gewalt erfolgt, welche dem Verantwortlichen übertragen wurde.
Ferner hat die betroffene Person bei der Ausübung ihres Rechts auf Datenübertragbarkeit gemäß Art. 20 Abs. 1 DSGVO das Recht, zu erwirken, dass die personenbezogenen Daten direkt von einem Verantwortlichen an einen anderen Verantwortlichen übermittelt werden, soweit dies technisch machbar ist und sofern hiervon nicht die Rechte und Freiheiten anderer Personen beeinträchtigt werden.
Zur Geltendmachung des Rechts auf Datenübertragbarkeit kann sich die betroffene Person jederzeit an den für die Verarbeitung Verantwortlichen des Projekts BSTIM-Covid19 wenden.
#### g) Recht auf Widerspruch
Jede von der Verarbeitung personenbezogener Daten betroffene Person hat das vom Europäischen Richtlinien- und Verordnungsgeber gewährte Recht, aus Gründen, die sich aus ihrer besonderen Situation ergeben, jederzeit gegen die Verarbeitung sie betreffender personenbezogener Daten, die aufgrund von Art. 6 Abs. 1 Buchstaben e oder f DSGVO erfolgt, Widerspruch einzulegen. Dies gilt auch für ein auf diese Bestimmungen gestütztes Profiling.
Das Projekt BSTIM-Covid19 verarbeitet die personenbezogenen Daten im Falle des Widerspruchs nicht mehr, es sei denn, wir können zwingende schutzwürdige Gründe für die Verarbeitung nachweisen, die den Interessen, Rechten und Freiheiten der betroffenen Person überwiegen, oder die Verarbeitung dient der Geltendmachung, Ausübung oder Verteidigung von Rechtsansprüchen.
Zudem hat die betroffene Person das Recht, aus Gründen, die sich aus ihrer besonderen Situation ergeben, gegen die sie betreffende Verarbeitung personenbezogener Daten, die beim Projekt BSTIM-Covid19 zu wissenschaftlichen oder historischen Forschungszwecken oder zu statistischen Zwecken gemäß Art. 89 Abs. 1 DSGVO erfolgen, Widerspruch einzulegen, es sei denn, eine solche Verarbeitung ist zur Erfüllung einer im öffentlichen Interesse liegenden Aufgabe erforderlich.
Zur Ausübung des Rechts auf Widerspruch kann sich die betroffene Person direkt an den für die Verarbeitung Verantwortlichen des Projekts BSTIM-Covid19 wenden.
Der betroffenen Person steht es ferner frei, im Zusammenhang mit der Nutzung von Diensten der Informationsgesellschaft, ungeachtet der Richtlinie 2002/58/EG, ihr Widerspruchsrecht mittels automatisierter Verfahren auszuüben, bei denen technische Spezifikationen verwendet werden.
#### h) Automatisierte Entscheidungen im Einzelfall einschließlich Profiling
Jede von der Verarbeitung personenbezogener Daten betroffene Person hat das vom Europäischen Richtlinien- und Verordnungsgeber gewährte Recht, nicht einer ausschließlich auf einer automatisierten Verarbeitung — einschließlich Profiling — beruhenden Entscheidung unterworfen zu werden, die ihr gegenüber rechtliche Wirkung entfaltet oder sie in ähnlicher Weise erheblich beeinträchtigt, sofern die Entscheidung
(1) nicht für den Abschluss oder die Erfüllung eines Vertrags zwischen der betroffenen Person und dem Verantwortlichen erforderlich ist, oder
(2) aufgrund von Rechtsvorschriften der Union oder der Mitgliedstaaten, denen der Verantwortliche unterliegt, zulässig ist und diese Rechtsvorschriften angemessene Maßnahmen zur Wahrung der Rechte und Freiheiten sowie der berechtigten Interessen der betroffenen Person enthalten oder
(3) mit ausdrücklicher Einwilligung der betroffenen Person erfolgt.
Ist die Entscheidung
(1) für den Abschluss oder die Erfüllung eines Vertrags zwischen der betroffenen Person und dem Verantwortlichen erforderlich oder
(2) erfolgt sie mit ausdrücklicher Einwilligung der betroffenen Person, trifft das Projekt BSTIM-Covid19 angemessene Maßnahmen, um die Rechte und Freiheiten sowie die berechtigten Interessen der betroffenen Person zu wahren, wozu mindestens das Recht auf Erwirkung des Eingreifens einer Person seitens des Verantwortlichen, auf Darlegung des eigenen Standpunkts und auf Anfechtung der Entscheidung gehört.
Möchte die betroffene Person Rechte mit Bezug auf automatisierte Entscheidungen geltend machen, kann sie sich hierzu jederzeit an den für die Verarbeitung Verantwortlichen wenden.
#### i) Recht auf Widerruf einer datenschutzrechtlichen Einwilligung
Jede von der Verarbeitung personenbezogener Daten betroffene Person hat das vom Europäischen Richtlinien- und Verordnungsgeber gewährte Recht, eine Einwilligung zur Verarbeitung personenbezogener Daten jederzeit zu widerrufen.
Möchte die betroffene Person ihr Recht auf Widerruf einer Einwilligung geltend machen, kann sie sich hierzu jederzeit an den für die Verarbeitung Verantwortlichen wenden.
Unbeschadet eines anderweitigen verwaltungsrechtlichen oder gerichtlichen Rechtsbehelfs steht Ihnen das Recht auf Beschwerde bei einer Aufsichtsbehörde, insbesondere in dem Mitgliedstaat ihres Aufenthaltsorts, ihres Arbeitsplatzes oder des Orts des mutmaßlichen Verstoßes, zu, wenn Sie der Ansicht sind, dass die Verarbeitung der Sie betreffenden personenbezogenen Daten gegen die DSGVO verstößt.
### 9. Rechtsgrundlage der Verarbeitung
Art. 6 I lit. a DSGVO dient unserem Projekt als Rechtsgrundlage für Verarbeitungsvorgänge, bei denen wir eine Einwilligung für einen bestimmten Verarbeitungszweck einholen.
Ist die Verarbeitung personenbezogener Daten zur Erfüllung eines Vertrags, dessen Vertragspartei die betroffene Person ist, erforderlich, wie dies beispielsweise bei Verarbeitungsvorgängen der Fall ist, die für eine Lieferung von Waren oder die Erbringung einer sonstigen Leistung oder Gegenleistung notwendig sind, so beruht die Verarbeitung auf Art. 6 I lit. b DSGVO. Gleiches gilt für solche Verarbeitungsvorgänge die zur Durchführung vorvertraglicher Maßnahmen erforderlich sind, etwa in Fällen von Anfragen zur unseren Produkten oder Leistungen.
Unterliegt unser Projekt einer rechtlichen Verpflichtung durch welche eine Verarbeitung von personenbezogenen Daten erforderlich wird, wie beispielsweise zur Erfüllung steuerlicher Pflichten, so basiert die Verarbeitung auf Art. 6 I lit. c DSGVO.
In seltenen Fällen könnte die Verarbeitung von personenbezogenen Daten erforderlich werden, um lebenswichtige Interessen der betroffenen Person oder einer anderen natürlichen Person zu schützen.
Dies wäre beispielsweise der Fall, wenn ein Besucher in unserem Betrieb verletzt werden würde und daraufhin sein Name, sein Alter, seine Krankenkassendaten oder sonstige lebenswichtige Informationen an einen Arzt, ein Krankenhaus oder sonstige Dritte weitergegeben werden müssten.
Dann würde die Verarbeitung auf Art. 6 I lit. d DSGVO beruhen. Letztlich könnten Verarbeitungsvorgänge auf Art. 6 I lit. f DSGVO beruhen.
Auf dieser Rechtsgrundlage basieren Verarbeitungsvorgänge, die von keiner der vorgenannten Rechtsgrundlagen erfasst werden, wenn die Verarbeitung zur Wahrung eines berechtigten Interesses unseres Projekts oder eines Dritten erforderlich ist, sofern die Interessen, Grundrechte und Grundfreiheiten des Betroffenen nicht überwiegen. Solche Verarbeitungsvorgänge sind uns insbesondere deshalb gestattet, weil sie durch den Europäischen Gesetzgeber besonders erwähnt wurden.
Er vertrat insoweit die Auffassung, dass ein berechtigtes Interesse anzunehmen sein könnte, wenn die betroffene Person ein Kunde des Verantwortlichen ist (Erwägungsgrund 47 Satz 2 DSGVO).
### 10. Berechtigte Interessen an der Verarbeitung, die von dem Verantwortlichen oder einem Dritten verfolgt werden
Basiert die Verarbeitung personenbezogener Daten auf Artikel 6 I lit. f DSGVO ist unser berechtigtes Interesse die Durchführung unserer Geschäftstätigkeit zugunsten des Wohlergehens all unserer Mitarbeiter und unserer Anteilseigner.
### 11. Dauer, für die die personenbezogenen Daten gespeichert werden
Das Kriterium für die Dauer der Speicherung von personenbezogenen Daten ist die jeweilige gesetzliche Aufbewahrungsfrist. Nach Ablauf der Frist werden die entsprechenden Daten routinemäßig gelöscht, sofern sie nicht mehr zur Vertragserfüllung oder Vertragsanbahnung erforderlich sind.
### 12. Gesetzliche oder vertragliche Vorschriften zur Bereitstellung der personenbezogenen Daten; Erforderlichkeit für den Vertragsabschluss; Verpflichtung der betroffenen Person, die personenbezogenen Daten bereitzustellen; mögliche Folgen der Nichtbereitstellung
Wir klären Sie darüber auf, dass die Bereitstellung personenbezogener Daten zum Teil gesetzlich vorgeschrieben ist (z.B. Steuervorschriften) oder sich auch aus vertraglichen Regelungen (z.B. Angaben zum Vertragspartner) ergeben kann.
Mitunter kann es zu einem Vertragsschluss erforderlich sein, dass eine betroffene Person uns personenbezogene Daten zur Verfügung stellt, die in der Folge durch uns verarbeitet werden müssen.
Die betroffene Person ist beispielsweise verpflichtet uns personenbezogene Daten bereitzustellen, wenn unser Projekt mit ihr einen Vertrag abschließt. Eine Nichtbereitstellung der personenbezogenen Daten hätte zur Folge, dass der Vertrag mit dem Betroffenen nicht geschlossen werden könnte.
Vor einer Bereitstellung personenbezogener Daten durch den Betroffenen muss sich der Betroffene an einen unserer Mitarbeiter wenden.
Unser Mitarbeiter klärt den Betroffenen einzelfallbezogen darüber auf, ob die Bereitstellung der personenbezogenen Daten gesetzlich oder vertraglich vorgeschrieben oder für den Vertragsabschluss erforderlich ist, ob eine Verpflichtung besteht, die personenbezogenen Daten bereitzustellen, und welche Folgen die Nichtbereitstellung der personenbezogenen Daten hätte.
### 13. Datenschutzbestimmungen zu Einsatz und Verwendung von YouTube
Der für die Verarbeitung Verantwortliche hat auf dieser Internetseite Komponenten von YouTube integriert. YouTube ist ein Internet-Videoportal, dass Video-Publishern das kostenlose Einstellen von Videoclips und anderen Nutzern die ebenfalls kostenfreie Betrachtung, Bewertung und Kommentierung dieser ermöglicht.
YouTube gestattet die Publikation aller Arten von Videos, weshalb sowohl komplette Film- und Fernsehsendungen, aber auch Musikvideos, Trailer oder von Nutzern selbst angefertigte Videos über das Internetportal abrufbar sind.
Betreibergesellschaft von YouTube ist die YouTube, LLC, 901 Cherry Ave., San Bruno, CA 94066, USA. Die YouTube, LLC ist einer Tochtergesellschaft der Google Inc., 1600 Amphitheatre Pkwy, Mountain View, CA 94043-1351, USA.
Durch jeden Aufruf einer der Einzelseiten dieser Internetseite, die durch den für die Verarbeitung Verantwortlichen betrieben wird und auf welcher eine YouTube-Komponente (YouTube-Video) integriert wurde, wird der Internetbrowser auf dem informationstechnologischen System der betroffenen Person automatisch durch die jeweilige YouTube-Komponente veranlasst, eine Darstellung der entsprechenden YouTube-Komponente von YouTube herunterzuladen. Weitere Informationen zu YouTube können unter [https://www.youtube.com/yt/about/de/](https://www.youtube.com/yt/about/de/) abgerufen werden.
Im Rahmen dieses technischen Verfahrens erhalten YouTube und Google Kenntnis darüber, welche konkrete Unterseite unserer Internetseite durch die betroffene Person besucht wird.
Sofern die betroffene Person gleichzeitig bei YouTube eingeloggt ist, erkennt YouTube mit dem Aufruf einer Unterseite, die ein YouTube-Video enthält, welche konkrete Unterseite unserer Internetseite die betroffene Person besucht.
Diese Informationen werden durch YouTube und Google gesammelt und dem jeweiligen YouTube-Account der betroffenen Person zugeordnet.
YouTube und Google erhalten über die YouTube-Komponente immer dann eine Information darüber, dass die betroffene Person unsere Internetseite besucht hat, wenn die betroffene Person zum Zeitpunkt des Aufrufs unserer Internetseite gleichzeitig bei YouTube eingeloggt ist; dies findet unabhängig davon statt, ob die betroffene Person ein YouTube-Video anklickt oder nicht.
Ist eine derartige Übermittlung dieser Informationen an YouTube und Google von der betroffenen Person nicht gewollt, kann diese die Übermittlung dadurch verhindern, dass sie sich vor einem Aufruf unserer Internetseite aus ihrem YouTube-Account ausloggt.
Die von YouTube veröffentlichten Datenschutzbestimmungen, die unter [https://www.google.de/intl/de/policies/privacy/](https://www.google.de/intl/de/policies/privacy/) abrufbar sind, geben Aufschluss über die Erhebung, Verarbeitung und Nutzung personenbezogener Daten durch YouTube und Google.
### 14. Bestehen einer automatisierten Entscheidungsfindung
Als verantwortungsbewusstes Projekt verzichten wir auf eine automatische Entscheidungsfindung oder ein Profiling.
### 15. Anpassung der Datenschutzerklärung
Wir behalten uns vor, diese Datenschutzerklärung von Zeit zu Zeit zu aktualisieren. Aktualisierungen dieser Datenschutzerklärung werden auf unserer Website veröffentlicht.
Änderungen gelten ab ihrer Publikation auf unserer Website. Wir empfehlen Ihnen daher, diese Seite regelmäßig zu besuchen, um sich über gegebenenfalls erfolgte Aktualisierungen zu informieren.
Diese Datenschutzerklärung wurde durch den Datenschutzerklärungs-Generator von ["Datenschutzbeauftragter Dresden"](https://dg-datenschutz.de/) in Kooperation mit der [RC GmbH](http://remarketing.company), die gebrauchte Notebooks wiederverwertet und den [Filesharing Rechtsanwälten von WBS-LAW](https://www.wbs-law.de/abmahnung-filesharing/) erstellt.
"""
),
]
),
dbc.ModalFooter(
dbc.Button("Schließen", id="datenschutz_modal_close", className="ml-auto")
),
],
),
]
)
@app.callback(
Output("datenschutz_modal", "is_open"),
[Input("datenschutz_modal_open", "n_clicks"), Input("datenschutz_modal_close", "n_clicks")],
[State("datenschutz_modal", "is_open")],
)
def toggle_modal(n1, n2, is_open):
if n1 or n2:
return not is_open
return is_open
#####################
# Header and Footer (main)
#####################
# https://dash-bootstrap-components.opensource.faculty.ai/docs/components/navbar/
navbar = dbc.NavbarSimple(
brand="Bayessches räumlich-zeitliches Interaktionsmodell für Covid-19",
brand_href="#",
color="dark",
fixed="top",
dark=True,
children=[
dbc.NavItem(
dbc.Button(
"Fragen & Antworten",
color="primary",
href="/faq" #"https://jupyter-jsc.fz-juelich.de/nbviewer/github/neuroinfo-os/BSTIM-Covid19/blob/master/notebooks/FragenAntworten.ipynb"
)
),
dbc.NavItem(
dbc.NavLink(
"Quellcode",
href="https://github.com/neuroinfo-os/BSTIM-Covid19",
)
),
])
faq_navbar = dbc.NavbarSimple(
brand="Bayessches räumlich-zeitliches Interaktionsmodell für Covid-19",
brand_href="#",
color="dark",
fixed="top",
dark=True,
children=[
dbc.NavItem(
dbc.Button(
"Dashboard",
color="primary",
href="/" #"https://jupyter-jsc.fz-juelich.de/nbviewer/github/neuroinfo-os/BSTIM-Covid19/blob/master/notebooks/FragenAntworten.ipynb"
)
),
dbc.NavItem(
dbc.NavLink(
"Quellcode",
href="https://github.com/neuroinfo-os/BSTIM-Covid19",
)
),
])
navbar_footer = dbc.NavbarSimple(
#brand="",
brand_href="#",
color="light",
#fixed="bottom",
#sticky=True,
#dark=True,
children=[
dbc.NavItem(impressum_modal),
dbc.NavItem(datenschutz_modal),
])
#####################
# Interpretationshilfen
#####################
ikernel_inter1_modal = html.Div(
[
dbc.Modal(
id="ikernel_inter1_modal",
size="xl",
children=[
dbc.ModalHeader("Interpretationshilfe"),
dbc.ModalBody(
children=[
dbc.Col(
children = [
html.Img(
src=asset_url + "ikernel-1.png",
style={'width':'80%', 'height':'80%'},
),
],
width={"size": 4, "offset": 8},
),
dcc.Markdown(
f"""
### Eigenschaften des Bildes
Eine rote intensive Farbe zeigt einen deutlichen Einfluss von Infektionen auf die Infektionsrate an.
Die rote Farbe zeigt, dass es sich um eine verstärkende Interaktion handelt, die die Infektionsrate anhebt.
Dieser Effekt ist hier räumlich auf die direkte Umgebung mit 0-10km und zeitlich auf eine Zeitspanne von 2-4 Tagen Verzögerung begrenzt.
### Interpretationshilfe
Solch ein Muster kann auf eine starke lokale Ausbreitung hindeuten, bei der Menschen sich verstärkt in der direkten Umgebung (0-10km) anstecken und diese Ansteckung mit einer Verzögerung von 2-4 Tagen zu einer gemeldeten Erkrankung führt.
**Achtung:**
Die Farbe zeigt nicht an, ob die Anzahl an Infektionen in der Region tatsächlich zu oder abnimmt, sondern einen lokalen Effekt der Beeinflussung.
Um die absolute Zu- oder Abnahme erkennen zu können muss zusätzlich die Vorhersage im Nowcast und Forecast genutzt werden.
"""
),
]
),
dbc.ModalFooter(
dbc.Button("Schließen", id="ikernel_inter1_modal_close", className="ml-auto")
),
],
),
]
)
ikernel_inter2_modal = html.Div(
[
dbc.Modal(
id="ikernel_inter2_modal",
size="xl",
children=[
dbc.ModalHeader("Interpretationshilfe"),
dbc.ModalBody(
children=[
dbc.Col(
children = [
html.Img(
src=asset_url + "ikernel-2.png",
style={'width':'80%', 'height':'80%'},
),
],
width={"size": 4, "offset": 8},
),
dcc.Markdown(
f"""
### Eigenschaften des Bildes
Eine schwache rote Farbe zeigt einen schwachen Einfluss von Infektionen auf die Infektionsrate an.
Die schwache Farbe zeigt, dass es sich um eine schwache Interaktion handelt, die die Infektionsrate nur schwach beeinflusst.
Dieser Effekt ist hier räumlich auf eine weitere Umgebung mit bis zu 0-30km begrenzt und tritt zeitlich durchgehen in der Zeitspanne von 0-5 Tagen auf.
### Interpretationshilfe
Die schwache Farbe zeigt eine schwache Anhebung der Infektionszahlen durch Menschen in der Umgebung an.
Die große Breite und der andauernde Effekt über die gesamten 5 Tage deuten auf eine Anhebung hin, die sich über einige Landkreise hinweg erstreckt und stärker als der Bundesdurchschnitt ist.
**Achtung:**
Die Farbe zeigt nicht an, ob die Anzahl an Infektionen tatsächlich zu oder abnimmt, sondern eine lokalen Effekt der Beeinflussung.
Um die absolute Zu- oder Abnahme erkennen zu können muss zusätzlich die Vorhersage im Nowcast und Forecast genutzt werden.
"""
),
]
),
dbc.ModalFooter(
dbc.Button("Schließen", id="ikernel_inter2_modal_close", className="ml-auto")
),
],
),
]
)
ikernel_inter3_modal = html.Div(
[
dbc.Modal(
id="ikernel_inter3_modal",
size="xl",
children=[
dbc.ModalHeader("Interpretationshilfe"),
dbc.ModalBody(
children=[
dbc.Col(
children = [
html.Img(
src=asset_url + "ikernel-3.png",
style={'width':'100%', 'height':'100%'},
),
],
width={"size": 4, "offset": 8},
),
dcc.Markdown(
f"""
### Eigenschaften des Bildes
Mittlere rote Farben und blaue Farben zeigen einen kleineren Einfluss von Infektionen auf die Infektionsrate an.
Die mittlere rote Farbe zeigt an, dass Infektionen in der Umgebung die Infektionsrate lokal anheben.
Die mittlere blaue Farbe zeigt an, dass die Infektionen in der Umgebung die Infektionsrate lokal absenken.
Beide Effekte sind lokal auf 0-10km begrenzt und treten mit einer zeitlichen Verzögerung auf.
### Interpretationshilfe
Die mittlere Farbe zeigt eine schwache Anhebung bzw. Absenkung der Infektionszahlen durch Menschen in der Umgebung an.
Aufeinanderfolgende rote und blaue Bereich können auf eine Kette von Ereignissen hindeuten.
So kann zum Beispiel dieses Muster auf eine lokalen Verzögerung oder Verschiebung der Meldeergebnisse zurückgeführt werden.
Die erhöhte rote Infektionsrate kann also das Ergebnis von „Nachmeldungen“ sein.
**Achtung:**
Die Farbe zeigt nicht an, ob die tatsächliche Anzahl an Infektionen zu oder abnimmt, sondern eine lokalen Effekt der Beeinflussung.
Um die absolute Zu- oder Abnahme erkennen zu können muss zusätzlich die Vorhersage im Nowcast und Forecast genutzt werden.
"""
),
]
),
dbc.ModalFooter(
dbc.Button("Schließen", id="ikernel_inter3_modal_close", className="ml-auto")
),
],
),
]
)
#####################
# Date-Tabs (left)
#####################
left_date_tab1 = dbc.Card(
outline=True,
color="light",
className="mt-3",
children=[ dbc.CardBody(
style={ 'padding': 0, },
children=[
html.Div(
id="left_date_tab1_img_div",
children=[
dcc.Loading(
id = "left_date_tab1_loading_graph",
children=[html.Div(children=[
dcc.Graph(id='left_date_tab1_graph', figure=init_mapfig_bstim, style={'width':'100%', 'height':'100%','display':'inline-block'}),
])],
type="circle", # 'graph', 'cube', 'circle', 'dot', 'default'
color="#343A40",
style={'hight':'450px'},
),
]),
]),
])
left_date_tab2_modal = html.Div(
[
dbc.Button("Vergrößern", id="left_date_tab2_modal_open", outline=True, color="secondary", className="mr-1"),
dbc.Modal(
id="left_date_tab2_modal",
size="xl",
children=[
dbc.ModalHeader("Interaktionskernel"),
dbc.ModalBody(
children=[
html.Img(
id="left_date_modal2_img",
src=asset_url + "figures/" + init_date.strftime('%Y_%m_%d') + "/interaction_kernel.png",
style={'width':'100%', 'height':'100%'},
),
]
),
dbc.ModalFooter(
dbc.Button("Schließen", id="left_date_tab2_modal_close", className="ml-auto")
),
],
),
]
)
left_date_tab2 = dbc.Card(
outline=True,
color="light",
className="mt-3",
children=[ dbc.CardBody(
children=[
html.Div(
id="left_date_tab2_img_div",
children=[
left_date_tab2_modal,
dcc.Loading(
id = "left_date_tab2_loading_img",
children=[html.Div(children=[
html.Img(
id="left_date_tab2_img",
src=asset_url + "figures/" + init_date.strftime('%Y_%m_%d') + "/interaction_kernel.png",
style={'width':'100%', 'height':'100%'},
),
])],
type="circle", # 'graph', 'cube', 'circle', 'dot', 'default'
color="#343A40",
style={'hight':'450px'},
),
dbc.Tooltip(
"Der Interaktionskernel schätzt ab um wie stark eine gemeldete Infektion eine Neuansteckung in den nächsten Tagen "
"in einem Umkreis von bis zu 50km beeinflusst. "
"Diese Interaktion ist ein zusätzlicher Faktor der den Trend in einem Landkreis verstärkt oder abschwächt. "
"Eine warme Farbe indiziert, dass eine Covid-19 Meldung eine erhöhte Wahrscheinlichkeit einer Neuinfektion "
"im Verhältnis zum Trend zur Folge hat. "
"Eine starke Farben in der Nähe kleiner Radien bedeutet, dass das Infektionsgeschehen vor allem Auswirkungen "
"in der direkten Nähe der gemeldeten Fälle zur Folge hat. "
"Die Interaktion basiert auf einer Schätzung der Bevölkerungsdichte und der Form der Landkreise. "
"Daten zu den Wohnorten der Infizierten werden in dem Model nicht genutzt. "
"Alle hier genutzten Daten sind vollständig anonymisiert (siehe Erklärvideo). "
"Bei der Interpretation der Interaktionskernel ist dies zu berücksichtigen, und wir weisen darauf hin, dass dies nur eine Schätzung ist "
"die von der Realität abweichen kann.",
target="left_date_tab2_img",
style={"width": "200%"},
placement="left",
),
]),
html.Div(
children = [
dbc.Row(
dbc.Col(
html.Div("Klick ähnliche Darstellung für Interpretationshilfe:"),
width={"size": 11, "offset": 1},
)
),
dbc.Row(
children = [
dbc.Col(
children = [
html.Div(
id="left_date_tab2_ikernel1_div",
children = [
html.Img(
id="left_date_tab2_ikernel1",
src=asset_url + "ikernel-1-border.png",
style={'width':'80%', 'height':'80%'},
),
],
),
],
width={"size": 3, "offset": 1},
),
dbc.Col(
children = [
html.Div(
id="left_date_tab2_ikernel2_div",
children = [
html.Img(
id="left_date_tab2_ikernel2",
src=asset_url + "ikernel-2-border.png",
style={'width':'80%', 'height':'80%'},
),
],
),
],
width={"size": 3, "offset": 1},
),
dbc.Col(
children = [
html.Div(
id="left_date_tab2_ikernel3_div",
children = [
html.Img(
id="left_date_tab2_ikernel3",
src=asset_url + "ikernel-3-border.png",
style={'width':'80%', 'height':'80%'},
),
],
),
],
width={"size": 3, "offset": 1},
),
],
),
],
),
]),
])
left_date_tab3 = dbc.Card(
outline=True,
color="light",
className="mt-3",
children=[ dbc.CardBody(
style={ 'padding': 0, },
children=[
html.Div(
id="left_date_tab3_img_div",
children=[
dcc.Loading(
id = "left_date_tab3_loading_graph",
children=[html.Div(children=[
dcc.Graph(id='left_date_tab3_graph', figure=init_mapfig_rki, style={'width':'100%', 'height':'100%','display':'inline-block'}),
])],
type="circle", # 'graph', 'cube', 'circle', 'dot', 'default'
color="#343A40",
style={'hight':'450px'},
),
]),
]),
])
@app.callback(
Output("left_date_tab2_modal", "is_open"),
[Input("left_date_tab2_img_div", "n_clicks"), Input("left_date_tab2_modal_open", "n_clicks"), Input("left_date_tab2_modal_close", "n_clicks")],
[State("left_date_tab2_modal", "is_open")],
)
def toggle_modal(n1, n2, n3, is_open):
if n1 or n2 or n3:
return not is_open
return is_open
#####################
# Date-Window Picker (left)
#####################
left_date_controls = dbc.FormGroup(
children=[
dbc.Label(
id='left_date-label',
children=["Vorhersagebeginn:"],
),
html.Div(
children=[
dcc.DatePickerSingle(
id='left_date-picker',
style={'width':'100%'},
display_format='DD. MMM YYYY',
min_date_allowed=min_date,
max_date_allowed=max_date,
initial_visible_month=init_date,
date=init_date +timedelta(days=deltadays),
),
html.Div(
id='left_output-container-date-picker',
style={'display': 'none'},
children=[(init_date +timedelta(days=deltadays)).strftime('%Y_%m_%d')],
),
]),
dbc.Label(
id='left_date-label2',
children=["(auf Basis der Daten des vorherigen 3-Wochenfensters)"],
),
])
# Date Picker
@app.callback(
Output(component_id='left_output-container-date-picker', component_property='children'),
[Input(component_id='left_date-picker', component_property='date')])
def update_left_date_picker(date):
if date is not None:
return get_assets_dir(date)
else:
return init_assets_dir
# Interactive Map
@app.callback(
Output(component_id='left_date_tab1_graph', component_property='figure'),
[Input(component_id='left_date-picker', component_property='date')])
@cache.memoize(timeout=cache_timeout)
def update_left_date_tab1_map(date):
if date is not None:
assets_dir = get_assets_dir(date)
mapfig = create_map("assets/figures/" + assets_dir + "/map.csv", 'newInf100k')
else:
mapfig = create_map("assets/placeholders/map_empty.csv", 'newInf100k')
return mapfig
# Interaction Kernel
@app.callback(
[Output(component_id='left_date_tab2_img', component_property='src'),
Output(component_id='left_date_modal2_img', component_property='src')],
[Input(component_id='left_date-picker', component_property='date')])
def update_left_date_tab2_img(date):
imgUrl=""
if date is not None:
assets_dir = get_assets_dir(date)
imgUrl = "figures/" + assets_dir + "interaction_kernel.png"
if not os.path.isfile("assets/" + imgUrl):
imgUrl = "placeholders/plot_not_found.png"
imgUrl = asset_url + imgUrl
return imgUrl, imgUrl
# Interactive Map - RKI
@app.callback(
Output(component_id='left_date_tab3_graph', component_property='figure'),
[Input(component_id='left_date-picker', component_property='date')])
@cache.memoize(timeout=cache_timeout)
def update_left_date_tab3_map(date):
if date is not None:
assets_dir = get_assets_dir(date)
mapfig = create_map("assets/figures/" + assets_dir + "/map.csv", 'newInf100k_RKI')
else:
mapfig = create_map("assets/placeholders/map_empty.csv", 'newInf100k')
return mapfig
#####################
# Date-Tabs (right)
#####################
right_date_tab1 = dbc.Card(
outline=True,
color="light",
className="mt-3",
children=[ dbc.CardBody(
style={ 'padding': 0, },
children=[
html.Div(
id="right_date_tab1_img_div",
children=[
dcc.Loading(
id = "right_date_tab1_loading_graph",
children=[html.Div(children=[
dcc.Graph(id='right_date_tab1_graph', figure=init_mapfig_bstim, style={'width':'100%', 'height':'100%','display':'inline-block'}),
])],
type="circle", # 'graph', 'cube', 'circle', 'dot', 'default'
color="#343A40",
style={'hight':'450px'},
),
]),
]),
])
right_date_tab2_modal = html.Div(
[
dbc.Button("Vergrößern", id="right_date_tab2_modal_open", outline=True, color="secondary", className="mr-1"),
dbc.Modal(
id="right_date_tab2_modal",
size="xl",
children=[
dbc.ModalHeader("Interaktionskernel"),
dbc.ModalBody(
children=[
html.Img(
id="right_date_modal2_img",
src=asset_url + "figures/" + init_date.strftime('%Y_%m_%d') + "/interaction_kernel.png",
style={'width':'100%', 'height':'100%'},
),
]
),
dbc.ModalFooter(
dbc.Button("Schließen", id="right_date_tab2_modal_close", className="ml-auto")
),
],
),
]
)
right_date_tab2 = dbc.Card(
outline=True,
color="light",
className="mt-3",
children=[ dbc.CardBody(
children=[
html.Div(
id="right_date_tab2_img_div",
children=[
right_date_tab2_modal,
dcc.Loading(
id = "right_date_tab2_loading_img",
children=[html.Div(children=[
html.Img(
id="right_date_tab2_img",
src=asset_url + "figures/" + init_date.strftime('%Y_%m_%d') + "/interaction_kernel.png",
style={'width':'100%', 'height':'100%'},
),
])],
type="circle", # 'graph', 'cube', 'circle', 'dot', 'default'
color="#343A40",
style={'hight':'450px'},
),
dbc.Tooltip(
"Der Interaktionskernel schätzt ab um wie stark eine gemeldete Infektion eine Neuansteckung in den nächsten Tagen "
"in einem Umkreis von bis zu 50km beeinflusst. "
"Diese Interaktion ist ein zusätzlicher Faktor der den Trend in einem Landkreis verstärkt oder abschwächt. "
"Eine warme Farbe indiziert, dass eine Covid-19 Meldung eine erhöhte Wahrscheinlichkeit einer Neuinfektion "
"im Verhältnis zum Trend zur Folge hat. "
"Eine starke Farben in der Nähe kleiner Radien bedeutet, dass das Infektionsgeschehen vor allem Auswirkungen "
"in der direkten Nähe der gemeldeten Fälle zur Folge hat. "
"Die Interaktion basiert auf einer Schätzung der Bevölkerungsdichte und der Form der Landkreise. "
"Daten zu den Wohnorten der Infizierten werden in dem Model nicht genutzt. "
"Alle hier genutzten Daten sind vollständig anonymisiert (siehe Erklärvideo). "
"Bei der Interpretation der Interaktionskernel ist dies zu berücksichtigen, und wir weisen darauf hin, dass dies nur eine Schätzung ist "
"die von der Realität abweichen kann.",
target="right_date_tab2_img",
style={"width": "200%"},
placement="right",
),
]),
html.Div(
children = [
dbc.Row(
dbc.Col(
html.Div("Klick ähnliche Darstellung für Interpretationshilfe:"),
width={"size": 11, "offset": 1},
)
),
dbc.Row(
children = [
dbc.Col(
children = [
html.Div(
id="right_date_tab2_ikernel1_div",
children = [
html.Img(
id="right_date_tab2_ikernel1",
src=asset_url + "ikernel-1-border.png",
style={'width':'80%', 'height':'80%'},
),
],
),
],
width={"size": 3, "offset": 1},
),
dbc.Col(
children = [
html.Div(
id="right_date_tab2_ikernel2_div",
children = [
html.Img(
id="right_date_tab2_ikernel2",
src=asset_url + "ikernel-2-border.png",
style={'width':'80%', 'height':'80%'},
),
],
),
],
width={"size": 3, "offset": 1},
),
dbc.Col(
children = [
html.Div(
id="right_date_tab2_ikernel3_div",
children = [
html.Img(
id="right_date_tab2_ikernel3",
src=asset_url + "ikernel-3-border.png",
style={'width':'80%', 'height':'80%'},
),
],
),
],
width={"size": 3, "offset": 1},
),
],
),
],
),
]),
])
right_date_tab3 = dbc.Card(
outline=True,
color="light",
className="mt-3",
children=[ dbc.CardBody(
style={ 'padding': 0, },
children=[
html.Div(
id="right_date_tab3_img_div",
children=[
dcc.Loading(
id = "right_date_tab3_loading_graph",
children=[html.Div(children=[
dcc.Graph(id='right_date_tab3_graph', figure=init_mapfig_rki, style={'width':'100%', 'height':'100%','display':'inline-block'}),
])],
type="circle", # 'graph', 'cube', 'circle', 'dot', 'default'
color="#343A40",
style={'hight':'450px'},
),
]),
]),
])
@app.callback(
Output("right_date_tab2_modal", "is_open"),
[Input("right_date_tab2_img_div", "n_clicks"), Input("right_date_tab2_modal_open", "n_clicks"), Input("right_date_tab2_modal_close", "n_clicks")],
[State("right_date_tab2_modal", "is_open")],
)
def toggle_modal(n1, n2, n3, is_open):
if n1 or n2 or n3:
return not is_open
return is_open
#####################
# callbacks für Interpretationshilfen
#####################
@app.callback(
Output("ikernel_inter1_modal", "is_open"),
[Input("left_date_tab2_ikernel1_div", "n_clicks"), Input("right_date_tab2_ikernel1_div", "n_clicks"), Input("ikernel_inter1_modal_close", "n_clicks")],
[State("ikernel_inter1_modal", "is_open")],
)
def toggle_modal(n1, n2, n3, is_open):
if n1 or n2 or n3:
return not is_open
return is_open
@app.callback(
Output("ikernel_inter2_modal", "is_open"),
[Input("left_date_tab2_ikernel2_div", "n_clicks"), Input("right_date_tab2_ikernel2_div", "n_clicks"), Input("ikernel_inter2_modal_close", "n_clicks")],
[State("ikernel_inter2_modal", "is_open")],
)
def toggle_modal(n1, n2, n3, is_open):
if n1 or n2 or n3:
return not is_open
return is_open
@app.callback(
Output("ikernel_inter3_modal", "is_open"),
[Input("left_date_tab2_ikernel3_div", "n_clicks"), Input("right_date_tab2_ikernel3_div", "n_clicks"), Input("ikernel_inter3_modal_close", "n_clicks")],
[State("ikernel_inter3_modal", "is_open")],
)
def toggle_modal(n1, n2, n3, is_open):
if n1 or n2 or n3:
return not is_open
return is_open
#####################
# Date-Window Picker (right)
#####################
right_date_controls = dbc.FormGroup(
children=[
dbc.Label(
id='right_date-label',
children=["Vorhersagebeginn:"],
),
html.Div(
children=[
dcc.DatePickerSingle(
id='right_date-picker',
style={'width':'100%'}, #150px'},
display_format='DD. MMM YYYY',
min_date_allowed=min_date,
max_date_allowed=max_date,
initial_visible_month=init_date,
date=init_date +timedelta(days=deltadays),
),
html.Div(
id='right_output-container-date-picker',
style={'display': 'none'},
children=[(init_date +timedelta(days=deltadays)).strftime('%Y_%m_%d')],
),
]),
dbc.Label(
id='right_date-label2',
children=["(auf Basis der Daten des vorherigen 3-Wochenfensters)"],
),
])
# Date Picker
@app.callback(
Output(component_id='right_output-container-date-picker', component_property='children'),
[Input(component_id='right_date-picker', component_property='date')])
def update_right_date_picker(date):
if date is not None:
return get_assets_dir(date)
else:
return init_assets_dir
# Interactive Map - BSTIM
@app.callback(
Output(component_id='right_date_tab1_graph', component_property='figure'),
[Input(component_id='right_date-picker', component_property='date')])
@cache.memoize(timeout=cache_timeout)
def update_right_date_tab1_map(date):
if date is not None:
assets_dir = get_assets_dir(date)
mapfig = create_map("assets/figures/" + assets_dir + "/map.csv", 'newInf100k')
else:
mapfig = create_map("assets/placeholders/map_empty.csv", 'newInf100k')
return mapfig
# Interaction Kernel
@app.callback(
[Output(component_id='right_date_tab2_img', component_property='src'),
Output(component_id='right_date_modal2_img', component_property='src')],
[Input(component_id='right_date-picker', component_property='date')])
def update_right_date_tab2_img(date):
imgUrl=""
if date is not None:
assets_dir = get_assets_dir(date)
imgUrl = "figures/" + assets_dir + "interaction_kernel.png"
if not os.path.isfile("assets/" + imgUrl):
imgUrl = "placeholders/plot_not_found.png"
imgUrl = asset_url + imgUrl
return imgUrl, imgUrl
# Interactive Map - RKI
@app.callback(
Output(component_id='right_date_tab3_graph', component_property='figure'),
[Input(component_id='right_date-picker', component_property='date')])
@cache.memoize(timeout=cache_timeout)
def update_right_date_tab3_map(date):
if date is not None:
assets_dir = get_assets_dir(date)
mapfig = create_map("assets/figures/" + assets_dir + "/map.csv", 'newInf100k_RKI')
else:
mapfig = create_map("assets/placeholders/map_empty.csv", 'newInf100k')
return mapfig
#####################
# County-Tabs (left)
#####################
left_pos_tab1_modal = html.Div(
[
dbc.Button("Vergrößern", id="left_pos_tab1_modal_open", outline=True, color="secondary", className="mr-1"),
dbc.Modal(
id="left_pos_tab1_modal",
size="xl",
children=[
dbc.ModalHeader("geglättet"),
dbc.ModalBody(
children=[
html.Img(
id="left_pos_modal1_img",
src=asset_url + "figures/" + init_date.strftime('%Y_%m_%d') + "/curve_{0:05d}.png".format(init_countyid),
style={'width':'100%', 'height':'100%'},
),
]
),
dbc.ModalFooter(
dbc.Button("Schließen", id="left_pos_tab1_modal_close", className="ml-auto")
),
],
),
]
)
left_pos_tab1 = dbc.Card(
outline=True,
color="light",
className="mt-3",
children=[ dbc.CardBody(
children=[
html.Div(
id="left_pos_tab1_img_div",
children=[
left_pos_tab1_modal,
dcc.Loading(
id = "left_pos_tab1_loading_img",
children=[html.Div(children=[
html.Img(
id="left_pos_tab1_img",
src=asset_url + "figures/" + init_date.strftime('%Y_%m_%d') + "/curve_{0:05d}.png".format(init_countyid),
style={'width':'100%', 'height':'100%'},
),
])],
type="circle", # 'graph', 'cube', 'circle', 'dot', 'default'
color="#343A40",
style={'hight':'340px'},
),
html.Div(
dcc.Markdown(
id="left_pos_tab1_txt",
children=[""],
)
),
dbc.Tooltip(
"Analyse und Vorhersage der Infektionszahlen für den ausgewählten Landkreis. "
"Der Nowcast entspricht der Schätzung der realen aktuellen Neuinfektionen für den angegebenden Tag. "
"Diese Schätzung korrigiert die gemeldeten Zahlen, die aufgrund von Verzögerungen im Meldeprozess "
"und einem unbekannten Erkrankungsdatum kleiner als die tatsächlichen Zahlen sein können, auf der Basis einer Vorhersage. "
"Die Vorhersage nutzt das gleiche Modell um den Verlauf der kommenden 5 Tage, für die noch keine Zahlen vorliegen, vorherzusagen. "
"Das geglättete Model korrigiert die Ergebnisse bezüglich eines Wochenrhythmusses bei den Meldeverzögerungen (siehe Erklärvideo). ",
target="left_pos_tab1_img",
style={"width": "600px"},
placement="left",
),
]),
]),
])
@app.callback(
Output("left_pos_tab1_modal", "is_open"),
[Input("left_pos_tab1_img_div", "n_clicks"), Input("left_pos_tab1_modal_open", "n_clicks"), Input("left_pos_tab1_modal_close", "n_clicks")],
[State("left_pos_tab1_modal", "is_open")],
)
def toggle_modal(n1, n2, n3, is_open):
if n1 or n2 or n3:
return not is_open
return is_open
#####################
left_pos_tab2_modal = html.Div(
[
dbc.Button("Vergrößern", id="left_pos_tab2_modal_open", outline=True, color="secondary", className="mr-1"),
dbc.Modal(
id="left_pos_tab2_modal",
size="xl",
children=[
dbc.ModalHeader("ungeglättet"),
dbc.ModalBody(
children=[
html.Img(
id="left_pos_modal2_img",
src=asset_url + "figures/" + init_date.strftime('%Y_%m_%d') + "/curve_trend_{0:05d}.png".format(init_countyid),
style={'width':'100%', 'height':'100%'},
),
]
),
dbc.ModalFooter(
dbc.Button("Schließen", id="left_pos_tab2_modal_close", className="ml-auto")
),
],
),
]
)
left_pos_tab2 = dbc.Card(
outline=True,
color="light",
className="mt-3",
children=[ dbc.CardBody(
children=[
html.Div(
id="left_pos_tab2_img_div",
children=[
left_pos_tab2_modal,
dcc.Loading(
id = "left_pos_tab2_loading_img",
children=[html.Div(children=[
html.Img(
id="left_pos_tab2_img",
src=asset_url + "figures/" + init_date.strftime('%Y_%m_%d') + "/curve_trend_{0:05d}.png".format(init_countyid),
style={'width':'100%', 'height':'100%'},
),
])],
type="circle", # 'graph', 'cube', 'circle', 'dot', 'default'
color="#343A40",
style={'hight':'340px'},
),
html.Div(
dcc.Markdown(
id="left_pos_tab2_txt",
children=[""],
)
),
dbc.Tooltip(
"Analyse und Vorhersage der Infektionszahlen für den ausgewählten Landkreis. "
"Der Nowcast entspricht der Schätzung der realen aktuellen Neuinfektionen für den angegebenden Tag. "
"Diese Schätzung korrigiert die gemeldeten Zahlen, die aufgrund von Verzögerungen im Meldeprozess "
"und einem unbekannten Erkrankungsdatum kleiner als die tatsächlichen Zahlen sein können, auf der Basis einer Vorhersage. "
"Die Vorhersage nutzt das gleiche Modell um den Verlauf der kommenden 5 Tage, für die noch keine Zahlen vorliegen, vorherzusagen. "
"Das geglättete Model korrigiert die Ergebnisse bezüglich eines Wochenrhythmusses bei den Meldeverzögerungen (siehe Erklärvideo). ",
target="left_pos_tab2_img",
style={"width": "200%"},
placement="left",
),
]),
]),
])
@app.callback(
Output("left_pos_tab2_modal", "is_open"),
[Input("left_pos_tab2_img_div", "n_clicks"), Input("left_pos_tab2_modal_open", "n_clicks"), Input("left_pos_tab2_modal_close", "n_clicks")],
[State("left_pos_tab2_modal", "is_open")],
)
def toggle_modal(n1, n2, n3, is_open):
if n1 or n2 or n3:
return not is_open
return is_open
#####################
# County Picker (left)
#####################
left_pos_controls = dbc.FormGroup(
children=[
dbc.Label(
id='left_pos-label',
children=["Wähle Landkreis:"],
),
html.Div(
children=[
dcc.Dropdown(
id="left_pos-variable",
value=init_countyid,
options=[
{"label": row['LKName'] + " (" + row['LKType'] + ")", "value": row['countyID']} for index, row in metadata.iterrows()
]),
#html.Div(id='left_output-container-pos-variable', style={'display': 'none'}),
]),
])
# County Picker
#@app.callback(
# Output(component_id='left_output-container-pos-variable', component_property='children'),
# [Input(component_id='left_pos-variable', component_property='value'),
# Input(component_id='left_output-container-date-picker', component_property='children')])
#def update_left_pos_variable(value, assets_dir):
# if value is not None:
# return asset_url + "figures/" + assets_dir + "curve_trend_{0:05d}.png".format(value)
# change dropbox on map-click
@app.callback(
Output(component_id='left_pos-variable', component_property='value'),
# Output(component_id='left_date_tab1_txt', component_property='children')],
[Input(component_id='left_date_tab1_graph', component_property='clickData'),
Input(component_id='left_date_tab3_graph', component_property='clickData')]
)
def update_left_date_mapclick(choro1_click, choro3_click):
ctx = dash.callback_context
if not ctx.triggered:
id_str = init_countyid
else:
cid = ctx.triggered[0]['value']['points'][0]['location']
id_str = counties_metadf['cca'][cid]
#print("update_right_date1_mapclick - cid={}, id_str={}".format(cid,id_str))
return int(id_str) #, id_str
# geglättet
@app.callback(
[Output(component_id='left_pos_tab1_img', component_property='src'),
Output(component_id='left_pos_modal1_img', component_property='src')],
[Input(component_id='left_pos-variable', component_property='value'),
Input(component_id='left_output-container-date-picker', component_property='children')])
def update_left_pos_tab1_img(value, assets_dir):
imgUrl=""
if value is not None:
imgUrl = "figures/" + assets_dir + "curve_trend_{0:05d}.png".format(value)
if not os.path.isfile("assets/" + imgUrl):
imgUrl = "placeholders/plot_not_found.png"
imgUrl = asset_url + imgUrl
return imgUrl, imgUrl
# ungeglättet
@app.callback(
[Output(component_id='left_pos_tab2_img', component_property='src'),
Output(component_id='left_pos_modal2_img', component_property='src')],
[Input(component_id='left_pos-variable', component_property='value'),
Input(component_id='left_output-container-date-picker', component_property='children')])
def update_left_pos_tab2_img(value, assets_dir):
imgUrl=""
if value is not None:
imgUrl = "figures/" + assets_dir + "curve_{0:05d}.png".format(value)
if not os.path.isfile("assets/" + imgUrl):
imgUrl = "placeholders/plot_not_found.png"
imgUrl = asset_url + imgUrl
return imgUrl, imgUrl
# print meta-information
@app.callback(
[Output(component_id='left_pos_tab1_txt', component_property='children'),
Output(component_id='left_pos_tab2_txt', component_property='children')],
[Input(component_id='left_pos-variable', component_property='value'),
Input(component_id='left_output-container-date-picker', component_property='children')])
def update_left_pos_txt(value, assets_dir):
msg = " "
if value is not None:
try:
mdat = pd.read_csv("./assets/figures/" + assets_dir + "/metadata.csv")
msg = mdat.loc[mdat['countyID'] == value]['probText'].to_string(index=False)
try:
val = float(msg)
absVal = abs(val)
if val<0.0:
if 95.0 < absVal <= 100.0:
msg = 'Es gibt eine deutliche Tendenz von **fallenden** Infektionszahlen mit einer Wahrscheinlichkeit von grösser **95%**.'
elif 75.0 < absVal <= 95.0:
msg = 'Es gibt eine Tendenz von **fallenden** Infektionszahlen mit einer Wahrscheinlichkeit von grösser **75%**.'
elif 50.0 < absVal <= 75.0:
msg = 'Es gibt eine Tendenz von **fallenden** Infektionszahlen mit einer Wahrscheinlichkeit von grösser **50%**.'
else:
msg = 'Die Infektioneszahlen werden mit einer Wahrscheinlichkeit von **{:.1f}%** fallen.'.format(absVal)
else:
if 95.0 < absVal <= 100.0:
msg = 'Es gibt eine deutliche Tendenz von **steigenden** Infektionszahlen mit einer Wahrscheinlichkeit von grösser **95%**.'
elif 75.0 < absVal <= 95.0:
msg = 'Es gibt eine Tendenz von **steigenden** Infektionszahlen mit einer Wahrscheinlichkeit von grösser **75%**.'
elif 50.0 < absVal <= 75.0:
msg = 'Es gibt eine Tendenz von **steigenden** Infektionszahlen mit einer Wahrscheinlichkeit von grösser **50%**.'
else:
msg = 'Die Infektioneszahlen werden mit einer Wahrscheinlichkeit von **{:.1f}%** fallen.'.format(absVal)
except:
print("Exception in update_right_pos_txt")
pass
except:
pass
return msg, msg
#####################
# County-Tabs (right)
#####################
right_pos_tab1_modal = html.Div(
[
dbc.Button("Vergrößern", id="right_pos_tab1_modal_open", outline=True, color="secondary", className="mr-1"),
dbc.Modal(
id="right_pos_tab1_modal",
size="xl",
children=[
dbc.ModalHeader("geglättet"),
dbc.ModalBody(
children=[
html.Img(
id="right_pos_modal1_img",
src=asset_url + "figures/" + init_date.strftime('%Y_%m_%d') + "/curve_{0:05d}.png".format(init_countyid),
style={'width':'100%', 'height':'100%'},
),
]
),
dbc.ModalFooter(
dbc.Button("Schließen", id="right_pos_tab1_modal_close", className="ml-auto")
),
],
),
]
)
right_pos_tab1 = dbc.Card(
outline=True,
color="light",
className="mt-3",
children=[ dbc.CardBody(
children=[
html.Div(
id="right_pos_tab1_img_div",
children=[
right_pos_tab1_modal,
dcc.Loading(
id = "right_pos_tab1_loading_img",
children=[html.Div(children=[
html.Img(
id="right_pos_tab1_img",
src=asset_url + "figures/" + init_date.strftime('%Y_%m_%d') + "/curve_{0:05d}.png".format(init_countyid),
style={'width':'100%', 'height':'100%'},
),
])],
type="circle", # 'graph', 'cube', 'circle', 'dot', 'default'
color="#343A40",
style={'hight':'340px'},
),
html.Div(
dcc.Markdown(
id="right_pos_tab1_txt",
children=[""],
)
),
dbc.Tooltip(
"Analyse und Vorhersage der Infektionszahlen für den ausgewählten Landkreis. "
"Der Nowcast entspricht der Schätzung der realen aktuellen Neuinfektionen für den angegebenden Tag. "
"Diese Schätzung korrigiert die gemeldeten Zahlen, die aufgrund von Verzögerungen im Meldeprozess "
"und einem unbekannten Erkrankungsdatum kleiner als die tatsächlichen Zahlen sein können, auf der Basis einer Vorhersage. "
"Die Vorhersage nutzt das gleiche Modell um den Verlauf der kommenden 5 Tage, für die noch keine Zahlen vorliegen, vorherzusagen. "
"Das geglättete Model korrigiert die Ergebnisse bezüglich eines Wochenrhythmusses bei den Meldeverzögerungen (siehe Erklärvideo). ",
target="right_pos_tab1_img",
style={"width": "200%"},
placement="right",
),
]),
]),
])
@app.callback(
Output("right_pos_tab1_modal", "is_open"),
[Input("right_pos_tab1_img_div", "n_clicks"), Input("right_pos_tab1_modal_open", "n_clicks"), Input("right_pos_tab1_modal_close", "n_clicks")],
[State("right_pos_tab1_modal", "is_open")],
)
def toggle_modal(n1, n2, n3, is_open):
if n1 or n2 or n3:
return not is_open
return is_open
#####################
right_pos_tab2_modal = html.Div(
[
dbc.Button("Vergrößern", id="right_pos_tab2_modal_open", outline=True, color="secondary", className="mr-1"),
dbc.Modal(
id="right_pos_tab2_modal",
size="xl",
children=[
dbc.ModalHeader("ungeglättet"),
dbc.ModalBody(
children=[
html.Img(
id="right_pos_modal2_img",
src=asset_url + "figures/" + init_date.strftime('%Y_%m_%d') + "/curve_trend_{0:05d}.png".format(init_countyid),
style={'width':'100%', 'height':'100%'},
),
]
),
dbc.ModalFooter(
dbc.Button("Schließen", id="right_pos_tab2_modal_close", className="ml-auto")
),
],
),
]
)
right_pos_tab2 = dbc.Card(
outline=True,
color="light",
className="mt-3",
children=[ dbc.CardBody(
children=[
html.Div(
id="right_pos_tab2_img_div",
children=[
right_pos_tab2_modal,
dcc.Loading(
id = "right_pos_tab2_loading_img",
children=[html.Div(children=[
html.Img(
id="right_pos_tab2_img",
src=asset_url + "figures/" + init_date.strftime('%Y_%m_%d') + "/curve_trend_{0:05d}.png".format(init_countyid),
style={'width':'100%', 'height':'100%'},
),
])],
type="circle", # 'graph', 'cube', 'circle', 'dot', 'default'
color="#343A40",
style={'hight':'340px'},
),
html.Div(
dcc.Markdown(
id="right_pos_tab2_txt",
children=[""],
)
),
dbc.Tooltip(
"Analyse und Vorhersage der Infektionszahlen für den ausgewählten Landkreis. "
"Der Nowcast entspricht der Schätzung der realen aktuellen Neuinfektionen für den angegebenden Tag. "
"Diese Schätzung korrigiert die gemeldeten Zahlen, die aufgrund von Verzögerungen im Meldeprozess "
"und einem unbekannten Erkrankungsdatum kleiner als die tatsächlichen Zahlen sein können, auf der Basis einer Vorhersage. "
"Die Vorhersage nutzt das gleiche Modell um den Verlauf der kommenden 5 Tage, für die noch keine Zahlen vorliegen, vorherzusagen. "
"Das geglättete Model korrigiert die Ergebnisse bezüglich eines Wochenrhythmusses bei den Meldeverzögerungen (siehe Erklärvideo). ",
target="right_pos_tab2_img",
style={"width": "200%"},
placement="right",
),
]),
]),
])
@app.callback(
Output("right_pos_tab2_modal", "is_open"),
[Input("right_pos_tab2_img", "n_clicks"), Input("right_pos_tab2_modal_open", "n_clicks"), Input("right_pos_tab2_modal_close", "n_clicks")],
[State("right_pos_tab2_modal", "is_open")],
)
def toggle_modal(n1, n2, n3, is_open):
if n1 or n2 or n3:
return not is_open
return is_open
#####################
# County Picker (right)
#####################
right_pos_controls = dbc.FormGroup(
children=[
dbc.Label(
id='right_pos-label',
children=["Wähle Landkreis:"],
),
html.Div(
children=[
dcc.Dropdown(
id="right_pos-variable",
value=init_countyid,
options=[
{"label": row['LKName'] + " (" + row['LKType'] + ")", "value": row['countyID']} for index, row in metadata.iterrows()
]),
#html.Div(id='right_output-container-pos-variable', style={'display': 'none'}),
]),
])
# County Picker
#@app.callback(
# Output(component_id='right_output-container-pos-variable', component_property='children'),
# [Input(component_id='right_pos-variable', component_property='value'),
# Input(component_id='right_output-container-date-picker', component_property='children')])
#def update_right_pos_variable(value, assets_dir):
# if value is not None:
# return asset_url + "figures/" + assets_dir + "curve_trend_{0:05d}.png".format(value)
# change dropbox on map-click
@app.callback(
Output(component_id='right_pos-variable', component_property='value'),
# Output(component_id='right_date_tab1_txt', component_property='children')],
[Input(component_id='right_date_tab1_graph', component_property='clickData'),
Input(component_id='right_date_tab3_graph', component_property='clickData')]
)
def update_right_date_mapclick(choro1_click, choro3_click):
ctx = dash.callback_context
if not ctx.triggered:
id_str = init_countyid
else:
cid = ctx.triggered[0]['value']['points'][0]['location']
id_str = counties_metadf['cca'][cid]
#print("update_right_date1_mapclick - cid={}, id_str={}".format(cid,id_str))
return int(id_str) #, id_str
# geglättet
@app.callback(
[Output(component_id='right_pos_tab1_img', component_property='src'),
Output(component_id='right_pos_modal1_img', component_property='src')],
[Input(component_id='right_pos-variable', component_property='value'),
Input(component_id='right_output-container-date-picker', component_property='children')])
def update_right_pos_tab1_img(value, assets_dir):
imgUrl=""
if value is not None:
imgUrl = "figures/" + assets_dir + "curve_trend_{0:05d}.png".format(value)
if not os.path.isfile("assets/" + imgUrl):
imgUrl = "placeholders/plot_not_found.png"
imgUrl = asset_url + imgUrl
return imgUrl, imgUrl
# ungeglättet
@app.callback(
[Output(component_id='right_pos_tab2_img', component_property='src'),
Output(component_id='right_pos_modal2_img', component_property='src')],
[Input(component_id='right_pos-variable', component_property='value'),
Input(component_id='right_output-container-date-picker', component_property='children')])
def update_right_pos_tab2_img(value, assets_dir):
imgUrl=""
if value is not None:
imgUrl = "figures/" + assets_dir + "curve_{0:05d}.png".format(value)
if not os.path.isfile("assets/" + imgUrl):
imgUrl = "placeholders/plot_not_found.png"
imgUrl = asset_url + imgUrl
return imgUrl, imgUrl
# print meta-information
@app.callback(
[Output(component_id='right_pos_tab1_txt', component_property='children'),
Output(component_id='right_pos_tab2_txt', component_property='children')],
[Input(component_id='right_pos-variable', component_property='value'),
Input(component_id='right_output-container-date-picker', component_property='children')])
def update_right_pos_txt(value, assets_dir):
msg = " "
if value is not None:
try:
mdat = pd.read_csv("./assets/figures/" + assets_dir + "/metadata.csv")
msg = mdat.loc[mdat['countyID'] == value]['probText'].to_string(index=False)
try:
val = float(msg)
absVal = abs(val)
if val<0.0:
if 95.0 < absVal <= 100.0:
msg = 'Es gibt eine deutliche Tendenz von **fallenden** Infektionszahlen mit einer Wahrscheinlichkeit von grösser **95%**.'
elif 75.0 < absVal <= 95.0:
msg = 'Es gibt eine Tendenz von **fallenden** Infektionszahlen mit einer Wahrscheinlichkeit von grösser **75%**.'
elif 50.0 < absVal <= 75.0:
msg = 'Es gibt eine Tendenz von **fallenden** Infektionszahlen mit einer Wahrscheinlichkeit von grösser **50%**.'
else:
msg = 'Die Infektioneszahlen werden mit einer Wahrscheinlichkeit von **{:.1f}%** fallen.'.format(absVal)
else:
if 95.0 < absVal <= 100.0:
msg = 'Es gibt eine deutliche Tendenz von **steigenden** Infektionszahlen mit einer Wahrscheinlichkeit von grösser **95%**.'
elif 75.0 < absVal <= 95.0:
msg = 'Es gibt eine Tendenz von **steigenden** Infektionszahlen mit einer Wahrscheinlichkeit von grösser **75%**.'
elif 50.0 < absVal <= 75.0:
msg = 'Es gibt eine Tendenz von **steigenden** Infektionszahlen mit einer Wahrscheinlichkeit von grösser **50%**.'
else:
msg = 'Die Infektioneszahlen werden mit einer Wahrscheinlichkeit von **{:.1f}%** fallen.'.format(absVal)
except:
print("Exception in update_right_pos_txt")
pass
except:
pass
return msg, msg | _____no_output_____ | BSD-3-Clause | covid19/covid19dynstat-dash.ipynb | FZJ-JSC/jupyter-jsc-dashboads |
Define the main body of the webpage https://dash-bootstrap-components.opensource.faculty.ai/docs/components/layout/ Layout in Bootstrap is controlled using the grid system.The Bootstrap grid has **twelve** columns, and **five** responsive tiers (allowing you to specify different behaviours on different screen sizes, see below). | #####################
# Main Structure
#####################
tab_height = '5vh'
body_layout = dbc.Container(
style={"marginTop": 100, "marginBottom": 20},
#fluid=True,
children=[
#####################
# Introduction
#####################
dbc.Row(
children=[
dbc.Col(
style={
"marginBottom": 10,
"width": 12,
},
children=[
dcc.Markdown(
f"""
##### **Ein Gemeinschaftsprojekt der Arbeitsgruppe [Neuroinformatik an der Universität Osnabrück](https://www.ikw.uni-osnabrueck.de/en/research_groups/neuroinformatics)**
##### **und des [Jülich Supercomputing Centre](https://www.fz-juelich.de/jsc), auf Basis der Daten des [RKI](https://www.rki.de/DE/Content/Infekt/IfSG/Signale/Projekte/Signale_Projekte_node.html;jsessionid=C61DE534E8208B0D69BEAD299FC753F9.internet091)**
"""
),
]),
]),
dbc.Row(
children=[
dbc.Col(
width=4,
children=[
html.A([
html.Img(
src=asset_url + 'uniosnab-logo.png',
height='48', # width='500',
style={
'display':'block',
'margin-left': 'auto',
'margin-right': 'auto'
},
),
], href='https://www.ikw.uni-osnabrueck.de/en/research_groups/neuroinformatics'),
]),
dbc.Col(
width=4,
children=[
# html.A([
# html.Img(
# src=asset_url + 'rki-logo.png', #'https://www.rki.de/SiteGlobals/StyleBundles/Bilder/Farbschema_A/logo_a.jpg?__blob=normal&v=7',
# height='48', # width='500',
# style={
# 'display':'block',
# 'margin-left': 'auto',
# 'margin-right': 'auto'
# },
# ),
# ], href='https://www.rki.de'),
]),
dbc.Col(
width=4,
children=[
html.A([
html.Img(
src=asset_url + 'jsc-logo.png',
height='48', # width='500',
style={
'display':'block',
'margin-left': 'auto',
'margin-right': 'auto'
},
),
], href='https://www.fz-juelich.de/jsc'),
]),
]),
dbc.Row(
children=[
dbc.Col(
style={
"marginTop": 30,
"width": 6,
},
children=[
disclaimer_modal,
]),
dbc.Col(
style={
"marginTop": 30,
"width": 6,
},
children=[
dcc.Markdown(
f"""
-----
##### Wie funktioniert die Vorhersage und Analyse
-----
"""
),
html.Div(
style={
'width': '100%',
'float': 'left',
'margin': '0% 0% 5% 0%' # top, right, bottom, left
},
children=[
dash_player.DashPlayer(
id='video-player',
url='https://youtu.be/0jvH3nkjR9I',
controls=True,
width='100%'
),
dcc.Markdown(
f"""
Das Video ist unter folgendem Link auch unter YouTube verfügbar:
["BSTIM Covid-19 Model zur Analyse der Ausbreitung der Infektion"](https://youtu.be/0jvH3nkjR9I)
""",
style={
'margin': '5% 0% 0% 0%' # top, right, bottom, left
},
),
]),
]),
]),
#####################
# Plots Section
#####################
dbc.Row(
children=[
dbc.Col(
dbc.Alert("Basisauswahl", color="primary")
),
dbc.Col(
dbc.Alert("Vergleichsauswahl", color="primary")
),
]
),
ikernel_inter1_modal,
ikernel_inter2_modal,
ikernel_inter3_modal,
dbc.Row(
children=[
##### left plots
dbc.Col(
children=[
dbc.Card(
style={
'margin': '0% 0% 0% 0%', # top, right, bottom, left
'padding': '0',
},
body=True,
children=[
# --- Zeitangabe (left) ---
dbc.CardHeader(
left_date_controls,
),
dbc.CardBody(
className="mt-3",
children=[
dbc.Tabs(
id="left_date-card-tabs",
active_tab="tab-0",
children=[
dbc.Tab(left_date_tab3, label="Meldedaten RKI", style={'padding': '0', 'height': '450px'}),
dbc.Tab(left_date_tab1, label="Nowcast BSTIM", style={'padding': '0', 'height': '450px'}),
dbc.Tab(left_date_tab2, label="Interaktionskernel", style={'padding': '0', 'height': '450px'}),
]),
html.P(
id="left_pos-card-separator",
className="card-text",
),
# --- Ortsangabe (left) ---
dbc.Card(
style={
'margin': '0% 0% 0% 0%', # top, right, bottom, leftleft
'padding': '0',
},
children=[
dbc.CardHeader(
left_pos_controls,
),
dbc.CardBody(
className="mt-3",
children=[
dbc.Tabs(
id="left_pos-card-tabs",
active_tab="tab-0",
children=[
dbc.Tab(left_pos_tab1, label="geglättet", style={'padding': '0', 'height': '340px'}),
dbc.Tab(left_pos_tab2, label="ungeglättet", style={'padding': '0', 'height': '340px'}),
]),
html.P(
id="left_pos-card-content",
className="card-text",
),
]),
]),
]),
]),
]),
##### right plots
dbc.Col(
children=[
dbc.Card(
style={
'margin': '0% 0% 0% 0%', # top, right, bottom, left
'padding': '0',
},
body=True,
children=[
# --- Zeitangabe (left) ---
dbc.CardHeader(
right_date_controls,
),
dbc.CardBody(
className="mt-3",
children=[
dbc.Tabs(
id="right_date-card-tabs",
active_tab="tab-0",
children=[
dbc.Tab(right_date_tab3, label="Meldedaten RKI", style={'padding': '0', 'height': '450px'}),
dbc.Tab(right_date_tab1, label="Nowcast BSTIM", style={'padding': '0', 'height': '450px'}),
dbc.Tab(right_date_tab2, label="Interaktionskernel", style={'padding': '0', 'height': '450px'}),
]),
html.P(
id="right_pos-card-separator",
className="card-text",
),
html.P(id='right_pos-card-hidden', style={'display':'none'}, children=["init"]),
# --- Ortsangabe (left) ---
dbc.Card(
style={
'margin': '0% 0% 0% 0%', # top, right, bottom, left
'padding': '0',
},
children=[
dbc.CardHeader(
right_pos_controls,
),
dbc.CardBody(
className="mt-3",
children=[
dbc.Tabs(
id="right_pos-card-tabs",
active_tab="tab-0",
children=[
dbc.Tab(right_pos_tab1, label="geglättet", style={'padding': '0', 'height': '340px'}),
dbc.Tab(right_pos_tab2, label="ungeglättet", style={'padding': '0', 'height': '340px'}),
]),
html.P(
id="right_pos-card-content",
className="card-text",
),
]),
]),
]),
]),
]),
]),
])
# Note that if the container itself is resizable, the graph will not be replotted/resized.
# There isn’t a reliable way to tell if a graph’s container has changed size in JavaScript yet, so we’re just checking if the window is resized.
# We have to call a synthetic resize event to ensure, the graph is informed.
# Solution found here: https://community.plotly.com/t/update-div-size-with-graph-in-it/22671
app.clientside_callback(
"""
function syntheticResize() {
var evt = window.document.createEvent('UIEvents');
evt.initUIEvent('resize', true, false, window, 0);
window.dispatchEvent(evt);
return "updated";
}
""",
Output('right_pos-card-hidden', 'children'),
[Input('left_date-card-tabs', 'active_tab'),
Input('right_date-card-tabs', 'active_tab')]
)
#####################
# Fragen & Anworten Structure
#####################
faq_body_layout = dbc.Container(
style={"marginTop": 100, "marginBottom": 20},
#fluid=True,
children=[
#####################
# Introduction
#####################
dbc.Row(
children=[
dbc.Col(
style={
"marginBottom": 10,
"width": 12,
},
children=[
dcc.Markdown(
f"""
##### **Ein Gemeinschaftsprojekt der Arbeitsgruppe [Neuroinformatik an der Universität Osnabrück](https://www.ikw.uni-osnabrueck.de/en/research_groups/neuroinformatics)**
##### **und des [Jülich Supercomputing Centre](https://www.fz-juelich.de/jsc), auf Basis der Daten des [RKI](https://www.rki.de/DE/Content/Infekt/IfSG/Signale/Projekte/Signale_Projekte_node.html;jsessionid=C61DE534E8208B0D69BEAD299FC753F9.internet091)**
"""
),
]),
]),
dbc.Row(
children=[
dbc.Col(
width=4,
children=[
html.Img(
src=asset_url + 'uniosnab-logo.png',
height='48', # width='500',
style={
'display':'block',
'margin-left': 'auto',
'margin-right': 'auto'
},
),
]),
dbc.Col(
width=4,
children=[
# html.Img(
# src=asset_url + 'rki-logo.png', #'https://www.rki.de/SiteGlobals/StyleBundles/Bilder/Farbschema_A/logo_a.jpg?__blob=normal&v=7',
# height='48', # width='500',
# style={
# 'display':'block',
# 'margin-left': 'auto',
# 'margin-right': 'auto'
# },
# ),
]),
dbc.Col(
width=4,
children=[
html.Img(
src=asset_url + 'jsc-logo.png',
height='48', # width='500',
style={
'display':'block',
'margin-left': 'auto',
'margin-right': 'auto'
},
),
]),
]),
dbc.Row(
style={ "marginTop": 30 },
children=[
dcc.Markdown(
f"""
------------------------
### Fragen & Antworten
##### Bayessches räumlich-zeitliches Interaktionsmodell für Covid-19
------------------------
#### Was ist ein Nowcast?
Aufgrund von verschiedenen Verzögerungen in der Erfassung von Infektionen entsprechen die aktuellen Meldezahlen nicht den tatsächlichen des heutigen Tages.
Das Nowcasting schätzt wie viele Fälle noch nicht berücksichtigt wurden und korrigiert Zahlen so, dass sie möglichst nah an den echten Zahlen sind.
Für weitere Informationen siehe das [FAQ des Robert Koch-Instituts](https://www.rki.de/SharedDocs/FAQ/NCOV2019/gesamt.html) und den [Erklärfilm](https://youtu.be/8-AfYeosBW8) .
------------------------
#### Woher kommen die Daten?
Die Zahlen der Positiv-Tests beziehen wir vom offiziellen [Dashboard des RKIs](https://experience.arcgis.com/experience/478220a4c454480e823b17327b2bf1d4), bzw. dem dahinterliegenden ArcGIS-System.
Eine Zusammenfassung dieser Zahlen wird auch im [Wochenbericht des RKI](https://ars.rki.de/Content/COVID19/Main.aspx) veröffentlicht.
------------------------
#### Worin unterscheidet sich diese Analyse von anderen Vorhersagen?
Dieses Modell modelliert nicht nur den wahrscheinlichsten Verlauf, sondern zeigt eine Vielzahl von mit den Daten kompatiblen Verläufen und berechnet deren Wahrscheinlichkeit (Bayesian Analyse, siehe auch [Konfidenzintervall](https://de.wikipedia.org/wiki/Konfidenzintervall)).
Dies erlaubt es die Wahrscheinlichkeit für eine Zu- oder Abnahme zu bestimmen, und zudem auch seltene aber eventuell extreme Vorhersagen in die Bewertung einfließen zu lassen.
------------------------
#### Was ist ein Konfidenzintervall?
Ein Konfidenzintervall gibt an wie groß der Bereich der Modell-Entwicklung ist, der mit einer bestimmten Wahrscheinlichkeit vorhergesagt wird.
In unserem Fall haben wir für die Vorhersage zwei Konfidenzintervalle genutzt, die wie folgt interpretiert werden können.
- 25%-75% Quantil: Dieses dunkelgrüne/-orange Intervall beinhaltet 50% der Vorhersagen.
Das heißt man kann erwarten, dass für eine Vorhersage die echten zukünftigen Daten mit einer Wahrscheinlichkeit von 50% in dem dunkelgrünen/-orangen Intervall liegen.
- 5%-95% Quantil: Dieses hellgrüne/-orange Intervall beinhaltet 90% der Vorhersagen.
Das heißt man kann erwarten, dass für eine Vorhersage die echten zukünftigen Daten mit einer Wahrscheinlichkeit von 90 % in dem hellgrünen/-orangen Intervall liegen.
------------------------
#### Was ist der Interaktionskernel?
Der Interaktionskernel schätzt ab um wie stark eine gemeldete Infektion eine Neuansteckung in den nächsten Tagen in einem Umkreis von bis zu 50km beeinflusst.
Diese Interaktion ist ein zusätzlicher Faktor der den Trend in einem Landkreis verstärkt oder abschwächt.
Eine warme Farbe indiziert, dass eine Covid-19 Meldung eine erhöhte Wahrscheinlichkeit einer Neuinfektion im Verhältnis zum Trend zur Folge hat.
Eine starke Farben in der Nähe kleiner Radien bedeutet, dass das Infektionsgeschehen vor allem Auswirkungen in der direkten Nähe der gemeldeten Fälle zur Folge hat.
Die Interaktion basiert auf einer Schätzung der Bevölkerungsdichte und der Form der Landkreise.
Daten zu den Wohnorten der Infizierten werden in dem Model nicht genutzt.
Alle hier genutzten Daten sind vollständig anonymisiert (siehe Erklärvideo).
Bei der Interpretation der Interaktionskernel ist dies zu berücksichtigen, und wir weisen darauf hin, dass dies nur eine Schätzung ist die von der Realität abweichen kann.
------------------------
#### Nach welchen Regeln werden die Farben des Interaktionskernels gewählt?
Die Farben des Interaktionskernel geben die Stärke des lokalen und zeitlichen Einflusses der Umgebung an.
Die Farben wurden so gewählt, dass starke Farben den größten Effekten seit dem Beginn der Analyse entsprechen.
Schwache Farben indizieren, dass der Effekt deutlich kleiner ist.
------------------------
#### Welche Schwächen hat die Methode?
Alle hier präsentierten Ergebnisse basieren auf statistischen Methoden und bilden damit nicht das tatsächliche Geschehen ab, sondern Schätzungen, die von der wirklichen Situation abweichen können.
Dies ist bei der Interpretation der Ergebnisse zu berücksichtigen.
Die hier präsentierten Forschungsergebnisse basieren auf einer neuen Methodik, die bisher nicht für COVID-19 sondern für Campylobacteriosis-, Rotavirus- und Borreliose-Infektionen eingesetzt wurde (siehe Veröffentlichung).
Die Validierung der Ergebnisse für COVID-19 wird mit der wachsenden Menge an Daten in den kommenden Monaten fortgeführt.
------------------------
#### Was ist das geglättete und ungeglättete Modell?
Die Daten des RKI zeigen eine Modulation im Wochenrhythmus, mit einer typischerweise niedrigeren Rate an Neuinfektionen am Wochenende.
Die Modulation lässt sich durch systematische Verzögerungen im Meldeprozess erklären.
Um die wirklichen Fallzahlen zu schätzen, nutzen wir ein Modell, welches diese Modulation im Wochenrhythmus korrigiert.
Diese korrigierte Version entspricht den geglätteten Daten und dem wahrscheinlichsten wirklichen Infektionsgeschehen.
Um die Modulation zu korrigieren, verfolgen wir den Ansatz, den Wochenrhythmus zunächst im Modell zu beschreiben und anschließend diesen Teil aus dem Modell zur Vorhersage zu entfernen.
Eine Alternative zu unserem Verfahren wäre es, die Daten zunächst zu filtern.
Im Vergleich bietet das von uns eingesetzte Model die Möglichkeit, die Güte der Beschreibung der Daten sowohl für die geglätteten als auch ungeglätteten Daten durchzuführen und so auch die Qualität der Glättung selbst zu bestimmen.
------------------------
#### Wer hat zu diesem Modell beigetragen?
- Luke Effenberger (Uni Osnabrück) (Umsetzung, Daten Analyse und Konzeption, Darstellung der Ergebnisse)
- [Jens Henrik Göbbert](https://www.fz-juelich.de/SharedDocs/Personen/IAS/JSC/EN/staff/goebbert_j_h.html) (Jülich Supercomputing Centre) (Umsetzung und Konzeption der Webapplikation sowie des wissenschaftlichen Rechnens)
- [Dr. Kai Krajsek](https://www.fz-juelich.de/SharedDocs/Personen/IAS/JSC/EN/staff/krajsek_k.html) (Jülich Supercomputing Centre) (Performance-Analyse und -Optimierung durch Nutzung von GPU)
- [Tim Kreuzer](https://www.fz-juelich.de/SharedDocs/Personen/IAS/JSC/EN/staff/kreuzer_t.html) (Jülich Supercomputing Centre) (Infrastruktur für das wissenschaftliche Rechens, Webapplikation, Automatisierung der Rechnungen)
- [Prof. Dr. Gordon Pipa](https://www.ikw.uni-osnabrueck.de/en/research_groups/neuroinformatics/people/prof_dr_gordon_pipa.html) (Uni Osnabrück) (Konzeption und wissenschaftliche Leitung)
- [Pascal Nieters](https://www.ikw.uni-osnabrueck.de/en/research_groups/neuroinformatics/people/msc_pascal_nieters.html) (Uni Osnabrück) (Umsetzung, Daten Analyse und Konzeption, Darstellung der Ergebnisse)
- Dr. Daniel Rohe (Jülich Supercomputing Centre) (Organisation und Diskussion)
"""
),
],
),
],
)
main_page = html.Div(children=[
html.P('4.5', id='version', style={'display':'none'}),
navbar, body_layout, navbar_footer
])
faq_page = html.Div(children=[faq_navbar, faq_body_layout, navbar_footer])
app.layout = html.Div([
dcc.Location(id='url', refresh=False),
html.Div(id='page-content')
])
# Update the visible page
@app.callback(dash.dependencies.Output('page-content', 'children'),
[dash.dependencies.Input('url', 'pathname')])
def display_page(pathname):
if pathname == '/faq':
return faq_page
else:
return main_page | _____no_output_____ | BSD-3-Clause | covid19/covid19dynstat-dash.ipynb | FZJ-JSC/jupyter-jsc-dashboads |
Start the app | app.run_server(mode="jupyterlab", debug=True) #,port=8052,debug=True)
# mode="jupyterlab" -> will open the app in a tab in JupyterLab
# mode="inline" -> will open the app below this cell
# mode="external" -> will displays a URL that you can click on to open the app in a browser tab | _____no_output_____ | BSD-3-Clause | covid19/covid19dynstat-dash.ipynb | FZJ-JSC/jupyter-jsc-dashboads |
--------------------------**Attention** If you get the error "adress in use" this can also be the case because simply your layout has an error so that a dash-app could not been started. Open the app in a new browser-tab with the url`/proxy/` where \ derives from the url of your jupyterlab and \ is by default 8050. For example: `https://jupyter-jsc.fz-juelich.de/user/[email protected]/jureca_login/proxy/8050` This will show the full error log.-------------------------- Show the Dash Flask server is listening | !echo "COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME"
!lsof -i -P -n | grep LISTEN | _____no_output_____ | BSD-3-Clause | covid19/covid19dynstat-dash.ipynb | FZJ-JSC/jupyter-jsc-dashboads |
Topic Modeling Methods Topic modeling is a powerful tool for quickly sorting through a lot of text and documents without having to read every one. There are several methods available for this using python, as well as several libraries. Topic modeling is extremely challenging to get meaningful results. "Garbage in, garbage out" is a phrase that applies well to this - we have to do a significant amount of text preprocessing to extract the right information to feed into a model. On this sheet, I will be topic modeling supreme court cases with the following:- SKlearn- LDA (with TF)- LSA - AKA TruncatedSVD (with TF and TFIDF)- NMF (with TFIDF) Reminder of Full Project WorkflowExtracting text using beautiful soup --> processing the text --> fitting text to a model --> applying model to other text Software Package & Built in Function Documentation- textblob - http://textblob.readthedocs.io/en/dev/ | import pandas as pd
import re
from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer, TfidfTransformer
from sklearn.decomposition import NMF, LatentDirichletAllocation, TruncatedSVD
from textblob import TextBlob
from sklearn.preprocessing import Normalizer
doc_list.read_pickle("full_proj_lemmatized3.pickle") #always save your work!
doc_list.shape #checking to make sure we have the info we expected to have | _____no_output_____ | Apache-2.0 | Topic Modeling/Step 4 - Topic Modeling Method Testing.ipynb | autodidact-m/Projects |
Testing ModelsTry LDA, NMF and LSA as well as adjusting of features, topics, and overlap for best results. | def print_top_words(model, feature_names, n_top_words):
for topic_idx, topic in enumerate(model.components_):
print("Topic #%d:" % topic_idx)
print(" ".join([feature_names[i]
for i in topic.argsort()[:-n_top_words - 1:-1]]))
print()
def modeler(corp, n_topics, n_top_words, clf, vect):
df = .80
str_vect = str(vect).split("(")[0]
str_clf = str(clf).split("(")[0]
print("Extracting {} features for {}...".format(str_vect, str_clf))
vect_trans = vect.fit_transform(corp)
# Fit the model
print("Fitting the {} model with {} features, "
"n_topics= {}, n_topic_words= {}, n_features= {}..."
.format(str_clf, str_vect, n_topics, n_top_words, n_features))
clf = clf.fit(vect_trans)
if str_clf == "TruncatedSVD":
print("\nExplained variance ratio", clf.explained_variance_ratio_)
print("\nTopics in {} model:".format(str_clf))
feature_names = vect.get_feature_names()
return print_top_words(clf, feature_names, n_top_words) | _____no_output_____ | Apache-2.0 | Topic Modeling/Step 4 - Topic Modeling Method Testing.ipynb | autodidact-m/Projects |
Latent Dirchlet Allocation ModelIn natural language processing, Latent Dirichlet Allocation (LDA) is a generative statistical model that allows sets of observations to be explained by unobserved groups that explain why some parts of the data are similar.  Improving Accuracy of Topic Modeling1. Frequency Filter2. Part of Speech Tag Filter 3. Batch Wise LDA The results of topic models are completely dependent on the features (terms) present in the corpus. The corpus is represented as document term matrix, which in general is very sparse in nature. Reducing the dimensionality of the matrix can improve the results of topic modelling. Based on my practical experience, there are few approaches which do the trick. **Frequency Filter**Arrange every term according to its frequency. Terms with higher frequencies are more likely to appear in the results as compared ones with low frequency. The low frequency terms are essentially weak features of the corpus, hence it is a good practice to get rid of all those weak features. An exploratory analysis of terms and their frequency can help to decide what frequency value should be considered as the threshold. **Part of Speech Tag Filter**POS tag filter is more about the context of the features than frequencies of features. Topic Modelling tries to map out the recurring patterns of terms into topics. However, every term might not be equally important contextually. For example, POS tag IN contain terms such as – “within”, “upon”, “except”. “CD” contains – “one”,”two”, “hundred” etc. “MD” contains “may”, “must” etc. These terms are the supporting words of a language and can be removed by studying their post tags. **Batch Wise LDA**In order to retrieve most important topic terms, a corpus can be divided into batches of fixed sizes. Running LDA multiple times on these batches will provide different results, however, the best topic terms will be the intersection of all batches.  | modeler(doc_list.lem, 30, 30, LatentDirichletAllocation(n_topics=30, max_iter=5, learning_method='online', \
learning_offset=50.,random_state=0), CountVectorizer(max_df=.80, min_df=2,
stop_words='english')) | _____no_output_____ | Apache-2.0 | Topic Modeling/Step 4 - Topic Modeling Method Testing.ipynb | autodidact-m/Projects |
 | LDA_mod(doc_list.lem, .95, 2, 2000,10) #df is a way to extract 'meaningful text' in this case | _____no_output_____ | Apache-2.0 | Topic Modeling/Step 4 - Topic Modeling Method Testing.ipynb | autodidact-m/Projects |
 Notes about LDA model performanceLDA is the most frequently used model in conversations about topic modeling. LDA has proven ineffective for this project, it performs poorly at picking up subtle differences in a corpus about the same subject (as in, if I wanted to find the difference between Apple products and apple the fruit, LDA would probably work, but not if I need to find the difference between cases where the majority of the text is about the law). Likely because LDA can only use a count vectorizer rather than a tfidf, so this bag of words is a serious limitation to finding how these documents relate. Truncated SVD (LSA) ModelThis transformer performs linear dimensionality reduction by means of truncated singular value decomposition (SVD). It is very similar to PCA, but operates on sample vectors directly, instead of on a covariance matrix. This means it can work with scipy.sparse matrices efficiently.Notes: SVD suffers from a problem called “sign indeterminancy”, which means the sign of the components_ and the output from transform depend on the algorithm and random state. To work around this, fit instances of this class to data once, then keep the instance around to do transformations.  | modeler(doc_list.lem, 100, 30, TruncatedSVD(2, algorithm = 'arpack'), TfidfVectorizer(max_df=.8, min_df=2,stop_words='english')) | _____no_output_____ | Apache-2.0 | Topic Modeling/Step 4 - Topic Modeling Method Testing.ipynb | autodidact-m/Projects |
 Notes about LSA performanceIssues similar to LDA - it's good at pulling out the law themes, but that's not really what we need. We need the law terms to not play a role at all in modeling for these topics - we know that this entire corpus is about the law, but we need to know what KIND of law each case within the corpus is about. NMF modelFind two non-negative matrices (W, H) whose product approximates the non- negative matrix X. This factorization can be used for example for dimensionality reduction, source separation or topic extraction.  | modeler(doc_list.lem, 30, 30, NMF(n_components=30, random_state=1, alpha=.1, l1_ratio=.5), \
TfidfVectorizer(max_df=.98, min_df=2,stop_words='english')) | _____no_output_____ | Apache-2.0 | Topic Modeling/Step 4 - Topic Modeling Method Testing.ipynb | autodidact-m/Projects |
Assignment: SQL Notebook for Peer AssignmentEstimated time needed: **60** minutes. IntroductionUsing this Python notebook you will:1. Understand the Spacex DataSet2. Load the dataset into the corresponding table in a Db2 database3. Execute SQL queries to answer assignment questions Overview of the DataSetSpaceX has gained worldwide attention for a series of historic milestones.It is the only private company ever to return a spacecraft from low-earth orbit, which it first accomplished in December 2010.SpaceX advertises Falcon 9 rocket launches on its website with a cost of 62 million dollars wheras other providers cost upward of 165 million dollars each, much of the savings is because Space X can reuse the first stage.Therefore if we can determine if the first stage will land, we can determine the cost of a launch.This information can be used if an alternate company wants to bid against SpaceX for a rocket launch.This dataset includes a record for each payload carried during a SpaceX mission into outer space. Download the datasetsThis assignment requires you to load the spacex dataset.In many cases the dataset to be analyzed is available as a .CSV (comma separated values) file, perhaps on the internet. Click on the link below to download and save the dataset (.CSV file):Spacex DataSet Store the dataset in database table**it is highly recommended to manually load the table using the database console LOAD tool in DB2**.Now open the Db2 console, open the LOAD tool, Select / Drag the .CSV file for the dataset, Next create a New Table, and then follow the steps on-screen instructions to load the data. Name the new table as follows:**SPACEXDATASET****Follow these steps while using old DB2 UI which is having Open Console Screen****Note:While loading Spacex dataset, ensure that detect datatypes is disabled. Later click on the pencil icon(edit option).**1. Change the Date Format by manually typing DD-MM-YYYY and timestamp format as DD-MM-YYYY HH\:MM:SS2. Change the PAYLOAD_MASS\_\_KG\_ datatype to INTEGER. **Changes to be considered when having DB2 instance with the new UI having Go to UI screen*** Refer to this insruction in this link for viewing the new Go to UI screen.* Later click on **Data link(below SQL)** in the Go to UI screen and click on **Load Data** tab.* Later browse for the downloaded spacex file.* Once done select the schema andload the file. | !pip install sqlalchemy==1.3.9
!pip install ibm_db_sa
!pip install ipython-sql | Collecting sqlalchemy==1.3.9
Downloading SQLAlchemy-1.3.9.tar.gz (6.0 MB)
Using legacy 'setup.py install' for sqlalchemy, since package 'wheel' is not installed.
Installing collected packages: sqlalchemy
Running setup.py install for sqlalchemy: started
Running setup.py install for sqlalchemy: finished with status 'done'
Successfully installed sqlalchemy-1.3.9
| MIT | Week 2 - SQL/jupyter-labs-eda-sql-coursera.ipynb | pFontanilla/ibm-applied-datascience-capstone |
Connect to the databaseLet us first load the SQL extension and establish a connection with the database | %load_ext sql | _____no_output_____ | MIT | Week 2 - SQL/jupyter-labs-eda-sql-coursera.ipynb | pFontanilla/ibm-applied-datascience-capstone |
**DB2 magic in case of old UI service credentials.**In the next cell enter your db2 connection string. Recall you created Service Credentials for your Db2 instance before. From the **uri** field of your Db2 service credentials copy everything after db2:// (except the double quote at the end) and paste it in the cell below after ibm_db_sa://in the following format**%sql ibm_db_sa://my-username:my-password\@my-hostname:my-port/my-db-name****DB2 magic in case of new UI service credentials.** * Use the following format.* Add security=SSL at the end**%sql ibm_db_sa://my-username:my-password\@my-hostname:my-port/my-db-name?security=SSL** | %sql ibm_db_sa://gmb99703:n8jwm8hlw2k7hr^[email protected]:50000/BLUDB
%sql select TABSCHEMA, TABNAME, CREATE_TIME from SYSCAT.TABLES where TABSCHEMA='GMB99703'
%sql SELECT * FROM SPACEXDATASET LIMIT 20 | * ibm_db_sa://gmb99703:***@dashdb-txn-sbox-yp-dal09-04.services.dal.bluemix.net:50000/BLUDB
Done.
* ibm_db_sa://gmb99703:***@dashdb-txn-sbox-yp-dal09-04.services.dal.bluemix.net:50000/BLUDB
Done.
| MIT | Week 2 - SQL/jupyter-labs-eda-sql-coursera.ipynb | pFontanilla/ibm-applied-datascience-capstone |
TasksNow write and execute SQL queries to solve the assignment tasks. Task 1 Display the names of the unique launch sites in the space mission | %sql SELECT UNIQUE LAUNCH_SITE FROM SPACEXDATASET | * ibm_db_sa://gmb99703:***@dashdb-txn-sbox-yp-dal09-04.services.dal.bluemix.net:50000/BLUDB
Done.
| MIT | Week 2 - SQL/jupyter-labs-eda-sql-coursera.ipynb | pFontanilla/ibm-applied-datascience-capstone |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.