{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# ETHZ: 227-0966-00L\n",
"# Quantitative Big Imaging\n",
"# April 23, 2020\n",
"\n",
"## Statistics and Reproducibility\n",
"\n",
"#### Anders Kaestner"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"slideshow": {
"slide_type": "skip"
}
},
"outputs": [],
"source": [
"%load_ext autoreload\n",
"%autoreload 2\n",
"import seaborn as sns\n",
"import matplotlib.pyplot as plt\n",
"plt.rcParams[\"figure.figsize\"] = (8, 8)\n",
"plt.rcParams[\"figure.dpi\"] = 150\n",
"plt.rcParams[\"font.size\"] = 14\n",
"plt.rcParams['font.family'] = ['sans-serif']\n",
"plt.rcParams['font.sans-serif'] = ['DejaVu Sans']\n",
"plt.style.use('ggplot')\n",
"sns.set_style(\"whitegrid\", {'axes.grid': False})"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Literature / Useful References\n",
"\n",
"### Books\n",
"- Jean Claude, Morphometry with R\n",
" - [Online](http://link.springer.com/book/10.1007%2F978-0-387-77789-4) through ETHZ\n",
" - __Chapter 3__\n",
" - [Buy it](http://www.amazon.com/Morphometrics-R-Use-Julien-Claude/dp/038777789X)\n",
"- John C. Russ, âThe Image Processing Handbookâ,(Boca Raton, CRC Press)\n",
" - Available [online](http://dx.doi.org/10.1201/9780203881095) within domain ethz.ch (or proxy.ethz.ch / public VPN) \n",
"- [Hypothesis Testing Chapter](http://www.sagepub.com/upm-data/40007_Chapter8.pdf)\n",
"- Grammar of Graphics: Leland and Wilkinson - http://www.springer.com/gp/book/9780387245447"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### Videos / Podcasts\n",
"- Google/Stanford Statistics Intro\n",
" - https://www.youtube.com/watch?v=YFC2KUmEebc\n",
"- Last Week Tonight: Scientific Studies\n",
" - https://www.youtube.com/watch?v=0Rnq1NpHdmw\n",
"- Credibility Crisis \n",
" - https://www.datacamp.com/community/podcast/credibility-crisis-in-data-science"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### Slides\n",
"- How to solve NLP problems\n",
" - https://twitter.com/sleepinyourhat/status/1105946169165955073?s=20\n",
"- Data Visualization\n",
" - https://socviz.co/lookatdata.html\n",
"- P-Values with Puppies\n",
" - https://hackernoon.com/explaining-p-values-with-puppies-af63d68005d0\n",
"\n",
"### Model Evaluation\n",
"\n",
"- [Julia Evans - Recalling with Precision](https://www.youtube.com/watch?v=ryZL4XNUmwo)\n",
"- [Stripe's Next Top Model](https://github.com/stripe/topmodel)\n",
"\n",
"### Iris Dataset\n",
"\n",
"- The Iris dataset was used in Fisher's classic 1936 paper, The Use of Multiple Measurements in Taxonomic Problems: http://rcs.chemometrics.ru/Tutorials/classification/Fisher.pdf"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### Papers / Sites\n",
"- [Matlab Unit Testing Documentation](http://www.mathworks.ch/ch/help/matlab/matlab-unit-test-framework.html\n",
")\n",
"- [Databases Introduction](http://swcarpentry.github.io/sql-novice-survey/)\n",
"- [Visualizing Genomic Data](http://circos.ca/documentation/course/visualizing-genomic-data.pdf) (General Visualization Techniques)\n",
"- [NIMRod Parameter Studies](http://www.messagelab.monash.edu.au/nimrod)\n",
"\n",
"- M.E. Wolak, D.J. Fairbairn, Y.R. Paulsen (2012) Guidelines for Estimating Repeatability. Methods in Ecology and Evolution 3(1):129-137.\n",
"- David J.C. MacKay, Bayesian Interpolartion (1991) [http://citeseer.ist.psu.edu/viewdoc/summary?doi=10.1.1.27.9072]"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Previously on QBI ...\n",
"\n",
"- Image Enhancment \n",
" - Highlighting the contrast of interest in images\n",
" - Minimizing Noise\n",
"- Understanding image histograms\n",
"- Automatic Methods\n",
"- Component Labeling\n",
"- Single Shape Analysis\n",
"- Complicated Shapes\n",
"- Dynamic Experiments"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Quantitative \"Big\" Imaging\n",
"\n",
"\n",
"The course has covered imaging enough and there have been a few quantitative metrics, but \"big\" has not really entered.\n",
"\n",
"What does __big__ mean?\n",
"\n",
"- Not just / even large\n",
"- it means being ready for _big data_\n",
"- volume, velocity, variety (3 V's)\n",
"- scalable, fast, easy to customize\n",
"\n",
"\n",
"So what is \"big\" imaging\n",
"\n",
"#### >>>> doing analyses in a disciplined manner <<<<\n",
"\n",
" - fixed steps\n",
" - easy to regenerate results\n",
" - no _magic_\n",
" - documentation\n",
" \n",
"#### having everything automated\n",
"\n",
" - 100 samples is as easy as 1 sample\n",
" \n",
"#### being able to adapt and reuse analyses\n",
"\n",
" - one really well working script and modify parameters\n",
" - different types of cells\n",
" - different regions"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Objectives\n",
"\n",
"1. Scientific Studies all try to get to a single number\n",
" - Make sure this number is describing the structure well (what we have covered before)\n",
" - Making sure the number is meaningful (__today!__)\n",
"1. How do we compare the number from different samples and groups?\n",
" - Within a sample or same type of samples\n",
" - Between samples\n",
"1. How do we compare different processing steps like filter choice, minimum volume, resolution, etc?\n",
"1. How do we evaluate our parameter selection?\n",
"1. How can we ensure our techniques do what they are supposed to do?\n",
"1. How can we visualize so much data? Are there rules?"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Outline\n",
"\n",
"- Motivation (Why and How?)\n",
"- Scientific Goals\n",
"- Reproducibility\n",
"- Predicting and Validating\n",
"- Statistical metrics and results\n",
"- Parameterization\n",
" - Parameter sweep\n",
" - Sensitivity analysis\n",
"- Unit Testing\n",
"- Visualization"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# What do we start with?\n",
"\n",
"Going back to our original cell image\n",
"\n",
"1. We have been able to get rid of the noise in the image and find all the cells (lecture 2-4)\n",
"1. We have analyzed the shape of the cells using the shape tensor (lecture 5)\n",
"1. We even separated cells joined together using Watershed (lecture 6)\n",
"1. We have created even more metrics characterizing the distribution (lecture 7)\n",
"\n",
"We have at least a few samples (or different regions), large number of metrics and an almost as large number of parameters to _tune_\n",
"\n",
"### How do we do something meaningful with it?"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Correlation and Causation\n",
"\n",
"\n",
"One of the most repeated criticisms of scientific work is that correlation and causation are confused. \n",
"\n",
"1. Correlation \n",
" - means a statistical relationship\n",
" - very easy to show (single calculation)\n",
"2. Causation \n",
" - implies there is a mechanism between A and B\n",
" - very difficult to show (impossible to prove)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Observational or Controlled\n",
"\n",
"There are two broad classes of data and scientific studies. \n",
"
\n",
"
\n",
"
Observational
Controlled
\n",
"
\n",
"
\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"## Observational\n",
"\n",
" - Exploring large datasets looking for trends\n",
" - Population is random\n",
" - Not always hypothesis driven\n",
" - Rarely leads to causation\n",
"\n",
"\n",
"#### Examples\n",
"- We examined 100 people \n",
" - the ones with blue eyes were on average 10cm taller\n",
" \n",
"- In 100 cake samples\n",
" - we found a 0.9 correlation between cooking time and bubble size"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"## Controlled\n",
"\n",
" - Most scientific studies fall into this category\n",
" - Specifics of the groups are controlled\n",
" - Can lead to causation\n",
"\n",
"#### Examples\n",
"- We examined 50 mice with gene XYZ off and 50 gene XYZ on and as the foot size increased by 10%\n",
"- We increased the temperature and the number of pores in the metal increased by 10%\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Simple Model: Magic / Weighted Coin\n",
"\n",
"\n",
"\n",
"Since most of the experiments in science are usually specific, noisy, and often very complicated and are not usually good teaching examples\n",
"\n",
"### Magic / Biased Coin\n",
"You buy a _magic_ coin at a shop\n",
"\n",
"#### How many times do you need to flip it to _prove_ it is not fair?\n",
" - If I flip it 10 times and another person flips it 10 times, is that the same as 20 flips?\n",
" - If I flip it 10 times and then multiply the results by 10 is that the same as 100 flips?\n",
" - If I buy 10 coins and want to know which ones are fair what do I do?\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Simple Model: Magic / Weighted Coin\n",
"\n",
"\n",
"1. Each coin represents a stochastic variable $\\mathcal{X}$ and each flip represents an observation $\\mathcal{X}_i$.\n",
"1. The act of performing a coin flip $\\mathcal{F}$ is an observation $\\mathcal{X}_i = \\mathcal{F}(\\mathcal{X})$\n",
"\n",
"We normally assume\n",
"\n",
"1. A _fair_ coin has an expected value of $E(\\mathcal{X})=\\frac{1}{2}$:\n",
" - 50% Heads, \n",
" - 50% Tails\n",
" \n",
"1. An _unbiased_ flip(er) means _each flip is independent of the others_\n",
"\n",
"$$ P(\\mathcal{F}_1(\\mathcal{X})*\\mathcal{F}_2(\\mathcal{X}))= P(\\mathcal{F}_1(\\mathcal{X}))*P(\\mathcal{F}_2(\\mathcal{X}))$$\n",
"\n",
" - the expected value of the flip is the same as that of the coin\n",
" \n",
"$$ E(\\prod_{i=0}^\\infty \\mathcal{F}_i(\\mathcal{X})) = E(\\mathcal{X}) $$"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Simple Model to Reality\n",
"\n",
"\n",
"### Coin Flip\n",
"\n",
"1. Each flip gives us a small piece of information about \n",
" - the coin \n",
" - _and_ the flipper\n",
" \n",
"2. More flips provides more information\n",
" - __Random / Stochastic variations__ in coin and flipper __cancel out__\n",
" - __Systematic variations accumulate__"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Simple Model to Reality\n",
"\n",
"### Real Experiment\n",
"\n",
"1. Each measurement tells us about \n",
" - our sample, \n",
" - our instrument, \n",
" - and our analysis\n",
"2. More measurements provide more information\n",
" - Random / Stochastic variations in sample, instrument, and analysis cancel out\n",
" - _Normally_ the analysis has very little to no stochastic variation\n",
" - Systematic variations accumulate"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Iris: A more complicated model\n",
"\n",
"Coin flips are very simple and probably difficult to match to another experiment. \n",
"\n",
"A very popular dataset for learning about such values beyond 'coin-flips' is called the [Iris dataset](http://archive.ics.uci.edu/ml/datasets/iris) which covers\n",
"- a number of measurements \n",
"- from different plants \n",
"- and the corresponding species.\n",
"\n",
"
"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"fig,(ax1,ax2) = plt.subplots(1,2,figsize=(15,5))\n",
"g = sns.swarmplot(data=iris_df, ax=ax1,\n",
" x='target', y='petal length (cm)');g.set_title('High Group Similarity');\n",
"ax2.imshow(plt.imread('../common/figures/FlowerAnatomy.png')); ax2.axis('off');"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Making quantitative statements\n",
"## Intraclass Correlation Coefficient Definition\n",
"\n",
"$$ ICC = \\frac{S_A^2}{S_A^2+S_W^2} $$\n",
"\n",
"where \n",
"- $S_A^2$ is the variance among groups or classes\n",
" - Estimate with the standard deviations of the mean values for each group \n",
"- $S_W^2$ is the variance within groups or classes.\n",
" - Estimate with the average of standard deviations for each group\n",
"\n",
"### Interpretation\n",
"$$\n",
"ICC = \\left\\{\\begin{array}{cl} \n",
"1 & \\mbox{means 100% of the variance is between classes} \\\\\n",
"0 & \\mbox{means 0% of the variance is between classes}\n",
"\\end{array}\\right.\n",
"$$"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Intraclass Correlation Coefficient: Values\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"format": "tab",
"hide_input": true,
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"
"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"def icc_calc(value_name, group_name, data_df):\n",
" data_agg = data_df.groupby(group_name).agg({value_name: ['mean', 'var']}).reset_index()\n",
" data_agg.columns = data_agg.columns.get_level_values(1)\n",
" S_w = data_agg['var'].mean()\n",
" S_a = data_agg['mean'].var()\n",
" return S_a/(S_a+S_w)\n",
"\n",
"fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))\n",
"sns.swarmplot(data=iris_df, ax=ax1,\n",
" x='target', y='sepal width (cm)')\n",
"ax1.set_title('Low Group Similarity\\nICC:{:2.1%}'.format(icc_calc('sepal width (cm)', 'target', iris_df)));\n",
"\n",
"sns.swarmplot(data=iris_df,ax=ax2, \n",
" x='target', y='petal length (cm)')\n",
"ax2.set_title('High Group Similarity\\nICC:{:2.1%}'.format(icc_calc('petal length (cm)', 'target', iris_df)));"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Comparing Groups: Tests\n",
"\n",
"\n",
"Once the reproducibility has been measured, it is possible to compare groups. \n",
"\n",
"The idea is to make a test to assess the likelihood that two groups are the same given the data\n",
"\n",
"1. List assumptions\n",
"1. Establish a null hypothesis\n",
" - Usually that both groups are the same\n",
"1. Calculate the probability of the observations given the truth of the null hypothesis\n",
" - Requires knowledge of probability distribution of the data\n",
" - Modeling can be exceptionally complicated\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Loaded Coin example\n",
"\n",
"We have 1 coin from a magic shop.\n",
"\n",
"- Our assumptions are:\n",
" - we flip and observe flips of coins accurately and independently\n",
" - the coin is invariant and always has the same expected value\n",
" \n",
" \n",
"- Our null hypothesis is the coin is unbiased $E(\\mathcal{X})=0.5$\n",
"- we can calculate the likelihood of a given observation given the number of flips ([p-value](https://en.wikipedia.org/wiki/P-value))\n",
"\n",
"
\n",
"\n",
"
\n",
"\n",
"How good is good enough?"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Comparing Groups: Student's T Distribution\n",
"\n",
"- Since we do not usually know our distribution very well \n",
"- _or_ have enough samples to create a sufficient probability model\n",
"\n",
"### [Student T Distribution](http://en.wikipedia.org/wiki/Student's_t-distribution)\n",
"We assume the distribution of our stochastic variable is normal (Gaussian) and the t-distribution provides an estimate for the mean of the underlying distribution based on few observations.\n",
"\n",
"- We estimate the likelihood of our observed values assuming they are coming from random observations of a normal process\n",
"\n",
"\n",
"\n",
"### [Student T-Test](https://en.wikipedia.org/wiki/Student%27s_t-test)\n",
"\n",
"Incorporates this distribution and provides an easy method for assessing the likelihood that the two given set of observations are coming from the same underlying process (null hypothesis)\n",
"\n",
"- Assume unbiased observations\n",
"- Assume normal distribution"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Multiple Testing Bias\n",
"\n",
"\n",
"Back to the magic coin, let's assume we are trying to publish a paper, \n",
"- we heard a p-value of < 0.05 (5%) was good enough. \n",
"- That means if we get 5 heads we are good!"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"## Probability with increasing number of tosses\n",
"\n",
"$$ P = \\prod_i P(\\mathcal{F}_i(\\mathcal{X}))$$"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"format": "column",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/html": [
"
"
],
"text/plain": [
" n_friends Probability of 5 Heads\n",
"0 1 3.1%\n",
"1 10 27.2%\n",
"2 20 47.0%\n",
"3 40 71.9%\n",
"4 80 92.1%"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"friends_heads_df = pd.DataFrame({'n_friends': [1, 10, 20, 40, 80]})\n",
"friends_heads_df['Probability of 5 Heads'] = friends_heads_df['n_friends'].map(\n",
" lambda n_friends: '{:2.1%}'.format((1-(1-0.5**5)**n_friends)))\n",
"display(friends_heads_df)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Clearly this is not the case, otherwise we could keep flipping coins or ask all of our friends to flip until we got 5 heads and publish\n",
"\n",
"The p-value is only meaningful when the experiment matches what we did. \n",
"#### We didn't say the chance of getting 5 heads ever was < 5%\n",
"#### We said is if we have \n",
"- exactly 5 observations \n",
"- and all of them are heads \n",
"- the likelihood that a fair coin produced that result is <5%\n",
"\n",
"#### There are many [methods](http://en.wikipedia.org/wiki/Multiple_comparisons_problem) to correct.\n",
"\n",
"Most just involve scaling $p$: \n",
"- The likelihood of a sequence of 5 heads in a row if you perform 10 flips is 5x higher."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Multiple Testing Bias: Experiments\n",
"\n",
"\n",
"This is very bad news for us. We have the ability to quantify all sorts of interesting metrics \n",
"- cell distance to other cells\n",
"- cell oblateness\n",
"- cell distribution oblateness\n",
"\n",
"So lets throw them all into a magical statistics algorithm and push the __publish__ button\n",
"\n",
"\n",
"With our p value of less than 0.05 and a study with 10 samples in each group, how does increasing the number of variables affect our result"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"format": "column",
"scrolled": true,
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [
{
"data": {
"text/html": [
"
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"var_find_df = pd.DataFrame({'Variables': np.linspace(1, 100, 30).astype(int)})\n",
"var_find_df['Likelihood of Detecting Really Different Variable'] = var_find_df['Variables'].map(\n",
" lambda var_count: np.mean(np.array(out_p_value)*var_count<0.05)\n",
")\n",
"fig, ax1 = plt.subplots(1, 1, figsize=(15, 5))\n",
"var_find_df.plot('Variables', 'Likelihood of Detecting Really Different Variable', ax=ax1)\n",
"ax1.set_ylabel('% Likelihood');"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Predicting and Validating - main categories\n",
"\n",
"\n",
"\n",
"Borrowed from http://peekaboo-vision.blogspot.ch/2013/01/machine-learning-cheat-sheet-for-scikit.html\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Overview\n",
"\n",
"\n",
"Basically all of these are ultimately functions which map inputs to outputs. \n",
"\n",
"#### The input could be \n",
"\n",
"- an image\n",
"- a point\n",
"- a feature vector\n",
"- or a multidimensional tensor\n",
"\n",
"#### The output is\n",
"\n",
"- a value (regression)\n",
"- a classification (classification)\n",
"- a group (clustering)\n",
"- a vector / matrix / tensor with _fewer_ degrees of input / less noise as the original data (dimensionality reduction)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### Overfitting\n",
"\n",
"The most serious problem with machine learning and such approachs is overfitting your model to your data. Particularly as models get increasingly complex (random forest, neural networks, deep learning, ...), it becomes more and more difficult to apply common sense or even understand exactly what a model is doing and why a given answer is produced. \n",
"\n",
"```python\n",
"magic_classifier = {}\n",
"# training\n",
"magic_classifier['Dog'] = 'Animal'\n",
"magic_classifier['Bob'] = 'Person'\n",
"magic_classifier['Fish'] = 'Animal'\n",
"```\n",
"\n",
"Now use this classifier, on the training data it works really well\n",
"\n",
"```python\n",
"magic_classifier['Dog'] == 'Animal' # true, 1/1 so far!\n",
"magic_classifier['Bob'] == 'Person' # true, 2/2 still perfect!\n",
"magic_classifier['Fish'] == 'Animal' # true, 3/3, wow!\n",
"```\n",
"\n",
"On new data it doesn't work at all, it doesn't even execute.\n",
"\n",
"```python\n",
"magic_classifier['Octopus'] == 'Animal' # exception?! but it was working so well\n",
"magic_classifier['Dan'] == 'Person' # exception?! \n",
"```\n",
"\n",
"The above example appeared to be a perfect trainer for mapping names to animals or people, but it just memorized the inputs and reproduced them at the output and so didn't actually learn anything, it just copied."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Validation\n",
"\n",
"\n",
"Relevant for each of the categories, but applied in a slightly different way depending on the group. The idea is two divide the dataset into groups called training and validation or ideally training, validation, and testing. \n",
"\n",
"The analysis is then \n",
"\n",
"- developed on __training__\n",
"- iteratively validated on __validation__\n",
"- ultimately tested on __testing__"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "skip"
}
},
"source": [
"# Concrete Example: Classifying Flowers\n",
"\n",
"\n",
"Here we return to the iris data set and try to automatically classify flowers"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"slideshow": {
"slide_type": "skip"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
sepal length (cm)
\n",
"
sepal width (cm)
\n",
"
petal length (cm)
\n",
"
petal width (cm)
\n",
"
target
\n",
"
\n",
" \n",
" \n",
"
\n",
"
41
\n",
"
4.5
\n",
"
2.3
\n",
"
1.3
\n",
"
0.3
\n",
"
setosa
\n",
"
\n",
"
\n",
"
40
\n",
"
5.0
\n",
"
3.5
\n",
"
1.3
\n",
"
0.3
\n",
"
setosa
\n",
"
\n",
"
\n",
"
33
\n",
"
5.5
\n",
"
4.2
\n",
"
1.4
\n",
"
0.2
\n",
"
setosa
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" sepal length (cm) sepal width (cm) petal length (cm) petal width (cm) \\\n",
"41 4.5 2.3 1.3 0.3 \n",
"40 5.0 3.5 1.3 0.3 \n",
"33 5.5 4.2 1.4 0.2 \n",
"\n",
" target \n",
"41 setosa \n",
"40 setosa \n",
"33 setosa "
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from sklearn.datasets import load_iris\n",
"import pandas as pd\n",
"import seaborn as sns\n",
"import matplotlib.pyplot as plt\n",
"data = load_iris()\n",
"iris_df = pd.DataFrame(data['data'], columns=data['feature_names'])\n",
"iris_df['target'] = data['target_names'][data['target']]\n",
"iris_df.sample(3)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Qualitative vs Quantitative\n",
"\n",
"Given the complexity of the tree, we need to do some pruning\n",
"\n",
"### Qualitative Assessment\n",
" - Evaluating metrics using visual feedback\n",
" - Compare with expectations from other independent techniques or approach\n",
" - Are there artifacts which are included in the output?\n",
" - Do the shapes look correct?\n",
" - Are they distributed as expected?\n",
" - Is their orientation meaningful?\n",
" \n",
"\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Quantitative Metrics\n",
"\n",
"\n",
"With a quantitative approach, we can calculate \n",
"- the specific shape \n",
"- or distribution metrics on the sample \n",
"\n",
"with each parameter and establish the relationship between \n",
"- parameter \n",
"- and metric. "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Parameters"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"hide_input": true,
"scrolled": false
},
"outputs": [
{
"data": {
"image/svg+xml": [
"\r\n",
"\r\n",
"\r\n",
"\r\n",
"\r\n"
],
"text/plain": [
""
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from graphviz import Digraph\n",
"\n",
"dot = Digraph()\n",
"\n",
"dot.node('Raw images',color='limegreen'), dot.node('Gaussian filter', color='lightblue')\n",
"dot.node('sigma=0.5', color='gray',shape='box'), dot.node('3x3 Neighbors', color='gray',shape='box')\n",
"dot.node('Threshold', color='lightblue'), dot.node('100', color='gray',shape='box')\n",
"dot.node('Thickness analysis',color='hotpink'), dot.node('Shape analysis',color='hotpink')\n",
"dot.node('Input',color='limegreen'), dot.node('Functions', color='lightblue')\n",
"dot.node('Parameters', color='gray',shape='box'),dot.node('Output',color='hotpink')\n",
"\n",
"dot.edge('Raw images', 'Gaussian filter'), dot.edge('sigma=0.5', 'Gaussian filter')\n",
"dot.edge('3x3 Neighbors', 'Gaussian filter'), dot.edge('Gaussian filter','Threshold')\n",
"dot.edge('Threshold', 'Thickness analysis'), dot.edge('Threshold', 'Shape analysis')\n",
"dot.edge('100','Threshold')\n",
"dot"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"## Parameter Sweep\n",
"\n",
"The way we do this is usually a parameter sweep which means \n",
"- taking one (or more) parameters \n",
"- and varying them between the reasonable bounds (judged qualitatively).\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Is it always the same?\n",
"
\n",
"
\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Sensitivity\n",
"\n",
"### Control system theory\n",
"Sensitivity is defined as \n",
"- the change in the value of an output \n",
"- against the change in the input.\n",
"\n",
"\n",
"$$ S = \\frac{|\\Delta \\textrm{Metric}|}{|\\Delta \\textrm{Parameter}|} $$\n",
"\n",
"### Image processing\n",
"Such a strict definition is not particularly useful for image processing since \n",
"- a threshold has a unit of intensity and \n",
"- a metric might be volume which has $m^3$ \n",
"\n",
"$\\rightarrow$ the sensitivity becomes volume per intensity!\n",
"\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Practical Sensitivity\n",
"\n",
"A more common approach is to estimate the variation in this parameter between images or within a single image (automatic threshold methods can be useful for this) and define the sensitivity based on this variation.\n",
"\n",
"It is also common to normalize it with the mean value so the result is a percentage.\n",
"\n",
"$$ S = \\frac{max(\\textrm{Metric})-min(\\textrm{Metric})}{avg(\\textrm{Metric})} $$"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Sensitivity: Real Measurements\n",
"\n",
"\n",
"In this graph it is magnitude of the slope. The steeper the slope the more the metric changes given a small change in the parameter\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Sensitivity: compare more than one variable\n",
"Comparing Different Variables we see that \n",
"- the best (lowest) value for the count sensitivity \n",
"- is the highest for the volume and anisotropy. \n",
"\n",
"\n",
"\n",
"
\n",
" \n",
"### A contradiction - Which metric is more important?\n",
"\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Reproducibility\n",
"A very broad topic with plenty of sub-areas and deeper meanings. We mean two things by reproducibility\n",
"\n",
"### Analysis\n",
"The process of going from images to numbers is detailed in a clear manner that __anyone__, __anywhere__ could follow and get the exact (within some tolerance) same numbers from your samples\n",
"\n",
"- No platform dependence\n",
"- No proprietary or \"in house\" algorithms\n",
"- No manual *clicking*, *tweaking*, or *copying*\n",
"- One script to go from image to result\n",
" \n",
"\n",
"\n",
"### Measurement\n",
"Everything for analysis + taking a measurement several times (noise and exact alignment vary each time) does not change the statistics _significantly_\n",
"\n",
"- No sensitivity to mounting or rotation\n",
"- No sensitivity to noise\n",
"- No dependence on exact illumination"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Reproducible Analysis\n",
"\n",
"Since we will need to perform the same analysis many times to understand how reproducible it is.\n",
"\n",
"- Notebooks are good to develop and document analysis workflow.\n",
"- The basis for reproducible analysis are scripts and macros. \n",
"\n",
"### With python scripts\n",
"```python\n",
"#!/$PYTHONPATH/python\n",
"import sys\n",
"from myAnalysis import analysisScript # some analysis script you implemented\n",
"\n",
"imageFile = sys.argv[0] # File name from command line\n",
"\n",
"threshold = 130\n",
"analysisScript(fname=imageFile, threshold = threshold)\n",
"```\n",
"\n",
"\n",
"### or Matlab, ImageJ, or R\n",
"```bash\n",
"IMAGEFILE=$1\n",
"THRESHOLD=130\n",
"matlab -r \"inImage=$IMAGEFILE; threshImage=inImage>$THRESHOLD; analysisScript;\"\n",
"```\n",
"- __or__ \n",
"```java -jar ij.jar -macro TestMacro.ijm blobs.tif```\n",
"- __or__\n",
"```Rscript -e \"library(plyr);...\"```"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Some software engineering - Unit testing"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Unit Testing\n",
"\n",
"In computer programming, unit testing is a method by which individual units of source code, sets of one or more computer program modules together with associated control data, usage procedures, and operating procedures, are tested to determine if they are fit for use.\n",
"\n",
"- Intuitively, one can view a unit as the smallest testable part of an application\n",
"- Unit testing is possible with every language\n",
"- Most (Java, C++, Matlab, R, Python) have built in support for automated testing and reporting\n",
"\n",
"[Comoutational science: ... Error](http://doi.org/10.1038/467775a)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Unit Testing - design\n",
"The first requirement for unit testing to work well is to have your code divided up into small independent parts (functions)\n",
"### What to test\n",
"- Each part can then be tested independently (unit testing)\n",
" - If the tests are well done, units can be changed and tested independently\n",
" - Makes upgrading or expanding tools _easy_\n",
"- The entire path can be tested (integration testing)\n",
" - Catches mistakes in integration or _glue_\n",
"\n",
"### How to test\n",
"- The _happy path_ - check what it is supposed to do\n",
"- To __provoke__ your code - provide data that will fail execution\n",
"\n",
"### Test data\n",
"Ideally with realistic but simulated test data\n",
"\n",
"
\n",
"
The utility of the testing is only as good as the tests you make
\n",
"
\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"## Example\n",
"Given the following function\n",
"```function vxCnt=countVoxs(inImage)```\n",
"\n",
"We can write the following tests:\n",
"\n",
"#### _testEmpty2d_ \n",
"```assert countVoxs(zeros(3,3)) == 0```\n",
"\n",
"#### testEmpty3d\n",
"```assert countVoxs(zeros(3,3,3)) == 0```\n",
"\n",
"#### testDiag2d\n",
"```assert countVoxs(eye(3)) == 3```"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Unit Testing: Example\n",
"Given the following function\n",
"```function shapeTable=shapeAnalysis(inImage)```\n",
"\n",
"We should decompose the function into sub-components with single tasks:"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
"\r\n",
"\r\n",
"\r\n",
"\r\n",
"\r\n"
],
"text/plain": [
""
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from graphviz import Digraph\n",
"dot = Digraph()\n",
"dot.edge('shapeAnalysis(inImage)', 'componentLabel(inImage)'), dot.edge('shapeAnalysis(inImage)', 'analyzeObject(inObject)')\n",
"dot.edge('analyzeObject(inObject)','countVoxs(inObject)'), dot.edge('analyzeObject(inObject)','calculateCOV(inObject)')\n",
"dot.edge('analyzeObject(inObject)','calcShapeT(covMat)'), dot.edge('analyzeObject(inObject)','calcOrientation(shapeT)')\n",
"dot.edge('analyzeObject(inObject)','calcAnisotropy(shapeT)')\n",
"dot"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Unit Testing in Python\n",
"\n",
"## PyTest\n",
"Packages like PyTest are \n",
"- well suited for larger projects \n",
"- you make a set of specific tests for each module \n",
"- run each time the project is updated. "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"## Unit testing examples from Scikit Image\n",
"https://github.com/scikit-image/scikit-image/tree/master/skimage\n",
"\n",
"- Test Watershed https://github.com/scikit-image/scikit-image/blob/16d3fd07e7d882d7f6b74e8dc4028ff946ac7e63/skimage/morphology/tests/test_watershed.py#L79\n",
"\n",
"- Test Connected Components https://github.com/scikit-image/scikit-image/blob/16d3fd07e7d882d7f6b74e8dc4028ff946ac7e63/skimage/morphology/tests/test_ccomp.py#L13\n",
"\n",
"```python\n",
"class TestWatershed(unittest.TestCase):\n",
" eight = np.ones((3, 3), bool)\n",
"\n",
" def test_watershed01(self):\n",
" \"watershed 1\"\n",
" data = np.array([[0, 0, 0, 0, 0, 0, 0],\n",
" [0, 0, 0, 0, 0, 0, 0],\n",
" [0, 0, 0, 0, 0, 0, 0],\n",
" [0, 1, 1, 1, 1, 1, 0],\n",
" [0, 1, 0, 0, 0, 1, 0],\n",
" [0, 1, 0, 0, 0, 1, 0],\n",
" [0, 1, 0, 0, 0, 1, 0],\n",
" [0, 1, 1, 1, 1, 1, 0],\n",
" [0, 0, 0, 0, 0, 0, 0],\n",
" [0, 0, 0, 0, 0, 0, 0]], np.uint8)\n",
" markers = np.array([[ -1, 0, 0, 0, 0, 0, 0],\n",
" [0, 0, 0, 0, 0, 0, 0],\n",
" [0, 0, 0, 0, 0, 0, 0],\n",
" [ 0, 0, 0, 0, 0, 0, 0],\n",
" [ 0, 0, 0, 0, 0, 0, 0],\n",
" [ 0, 0, 0, 1, 0, 0, 0],\n",
" [ 0, 0, 0, 0, 0, 0, 0],\n",
" [ 0, 0, 0, 0, 0, 0, 0],\n",
" [ 0, 0, 0, 0, 0, 0, 0],\n",
" [ 0, 0, 0, 0, 0, 0, 0]],\n",
" np.int8)\n",
" out = watershed(data, markers, self.eight)\n",
" expected = np.array([[-1, -1, -1, -1, -1, -1, -1],\n",
" [-1, -1, -1, -1, -1, -1, -1],\n",
" [-1, -1, -1, -1, -1, -1, -1],\n",
" [-1, 1, 1, 1, 1, 1, -1],\n",
" [-1, 1, 1, 1, 1, 1, -1],\n",
" [-1, 1, 1, 1, 1, 1, -1],\n",
" [-1, 1, 1, 1, 1, 1, -1],\n",
" [-1, 1, 1, 1, 1, 1, -1],\n",
" [-1, -1, -1, -1, -1, -1, -1],\n",
" [-1, -1, -1, -1, -1, -1, -1]])\n",
" error = diff(expected, out)\n",
" assert error < eps\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"## DocTests\n",
"\n",
"Keep the tests in the code itself: https://github.com/scikit-image/scikit-image/blob/16d3fd07e7d882d7f6b74e8dc4028ff946ac7e63/skimage/filters/thresholding.py#L886\n",
"```python\n",
"def apply_hysteresis_threshold(image, low, high):\n",
" \"\"\"Apply hysteresis thresholding to `image`.\n",
" This algorithm finds regions where `image` is greater than `high`\n",
" OR `image` is greater than `low` *and* that region is connected to\n",
" a region greater than `high`.\n",
" Parameters\n",
" ----------\n",
" image : array, shape (M,[ N, ..., P])\n",
" Grayscale input image.\n",
" low : float, or array of same shape as `image`\n",
" Lower threshold.\n",
" high : float, or array of same shape as `image`\n",
" Higher threshold.\n",
" Returns\n",
" -------\n",
" thresholded : array of bool, same shape as `image`\n",
" Array in which `True` indicates the locations where `image`\n",
" was above the hysteresis threshold.\n",
" Examples\n",
" --------\n",
" >>> image = np.array([1, 2, 3, 2, 1, 2, 1, 3, 2])\n",
" >>> apply_hysteresis_threshold(image, 1.5, 2.5).astype(int)\n",
" array([0, 1, 1, 1, 0, 0, 0, 1, 1])\n",
" References\n",
" ----------\n",
" .. [1] J. Canny. A computational approach to edge detection.\n",
" IEEE Transactions on Pattern Analysis and Machine Intelligence.\n",
" 1986; vol. 8, pp.679-698.\n",
" DOI: 10.1109/TPAMI.1986.4767851\n",
" \"\"\"\n",
" low = np.clip(low, a_min=None, a_max=high) # ensure low always below high\n",
" mask_low = image > low\n",
" mask_high = image > high\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Unit Testing Jupyter\n",
"Working primarily in notebooks makes regular testing more difficult but not impossible. If we employ a few simple tricks we can use doctesting seamlessly inside of Jupyter. We can make what in python is called an annotatation to setup this code. "
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"import doctest\n",
"import copy\n",
"import functools\n",
"\n",
"def autotest(func):\n",
" globs = copy.copy(globals())\n",
" globs.update({func.__name__: func})\n",
" doctest.run_docstring_examples(\n",
" func, globs, verbose=True, name=func.__name__)\n",
" return func"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"format": "column",
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Finding tests in add_5\n",
"Trying:\n",
" add_5(5)\n",
"Expecting:\n",
" 10\n",
"ok\n"
]
}
],
"source": [
"@autotest\n",
"def add_5(x):\n",
" \"\"\"\n",
" Function adds 5\n",
" >>> add_5(5)\n",
" 10\n",
" \"\"\"\n",
" return x+5\n"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"format": "column",
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Finding tests in simple_label\n",
"Trying:\n",
" test_img = np.eye(3)\n",
"Expecting nothing\n",
"ok\n",
"Trying:\n",
" test_img\n",
"Expecting:\n",
" array([[1., 0., 0.],\n",
" [0., 1., 0.],\n",
" [0., 0., 1.]])\n",
"ok\n",
"Trying:\n",
" simple_label(test_img)\n",
"Expecting:\n",
" array([[1, 0, 0],\n",
" [0, 1, 0],\n",
" [0, 0, 1]])\n",
"**********************************************************************\n",
"File \"__main__\", line 12, in simple_label\n",
"Failed example:\n",
" simple_label(test_img)\n",
"Expected:\n",
" array([[1, 0, 0],\n",
" [0, 1, 0],\n",
" [0, 0, 1]])\n",
"Got:\n",
" array([[1, 0, 0],\n",
" [0, 1, 0],\n",
" [0, 0, 1]], dtype=int64)\n",
"Trying:\n",
" test_img[1,1] = 0\n",
"Expecting nothing\n",
"ok\n",
"Trying:\n",
" simple_label(test_img)\n",
"Expecting:\n",
" array([[1, 0, 0],\n",
" [0, 0, 0],\n",
" [0, 0, 2]])\n",
"**********************************************************************\n",
"File \"__main__\", line 17, in simple_label\n",
"Failed example:\n",
" simple_label(test_img)\n",
"Expected:\n",
" array([[1, 0, 0],\n",
" [0, 0, 0],\n",
" [0, 0, 2]])\n",
"Got:\n",
" array([[1, 0, 0],\n",
" [0, 0, 0],\n",
" [0, 0, 2]], dtype=int64)\n"
]
}
],
"source": [
"from skimage.measure import label\n",
"import numpy as np\n",
"@autotest\n",
"def simple_label(x):\n",
" \"\"\"\n",
" Label an image\n",
" >>> test_img = np.eye(3)\n",
" >>> test_img\n",
" array([[1., 0., 0.],\n",
" [0., 1., 0.],\n",
" [0., 0., 1.]])\n",
" >>> simple_label(test_img)\n",
" array([[1, 0, 0],\n",
" [0, 1, 0],\n",
" [0, 0, 1]])\n",
" >>> test_img[1,1] = 0\n",
" >>> simple_label(test_img)\n",
" array([[1, 0, 0],\n",
" [0, 0, 0],\n",
" [0, 0, 2]])\n",
" \"\"\"\n",
" return label(x)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Unit Testing Matlab\n",
"https://www.mathworks.com/help/matlab/matlab-unit-test-framework.html\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Test Driven Programming\n",
"\n",
"\n",
"Test Driven programming is a style or approach to programming where the tests are written before the functional code. Like very concrete specifications. It is easy to estimate how much time is left since you can automatically see how many of the tests have been passed. You and your collaborators are clear on the utility of the system.\n",
"\n",
"1. shapeAnalysis must give an anisotropy of 0 when we input a sphere\n",
"1. shapeAnalysis must give the center of volume within 0.5 pixels\n",
"1. shapeAnalysis must run on a 1000x1000 image in 30 seconds"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Continuous Integration\n",
"Conntinuous integration is the process of running tests automatically everytime changes are made. \n",
"\n",
"This is possible to setup inside of many IDEs and is offered as a commercial service from companies like CircleCI and Travis. \n",
"\n",
"We use them for the QBI course to make sure all of the code in the slides are correct. \n",
"\n",
"Projects like scikit-image use them to ensure changes that are made do not break existing code without requiring manual checks"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Presenting the results - bringing out the message"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Visualization\n",
"\n",
"\n",
"One of the biggest problems with _big_ sciences is trying to visualize a lot of heterogeneous data. \n",
"\n",
"- Tables are difficult to interpret\n",
"- 3D Visualizations are very difficult to compare visually \n",
"- Contradictory necessity of simple single value results and all of the data to look for trends and find problems"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Color maps revisited\n",
"Crameri, F., Shephard, G.E. & Heron, P.J. The misuse of colour in science communication. Nat Commun 11, 5444 (2020). https://doi.org/10.1038/s41467-020-19160-7"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Purpose of the visualization\n",
"\n",
"You visualize your data for different reasons:\n",
"### Understanding and exploration \n",
"- Small and known audience (you and colleagues)\n",
"- High degree of understanding of specific topic.\n",
" \n",
"### Presenting your results\n",
"- Wider and sometimes unknown audience (reader of paper, person listening to presentation)\n",
"- At best general understanding of the topic.\n",
" \n",
" from [Knaflic 2015](https://doi.org/10.1002/9781119055259)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Bad Graphs\n",
"\n",
"There are too many graphs which say:\n",
"\n",
"- *my data is very complicated*\n",
"- *I know how to use __ toolbox in Matlab/R/Mathematica*\n",
"- Most programs by default make poor plots\n",
"- Good visualizations takes time to produce\n",
"\n",
"
\n",
"
\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# How to improve - Key Ideas \n",
"\n",
"\n",
"1. What is my message? \n",
"1. Does the graphic communicate it clearly?\n",
"1. Is a graphic representation really necessary?\n",
" - Does every line / color serve a purpose?\n",
" - Pretend ink is very expensive\n",
"\n",
"#### Some literature\n",
"- [Few, Should data visualization always be beautiful?, 2012](https://www.perceptualedge.com/blog/?p=1169)\n",
"\n",
"- [Knaflic, Storytelling with Data: A Data Visualization Guide for Business Professionals, 2015](https://doi.org/10.1002/9781119055259)\n",
"\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### Simple Rules\n",
"\n",
"1. Never use 3D graphics when it can be avoided (unless you want to be deliberately misleading)\n",
"\n",
"1. Pie charts can also be hard to interpret\n",
"1. Background color should almost always be white (not light gray)\n",
"1. Use color palettes adapted to human visual sensitivity \n",
"1. Use colors and transparency smart\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# What is my message\n",
"Plots to \"show the results\" or \"get a feeling\" are usually not good"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"
"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
""
]
},
"execution_count": 40,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(ggplot(df,aes(x='x',y='y'))\n",
" + geom_density_2d(aes(x='x', y='y', color='..level..'))\n",
" + geom_smooth(method=\"lm\")\n",
" + coord_equal() \n",
" + labs(color=\"Type\")\n",
" + theme_bw(15)\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Grammar of Graphics\n",
"\n",
"\n",
"### What is a grammar?\n",
"- Set of rules for constructing and validating a sentence\n",
"- Specifies the relationship and order between the words constituting the sentence"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"## How does grammar apply to graphics?\n",
"If we develop a consistent way of \n",
"- expressing graphics (sentences) \n",
"- in terms of elements (words) \n",
"we can compose and decompose graphics easily\n",
"\n",
"\n",
"The most important modern work in graphical grammars is [\"The Grammar of Graphics\"](https://doi.org/10.1007/0-387-28695-0) by Wilkinson, Anand, and Grossman (2005). \n",
"\n",
"This work built on earlier work by Bertin (1983) and proposed a grammar that can be used to describe and construct a wide range of statistical graphics.\n",
"\n",
"\n",
"\n",
"#### Graphics in python\n",
"- Graphical grammar can be applied in [R using the ggplot2 library](https://doi.org/10.1007/978-3-319-24277-4), which is ported to [python](https://www.datascienceworkshops.com/blog/plotnine-grammar-of-graphics-for-python).\n",
"- Matplotlib does not support grammar but is still very useful:\n",
"[Matplotlib 3.0 Cookbook](https://www.packtpub.com/big-data-and-business-intelligence/matplotlib-30-cookbook) [ETHZ lib](https://learning.oreilly.com/library/view/matplotlib-30-cookbook/9781789135718), [code examples](https://github.com/PacktPublishing/Matplotlib-3.0-Cookbook)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Grammar Explained\n",
"\n",
"Normally we think of plots in terms of some sort of data which is fed into a plot command that produces a picture\n",
"- In Excel you select a range and plot-type and click \"Make\"\n",
"- In Matlab you run ```plot(xdata,ydata,color/shape)``` \n",
"\n",
"1. These produces entire graphics (sentences) or at least phrases in one go and thus abstract away from the idea of grammar. \n",
"1. If you spoke by finding entire sentences in a book it would be very ineffective, it is much better to build up word by word\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### Grammar\n",
"\n",
"Separate the graph into its component parts\n",
"\n",
"
\n",
"\n",
"
Data mapping
Points
Axes/Coordinate system
Labels/annotation
\n",
"
\n",
"
$var1 \\rightarrow x$, $var2 \\rightarrow y$
\n",
"
\n",
"
\n",
"
\n",
"
\n",
"
\n",
"\n",
"Construct graphics by focusing on each portion independently."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Wrapping up\n",
"\n",
"\n",
"- I am not a statistician and is not a statistics course\n",
"- If you have questions or concerns\n",
" - Both ETHZ and Uni Zurich offer __free__ consultation with real statisticians\n",
" - They are rarely bearers of good news - you allways need more data... \n",
" \n",
"- Simulations (even simple ones) are very helpful \n",
"- Try and understand the tests you are performing\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "skip"
}
},
"source": [
"# Old slides to transfer from R to python"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "skip"
}
},
"source": [
"[old lecture 2017](https://rawgit.com/Quantitative-Big-Imaging/Quantitative-Big-Imaging-2017/master/Lectures/08-Slides.html#(53))\n",
"[old lecture 2019](https://github.com/kmader/Quantitative-Big-Imaging-2019)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"slideshow": {
"slide_type": "skip"
}
},
"outputs": [],
"source": [
"# Old parameter sweep figure, needs translation from R\n",
"import sys\n",
"sys.path.append(\"../common/scripts/\")\n",
"import shapeAnalysisProcess\n",
"import commonReportFunctions\n",
"\n",
"# read and correct the coordinate system\n",
"def threshfun(x) :\n",
" pth = rev(strsplit(x,\"/\")[[1]])[2]\n",
" t=strsplit(pth,\"_\")[[1]][3]\n",
" # as.numeric(substring(t,2,nchar(t)))\n",
"\n",
"def readfcn(x) :\n",
" cbind(compare.foam.corrected(x,checkProj=F),thresh=thresh.fun(x))\n",
" # Where are the csv files located\n",
" rootDir=\"../common/data/mcastudy\" \n",
" clpor.files=Sys.glob(paste(rootDir,\"/a*/lacun_0.csv\",sep=\"/\")) # list all of the files\n",
" data = ldply(clpor.files,readfcn,.parallel=T) # Read in all of the files\n",
" df = pd.DataFrame(data)\n",
" \n",
" return df;\n",
"\n",
"lacun=readfcn(10)\n",
"\n",
"(ggplot(lacun,aes(y=VOLUME*1e9,x=thresh))\n",
"+ geom_jitter(alpha=0.1)+geom_smooth()\n",
"+ theme_bw(24)\n",
"+ labs(y=\"Volume (um3)\",x=\"Threshold Value\",color=\"Threshold\")\n",
"+ ylim(0,1000))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"slideshow": {
"slide_type": "skip"
}
},
"outputs": [],
"source": [
"(ggplot(subset(lacun,thresh %% 1000==0),aes(y=VOLUME*1e9,x=as.factor(thresh)))\n",
" + geom_violin()\n",
" + theme_bw(24)\n",
" + labs(y=\"Volume (um3)\",x=\"Threshold Value\",color=\"Threshold\")\n",
" + ylim(0,1000))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"slideshow": {
"slide_type": "skip"
}
},
"outputs": [],
"source": [
"(ggplot(lacun,aes(y=PCA1_Z,x=thresh))+\n",
" + geom_jitter(alpha=0.1)+geom_smooth()+\n",
" + theme_bw(24)\n",
" + labs(y=\"Orientation\",x=\"Threshold Value\",color=\"Threshold\"))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "skip"
}
},
"source": [
"# Sensitivity: Real Measurements\n",
"\n",
"\n",
"In this graph it is magnitude of the slope. The steeper the slope the more the metric changes given a small change in the parameter\n",
"\n",
"```{r , fig.height=5}\n",
"poresum<-function(all.data) ddply(all.data,.(thresh),function(c.sample) {\n",
" data.frame(Count=nrow(c.sample),\n",
" Volume=mean(c.sample$VOLUME*1e9),\n",
" Stretch=mean(c.sample$AISO),\n",
" Oblateness=mean(c.sample$OBLATENESS),\n",
" #Lacuna_Density_mm=1/mean(c.sample$DENSITY_CNT),\n",
" Length=mean(c.sample$PROJ_PCA1*1000),\n",
" Width=mean(c.sample$PROJ_PCA2*1000),\n",
" Height=mean(c.sample$PROJ_PCA3*1000),\n",
" Orientation=mean(abs(c.sample$PCA1_Z)))\n",
"})\n",
"comb.summary<-cbind(poresum(all.lacun),Phase=\"Lacuna\")\n",
"splot<-ggplot(comb.summary,aes(x=thresh))\n",
"splot+geom_line(aes(y=Count))+geom_point(aes(y=Count))+scale_y_log10()+\n",
" theme_bw(24)+labs(y=\"Object Count\",x=\"Threshold\",color=\"Phase\")\n",
"```\n",
"\n",
"Comparing Different Variables we see that the best (lowest) value for the count sensitivity is the highest for the volume and anisotropy. \n",
"\n",
"```{r , fig.height=5}\n",
"calc.sens<-function(in.df) {\n",
" data.frame(sens.cnt=100*with(in.df,(max(Count)-min(Count))/mean(Count)),\n",
" sens.vol=100*with(in.df,(max(Volume)-min(Volume))/mean(Volume)),\n",
" sens.stretch=100*with(in.df,(max(Stretch)-min(Stretch))/mean(Stretch))\n",
" )\n",
"}\n",
"sens.summary<-ddply.cutcols(comb.summary,.(cut_interval(thresh,5)),calc.sens)\n",
"ggplot(sens.summary,aes(x=thresh))+\n",
" geom_line(aes(y=sens.cnt,color=\"Count\"))+\n",
" geom_line(aes(y=sens.vol,color=\"Volume\"))+\n",
" geom_line(aes(y=sens.stretch,color=\"Anisotropy\"))+\n",
" labs(x=\"Threshold\",y=\"Sensitivity (%)\",color=\"Metric\")+\n",
" theme_bw(20)\n",
"```\n",
"\n",
"### Which metric is more important?"
]
}
],
"metadata": {
"celltoolbar": "Slideshow",
"hide_input": false,
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.5"
},
"rise": {
"autolaunch": true,
"enable_chalkboard": true,
"footer": "April 16, 2020 - ETH 227-0966-00L: Quantitative Big Imaging/Statistics and reproducibility",
"header": "
![](\"../common/figures/noun_MuseumVisit.svg\")
![](\"../common/figures/noun_puppet.svg\")
![](\"../common/figures/Iris.png\")
\n",
"![](\"../common/figures/p-value.svg\")
\n",
"![](\"../common/figures/MLalgorithms.png\")
\n",
"\n",
"Borrowed from http://peekaboo-vision.blogspot.ch/2013/01/machine-learning-cheat-sheet-for-scikit.html\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Overview\n",
"\n",
"\n",
"Basically all of these are ultimately functions which map inputs to outputs. \n",
"\n",
"#### The input could be \n",
"\n",
"- an image\n",
"- a point\n",
"- a feature vector\n",
"- or a multidimensional tensor\n",
"\n",
"#### The output is\n",
"\n",
"- a value (regression)\n",
"- a classification (classification)\n",
"- a group (clustering)\n",
"- a vector / matrix / tensor with _fewer_ degrees of input / less noise as the original data (dimensionality reduction)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### Overfitting\n",
"\n",
"The most serious problem with machine learning and such approachs is overfitting your model to your data. Particularly as models get increasingly complex (random forest, neural networks, deep learning, ...), it becomes more and more difficult to apply common sense or even understand exactly what a model is doing and why a given answer is produced. \n",
"\n",
"```python\n",
"magic_classifier = {}\n",
"# training\n",
"magic_classifier['Dog'] = 'Animal'\n",
"magic_classifier['Bob'] = 'Person'\n",
"magic_classifier['Fish'] = 'Animal'\n",
"```\n",
"\n",
"Now use this classifier, on the training data it works really well\n",
"\n",
"```python\n",
"magic_classifier['Dog'] == 'Animal' # true, 1/1 so far!\n",
"magic_classifier['Bob'] == 'Person' # true, 2/2 still perfect!\n",
"magic_classifier['Fish'] == 'Animal' # true, 3/3, wow!\n",
"```\n",
"\n",
"On new data it doesn't work at all, it doesn't even execute.\n",
"\n",
"```python\n",
"magic_classifier['Octopus'] == 'Animal' # exception?! but it was working so well\n",
"magic_classifier['Dan'] == 'Person' # exception?! \n",
"```\n",
"\n",
"The above example appeared to be a perfect trainer for mapping names to animals or people, but it just memorized the inputs and reproduced them at the output and so didn't actually learn anything, it just copied."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Validation\n",
"\n",
"\n",
"Relevant for each of the categories, but applied in a slightly different way depending on the group. The idea is two divide the dataset into groups called training and validation or ideally training, validation, and testing. \n",
"\n",
"The analysis is then \n",
"\n",
"- developed on __training__\n",
"- iteratively validated on __validation__\n",
"- ultimately tested on __testing__"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "skip"
}
},
"source": [
"# Concrete Example: Classifying Flowers\n",
"\n",
"\n",
"Here we return to the iris data set and try to automatically classify flowers"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"slideshow": {
"slide_type": "skip"
}
},
"outputs": [
{
"data": {
"text/html": [
"![](\"../common/figures/parameter_sweep.png\")
"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Is it always the same?\n",
"![](\"../common/figures/parameter_sweep_volume.png\")
![](\"../common/figures/parameter_sweep_orientation.png\")
![](\"../common/figures/sensitivity_counts.png\")
"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Sensitivity: compare more than one variable\n",
"Comparing Different Variables we see that \n",
"- the best (lowest) value for the count sensitivity \n",
"- is the highest for the volume and anisotropy. \n",
"\n",
"![](\"../common/figures/sensitivity_compare.png\")
\n",
"\n",
"![](\"../common/figures/Knaflic_audience.png\")
from [Knaflic 2015](https://doi.org/10.1002/9781119055259)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"# Bad Graphs\n",
"\n",
"There are too many graphs which say:\n",
"\n",
"- *my data is very complicated*\n",
"- *I know how to use __ toolbox in Matlab/R/Mathematica*\n",
"- Most programs by default make poor plots\n",
"- Good visualizations takes time to produce\n",
"\n",
"
![](\"../common/figures/niceplot.svg\")
"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### Grammar\n",
"\n",
"Separate the graph into its component parts\n",
"\n",
"![](\"../common/figures/niceplot_points.png\")
![](\"../common/figures/niceplot_axes.png\")
![](\"../common/figures/niceplot_annotations.png\")
