diff --git a/biostatistics/Method_comparison_Bland_Altman_analysis.ipynb b/biostatistics/Method_comparison_Bland_Altman_analysis.ipynb new file mode 100644 index 0000000..4fb8467 --- /dev/null +++ b/biostatistics/Method_comparison_Bland_Altman_analysis.ipynb @@ -0,0 +1,787 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Method comparison\n", + "Assume for a specific type of measurement, there are two methods for performing it. A common question in this context is if both methods could replace each other. Therefore, similarity of measurements is investigated. One method for this is Bland-Altman analysis called after Martin Bland and Douglas Altman. \n", + "\n", + "See also\n", + "[Measurement in Medicine: the Analysis of Method Comparison Studies](https://www-users.york.ac.uk/~mb55/meas/ab83.pdf)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before we dive into Bland-Altman analysis, we have a look at straight-forward methods for comparing methods. An important assumption is that we worked with paired data. That means we can apply the two measurement methods to the same sample without destroying it and without the two methods harming each other." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AB
014
195
275
317
424
585
694
726
816
975
1084
\n", + "
" + ], + "text/plain": [ + " A B\n", + "0 1 4\n", + "1 9 5\n", + "2 7 5\n", + "3 1 7\n", + "4 2 4\n", + "5 8 5\n", + "6 9 4\n", + "7 2 6\n", + "8 1 6\n", + "9 7 5\n", + "10 8 4" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# make up some data\n", + "measurement_A = [1, 9, 7, 1, 2, 8, 9, 2, 1, 7, 8]\n", + "measurement_B = [4, 5, 5, 7, 4, 5, 4, 6, 6, 5, 4]\n", + "\n", + "# show measurements as table\n", + "pd.DataFrame([measurement_A, measurement_B], [\"A\", \"B\"]).transpose()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Comparison of means\n", + "A very simple method for comparing arrays of measurements is comparing their means." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean(A) = 5.0\n", + "Mean(B) = 5.0\n" + ] + } + ], + "source": [ + "print(\"Mean(A) = \" + str(np.mean(measurement_A)))\n", + "print(\"Mean(B) = \" + str(np.mean(measurement_B)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using this method one could conclude that both methods deliver similar measurements because their mean is equal. However, this might be misleading.\n", + "\n", + "## Scatter plots\n", + "A more visual method for method comparison is drawing scatter plots. In these plots measurements of the one method are plotted against the other method." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(measurement_A, measurement_B, \"*\")\n", + "plt.plot([0, 10], [0, 10])\n", + "plt.axis([0, 10, 0, 10])\n", + "plt.xlabel('measurement A')\n", + "plt.ylabel('measurement B')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Obviously A and B lead to quite different results. If the blue points would lie on the orange line, we would conclude that the measurements are related.\n", + "\n", + "## Histograms\n", + "As we concluded already that both measurements lie in different ranges, we should take a look at the distribution. Histograms are a good plot of choice. To make sure histograms for both measurements are visualized the same, e.g. with the same range on the x-axis, we can write our own little `draw_histogram` function:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def draw_histogram(data):\n", + " counts, bins = np.histogram(data, bins=10, range=(0,10))\n", + " plt.hist(bins[:-1], bins, weights=counts)\n", + " plt.axis([0, 10, 0, 4])\n", + " plt.show()\n", + " \n", + "draw_histogram(measurement_A)\n", + "draw_histogram(measurement_B)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Correlation\n", + "For measuring the relationship between two measurements, we can take [Pearson's definition of a correlation coefficient](https://en.wikipedia.org/wiki/Pearson_correlation_coefficient)\n", + "\n", + "The data for the following expriment is taken from [Altman & Bland, The Statistician 32, 1983](https://www-users.york.ac.uk/~mb55/meas/ab83.pdf), Fig. 1." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# new measurements\n", + "measurement_1 = [130, 132, 138, 145, 148, 150, 155, 160, 161, 170, 175, 178, 182, 182, 188, 195, 195, 200, 200, 204, 210, 210, 215, 220, 200]\n", + "measurement_2 = [122, 130, 135, 132, 140, 151, 145, 150, 160, 150, 160, 179, 168, 175, 187, 170, 182, 179, 195, 190, 180, 195, 210, 190, 200]\n", + "\n", + "# scatter plot\n", + "plt.plot(measurement_1, measurement_2, \"o\")\n", + "plt.plot([120, 220], [120, 220])\n", + "plt.axis([120, 220, 120, 220])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "r = 0.9435300113035253\n" + ] + } + ], + "source": [ + "# Determining Pearson's correlation coefficient r with a for-loop\n", + "import numpy as np\n", + "\n", + "# get the mean of the measurements\n", + "mean_1 = np.mean(measurement_1)\n", + "mean_2 = np.mean(measurement_2)\n", + "\n", + "# get the number of measurements\n", + "n = len(measurement_1)\n", + "\n", + "# get the standard deviation of the measurements\n", + "std_dev_1 = np.std(measurement_1)\n", + "std_dev_2 = np.std(measurement_2)\n", + "\n", + "# sum the expectation of \n", + "sum = 0\n", + "for m_1, m_2 in zip(measurement_1, measurement_2):\n", + " sum = sum + (m_1 - mean_1) * (m_2 - mean_2) / n\n", + "\n", + "r = sum / (std_dev_1 * std_dev_2)\n", + "\n", + "print (\"r = \" + str(r))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9435300113035255" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Determine Pearson's r using scipy\n", + "from scipy import stats\n", + "\n", + "stats.pearsonr(measurement_1, measurement_2)[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bland-Altman plots\n", + "Bland-Altman plots are a way to visualize differences between paired measurements specifically. When googling for python code that draws such plots, one can end up with this solution:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# A function for drawing Bland-Altman plots\n", + "# source https://stackoverflow.com/questions/16399279/bland-altman-plot-in-python\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def bland_altman_plot(data1, data2, *args, **kwargs):\n", + " data1 = np.asarray(data1)\n", + " data2 = np.asarray(data2)\n", + " mean = np.mean([data1, data2], axis=0)\n", + " diff = data1 - data2 # Difference between data1 and data2\n", + " md = np.mean(diff) # Mean of the difference\n", + " sd = np.std(diff, axis=0) # Standard deviation of the difference\n", + "\n", + " plt.scatter(mean, diff, *args, **kwargs)\n", + " plt.axhline(md, color='gray', linestyle='--')\n", + " plt.axhline(md + 1.96*sd, color='gray', linestyle='--')\n", + " plt.axhline(md - 1.96*sd, color='gray', linestyle='--')\n", + " plt.xlabel(\"Average\")\n", + " plt.ylabel(\"Difference\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# draw a Bland-Altman plot\n", + "bland_altman_plot(measurement_1, measurement_2)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alternatively, one can use more advanced visualizations using statsmodels (`pip install statsmodels`). It needs numpy-arrays to work with and doesn't work with lists." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from statsmodels.graphics.agreement import mean_diff_plot\n", + "\n", + "m1 = np.asarray(measurement_1)\n", + "m2 = np.asarray(measurement_2)\n", + "\n", + "plot = mean_diff_plot(m1, m2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "... or [pyCompare](https://github.com/jaketmp/pyCompare) (`pip install pycompare`)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from pyCompare import blandAltman\n", + "\n", + "blandAltman(measurement_1, measurement_2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Some simulated situations\n", + "For simulating some characteristic bland altman plots, we start by setting a ground truth set of numbers, e.g. radii in mm of 100 cherries." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[16.31548019 14.37517473 16.51054449 15.84041798 15.49603976]\n" + ] + } + ], + "source": [ + "radii = np.random.normal(15, scale=1, size=(100))\n", + "\n", + "# for demo purposes: print the first 5\n", + "print(radii[:5])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We assume these radii are the perfect ground truth. We will now measure the size of these cherries twice. Our measurement device is not perfect and thus, has a little error." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[16.39064502 13.86405243 15.65842279 15.24593097 15.40542395]\n", + "[16.45878463 13.28064121 16.83784292 16.22139569 15.47869143]\n" + ] + } + ], + "source": [ + "measurement_r1 = radii + np.random.normal(0, scale=0.5, size=(100))\n", + "measurement_r2 = radii + np.random.normal(0, scale=0.5, size=(100))\n", + "\n", + "print(measurement_r1[:5])\n", + "print(measurement_r2[:5])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plotting these two measurements against each other in a Bland-Altman plot visualizes the agreement between the methods. Note the symmetry of the plot and that the data points are arranged around difference = 0. " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "bland_altman_plot(measurement_r1, measurement_r2)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Additive bias\n", + "If one method tends to measure more than the other method by a fixed offset, we call that an additive bias:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[16.41621805 14.53002778 16.57526139 16.07168847 14.86692817]\n", + "[17.55130903 15.67576592 16.90477155 16.68142297 16.2229812 ]\n" + ] + } + ], + "source": [ + "offset = 1\n", + "\n", + "measurement_r1 = radii + np.random.normal(0, scale=0.5, size=(100))\n", + "measurement_r2 = radii + np.random.normal(0, scale=0.5, size=(100)) + offset\n", + "\n", + "print(measurement_r1[:5])\n", + "print(measurement_r2[:5])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can observe the offset in the Bland-Altman plot because the measurements are arranged around difference = offset:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "bland_altman_plot(measurement_r1, measurement_r2)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Multiplicative bias\n", + "If one method always measures more than the other linearily depending on the measurement itself, we call that a multiplicative bias." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[15.83770873 15.06246167 16.34513459 15.78063121 15.01767525]\n", + "[17.08844099 14.45992546 16.7227079 15.95087408 15.82241279]\n" + ] + } + ], + "source": [ + "factor = 1.1\n", + "\n", + "measurement_r1 = radii + np.random.normal(0, scale=0.5, size=(100))\n", + "measurement_r2 = radii + np.random.normal(0, scale=0.5, size=(100)) * factor\n", + "\n", + "print(measurement_r1[:5])\n", + "print(measurement_r2[:5])" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "bland_altman_plot(measurement_r1, measurement_r2)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As the effect is harder to see, we use a higher factor." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[16.77457296 14.0869135 15.7809657 16.2517887 15.33721078]\n", + "[15.47728748 20.39815187 22.31386417 19.4948697 23.4488285 ]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "factor = 5\n", + "\n", + "measurement_r1 = radii + np.random.normal(0, scale=0.5, size=(100))\n", + "measurement_r2 = radii + np.random.normal(0, scale=0.5, size=(100)) * factor + 5\n", + "\n", + "print(measurement_r1[:5])\n", + "print(measurement_r2[:5])\n", + "\n", + "bland_altman_plot(measurement_r1, measurement_r2)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise\n", + "Process the banana dataset again, e.g. using a for-loop that goes through the folder `../data/banana/` and processes all the images. Measure the size of the banana slices using the [scikit-image thresholding methods](https://scikit-image.org/docs/dev/search.html?q=threshold_&check_keywords=yes&area=default#) `threshold_otsu` and `threshold_yen`. Compare both methods using the techniques you learned above." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "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.9.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/biostatistics/Processing_tabular_data_with_pandas.pdf b/biostatistics/Processing_tabular_data_with_pandas.pdf new file mode 100644 index 0000000..1759d99 Binary files /dev/null and b/biostatistics/Processing_tabular_data_with_pandas.pdf differ diff --git a/biostatistics/processing_tables_with_pandas.ipynb b/biostatistics/processing_tables_with_pandas.ipynb new file mode 100644 index 0000000..9c92aa7 --- /dev/null +++ b/biostatistics/processing_tables_with_pandas.ipynb @@ -0,0 +1,1548 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Working with tabular data using pandas\n", + "[Pandas](https://pandas.pydata.org/) is a library for processing and analysing tabular data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading data from disk\n", + "Load a csv file from disc and show it" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AreaMeanStdDevMinMaxCirc.ARRoundSolidity
01433190.85530.3051282320.6302.0750.4820.860
12185179.28621.8831282240.7631.7780.5620.951
23658205.61729.3811282480.8721.0680.9360.967
34434217.32736.0611282480.8841.0640.9400.959
45477212.14329.9041282480.8211.5700.6370.968
.................................
59601128.0000.0001281281.0001.0001.0001.000
606181183.40734.6821282480.5673.0820.3240.910
616290181.51125.5991282160.4614.0950.2440.933
626353188.37738.7991282480.5272.8590.3500.891
636449172.89828.7431282240.4564.2770.2340.883
\n", + "

64 rows × 10 columns

\n", + "
" + ], + "text/plain": [ + " Area Mean StdDev Min Max Circ. AR Round Solidity\n", + "0 1 433 190.855 30.305 128 232 0.630 2.075 0.482 0.860\n", + "1 2 185 179.286 21.883 128 224 0.763 1.778 0.562 0.951\n", + "2 3 658 205.617 29.381 128 248 0.872 1.068 0.936 0.967\n", + "3 4 434 217.327 36.061 128 248 0.884 1.064 0.940 0.959\n", + "4 5 477 212.143 29.904 128 248 0.821 1.570 0.637 0.968\n", + ".. .. ... ... ... ... ... ... ... ... ...\n", + "59 60 1 128.000 0.000 128 128 1.000 1.000 1.000 1.000\n", + "60 61 81 183.407 34.682 128 248 0.567 3.082 0.324 0.910\n", + "61 62 90 181.511 25.599 128 216 0.461 4.095 0.244 0.933\n", + "62 63 53 188.377 38.799 128 248 0.527 2.859 0.350 0.891\n", + "63 64 49 172.898 28.743 128 224 0.456 4.277 0.234 0.883\n", + "\n", + "[64 rows x 10 columns]" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "data_frame = pd.read_csv('../data/Measurements_blobs_ImageJ.csv', delimiter=',')\n", + "\n", + "# show it\n", + "data_frame" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data selection\n", + "Select a column out of the table - or two!" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 0.482\n", + "1 0.562\n", + "2 0.936\n", + "3 0.940\n", + "4 0.637\n", + " ... \n", + "59 1.000\n", + "60 0.324\n", + "61 0.244\n", + "62 0.350\n", + "63 0.234\n", + "Name: Round, Length: 64, dtype: float64" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_frame[\"Round\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Descriptive statistics\n", + "\n", + "Determine the mean of a column" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "187.72724999999997" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "np.mean(data_frame[\"Mean\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Read out one particular cell of the table" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "190.855" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_frame[\"Mean\"][0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Creating DataFrames\n", + "Make a new [DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html) from scratch:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
012
A123
B456
C789
\n", + "
" + ], + "text/plain": [ + " 0 1 2\n", + "A 1 2 3\n", + "B 4 5 6\n", + "C 7 8 9" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "header = ['A', 'B', 'C']\n", + "\n", + "data = [\n", + " [1, 2, 3], # this will later be colum A\n", + " [4, 5, 6], # B\n", + " [7, 8, 9] # C\n", + "]\n", + "\n", + "# convert the data and header arrays in a pandas data frame\n", + "data_frame = pd.DataFrame(data, header)\n", + "\n", + "# show it\n", + "data_frame" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ABC
0147
1258
2369
\n", + "
" + ], + "text/plain": [ + " A B C\n", + "0 1 4 7\n", + "1 2 5 8\n", + "2 3 6 9" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# rotate/flip it\n", + "data_frame = data_frame.transpose()\n", + "\n", + "# show it\n", + "data_frame" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also create a DataFrame from a dictionary of arrays. Earlier, we called them tables." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CityCountryPopulationArea_km2
0TokyoJapan135152712191
1DelhiIndia167532351484
2ShanghaiChina241830006341
3Sao PauloBrazil122520231521
4Mexico CityMexico92099441485
\n", + "
" + ], + "text/plain": [ + " City Country Population Area_km2\n", + "0 Tokyo Japan 13515271 2191\n", + "1 Delhi India 16753235 1484\n", + "2 Shanghai China 24183000 6341\n", + "3 Sao Paulo Brazil 12252023 1521\n", + "4 Mexico City Mexico 9209944 1485" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# source: https://en.wikipedia.org/wiki/List_of_largest_cities\n", + "cities_table = {\n", + " \"City\": ['Tokyo', 'Delhi', 'Shanghai', 'Sao Paulo', 'Mexico City'],\n", + " \"Country\": ['Japan', 'India', 'China', 'Brazil', 'Mexico'],\n", + " \"Population\": [13515271, 16753235, 24183000, 12252023, 9209944],\n", + " \"Area_km2\": [2191, 1484, 6341, 1521, 1485]\n", + "}\n", + "\n", + "cities = pd.DataFrame(cities_table)\n", + "cities" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Selecting rows and columns\n", + "You can filter rows and columns from pandas DataFrames quite intuitively, [see also](https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html).\n", + "\n", + "Let's start by selecting two columns" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CityCountry
0TokyoJapan
1DelhiIndia
2ShanghaiChina
3Sao PauloBrazil
4Mexico CityMexico
\n", + "
" + ], + "text/plain": [ + " City Country\n", + "0 Tokyo Japan\n", + "1 Delhi India\n", + "2 Shanghai China\n", + "3 Sao Paulo Brazil\n", + "4 Mexico City Mexico" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cities[['City', 'Country']]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When analysing tabular data, it is often necessary to filter tables by selecting only rows which fulfill certain conditions. For example, we select large cities by area:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CityCountryPopulationArea_km2
0TokyoJapan135152712191
2ShanghaiChina241830006341
\n", + "
" + ], + "text/plain": [ + " City Country Population Area_km2\n", + "0 Tokyo Japan 13515271 2191\n", + "2 Shanghai China 24183000 6341" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cities[cities['Area_km2'] > 2000]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "How does this work? The inner square bracket returns a list of boolean `flags`, which select entries in the outer square brackets:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 2191\n", + "1 1484\n", + "2 6341\n", + "3 1521\n", + "4 1485\n", + "Name: Area_km2, dtype: int64" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cities['Area_km2']" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 True\n", + "1 False\n", + "2 True\n", + "3 False\n", + "4 False\n", + "Name: Area_km2, dtype: bool" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "flags = cities['Area_km2'] > 2000\n", + "flags" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CityCountryPopulationArea_km2
0TokyoJapan135152712191
2ShanghaiChina241830006341
\n", + "
" + ], + "text/plain": [ + " City Country Population Area_km2\n", + "0 Tokyo Japan 13515271 2191\n", + "2 Shanghai China 24183000 6341" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cities[flags]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Adding columns\n", + "Sometimes, you want to compute parameters from other parameters and add them to the table. You can also add columns like this:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CityCountryPopulationArea_km2Population per km2
0TokyoJapan1351527121916168
1DelhiIndia16753235148411289
2ShanghaiChina2418300063413813
3Sao PauloBrazil1225202315218055
4Mexico CityMexico920994414856201
\n", + "
" + ], + "text/plain": [ + " City Country Population Area_km2 Population per km2\n", + "0 Tokyo Japan 13515271 2191 6168\n", + "1 Delhi India 16753235 1484 11289\n", + "2 Shanghai China 24183000 6341 3813\n", + "3 Sao Paulo Brazil 12252023 1521 8055\n", + "4 Mexico City Mexico 9209944 1485 6201" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cities['Population per km2'] = (cities['Population'] / cities['Area_km2']).astype(int)\n", + "cities" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Removing columns\n", + "You can use pythons [del](https://www.w3schools.com/python/ref_keyword_del.asp) cmmand to remove a column." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CityCountryPopulationArea_km2
0TokyoJapan135152712191
1DelhiIndia167532351484
2ShanghaiChina241830006341
3Sao PauloBrazil122520231521
4Mexico CityMexico92099441485
\n", + "
" + ], + "text/plain": [ + " City Country Population Area_km2\n", + "0 Tokyo Japan 13515271 2191\n", + "1 Delhi India 16753235 1484\n", + "2 Shanghai China 24183000 6341\n", + "3 Sao Paulo Brazil 12252023 1521\n", + "4 Mexico City Mexico 9209944 1485" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "del cities['Population per km2']\n", + "cities" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Combining tables\n", + "In the mastery of data science you need to combine information from multiple tables. For example, to compute the relative population of a city with respect to the country it's in, you need to combine the `cities` DataFrame with the `Countries` DataFrame." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CountryPopulation
0Japan127202192
1India1352642280
2China1427647786
3Brazil209469323
4Mexico126190788
\n", + "
" + ], + "text/plain": [ + " Country Population\n", + "0 Japan 127202192\n", + "1 India 1352642280\n", + "2 China 1427647786\n", + "3 Brazil 209469323\n", + "4 Mexico 126190788" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# source https://en.wikipedia.org/wiki/List_of_countries_by_population_(United_Nations)\n", + "countries_table = {\n", + " 'Country': ['Japan', 'India', 'China', 'Brazil', 'Mexico'],\n", + " 'Population': [127202192, 1352642280, 1427647786, 209469323, 126190788]\n", + "}\n", + "countries = pd.DataFrame(countries_table)\n", + "countries" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For combining tables, we use the [join](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.join.html) function." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CountryPopulation_xCityPopulation_yArea_km2
0Japan127202192Tokyo135152712191
1India1352642280Delhi167532351484
2China1427647786Shanghai241830006341
3Brazil209469323Sao Paulo122520231521
4Mexico126190788Mexico City92099441485
\n", + "
" + ], + "text/plain": [ + " Country Population_x City Population_y Area_km2\n", + "0 Japan 127202192 Tokyo 13515271 2191\n", + "1 India 1352642280 Delhi 16753235 1484\n", + "2 China 1427647786 Shanghai 24183000 6341\n", + "3 Brazil 209469323 Sao Paulo 12252023 1521\n", + "4 Mexico 126190788 Mexico City 9209944 1485" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "countries.merge(cities, on='Country')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The two population columns with _x and _y might be confusing. Thus, we can explicitly name them properly by providing a suffix." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CountryPopulation_countryCityPopulation_cityArea_km2
0Japan127202192Tokyo135152712191
1India1352642280Delhi167532351484
2China1427647786Shanghai241830006341
3Brazil209469323Sao Paulo122520231521
4Mexico126190788Mexico City92099441485
\n", + "
" + ], + "text/plain": [ + " Country Population_country City Population_city Area_km2\n", + "0 Japan 127202192 Tokyo 13515271 2191\n", + "1 India 1352642280 Delhi 16753235 1484\n", + "2 China 1427647786 Shanghai 24183000 6341\n", + "3 Brazil 209469323 Sao Paulo 12252023 1521\n", + "4 Mexico 126190788 Mexico City 9209944 1485" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "combined = countries.merge(cities, on='Country', suffixes=['_country', '_city'])\n", + "combined " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Just for fun, we compute the population ratio of the city in its country. For showing results nicely, remove all the other columns." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CityCity_Country_population_ratio
0Tokyo0.106250
1Delhi0.012386
2Shanghai0.016939
3Sao Paulo0.058491
4Mexico City0.072984
\n", + "
" + ], + "text/plain": [ + " City City_Country_population_ratio\n", + "0 Tokyo 0.106250\n", + "1 Delhi 0.012386\n", + "2 Shanghai 0.016939\n", + "3 Sao Paulo 0.058491\n", + "4 Mexico City 0.072984" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# compute ratio\n", + "combined['City_Country_population_ratio'] = combined['Population_city'] / combined['Population_country']\n", + "\n", + "# only show selected columns\n", + "combined[['City', 'City_Country_population_ratio']]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Saving tables to disk\n", + "Saving tables to disk is trivial. Depending on the software you want to use for postprocessing, you nay want to specify separators (tabulator, comma, semicolon). See [documentation](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_csv.html) for details." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "# save a dataframe to a CSV\n", + "cities.to_csv(\"output.csv\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise\n", + "Open `../data/Measurements_blobs_ImageJ.csv` and add a new column containing the perimeter of the objects. ([Hint](https://github.com/BiAPoL/Bio-image_Analysis_with_Python/blob/main/gpu_acceleration/00_GPU_acceleration_Quantitatve_measurements.pdf))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "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.9.4" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": false, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": false, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/data/Measurements_blobs_ImageJ.csv b/data/Measurements_blobs_ImageJ.csv new file mode 100644 index 0000000..1234b1e --- /dev/null +++ b/data/Measurements_blobs_ImageJ.csv @@ -0,0 +1,65 @@ + ,Area,Mean,StdDev,Min,Max,Circ.,AR,Round,Solidity +1,433,190.855,30.305,128,232,0.630,2.075,0.482,0.860 +2,185,179.286,21.883,128,224,0.763,1.778,0.562,0.951 +3,658,205.617,29.381,128,248,0.872,1.068,0.936,0.967 +4,434,217.327,36.061,128,248,0.884,1.064,0.940,0.959 +5,477,212.143,29.904,128,248,0.821,1.570,0.637,0.968 +6,285,204.295,36.565,128,248,0.926,1.153,0.867,0.938 +7,81,161.481,19.478,128,200,0.971,1.204,0.830,0.926 +8,278,174.849,25.472,128,224,0.854,1.389,0.720,0.919 +9,231,188.468,30.600,128,240,0.936,1.141,0.877,0.941 +10,30,147.200,13.053,128,168,0.406,4.338,0.230,0.870 +11,501,189.142,25.482,128,232,0.921,1.075,0.930,0.948 +12,660,171.697,20.530,128,232,0.858,1.337,0.748,0.952 +13,99,165.253,21.233,128,200,0.971,1.269,0.788,0.943 +14,228,195.895,37.354,128,248,0.924,1.142,0.876,0.940 +15,448,209.036,35.670,128,248,0.915,1.207,0.828,0.947 +16,401,179.571,26.013,128,232,0.658,2.499,0.400,0.890 +17,520,193.985,29.256,128,248,0.912,1.182,0.846,0.952 +18,425,195.953,31.439,128,248,0.881,1.451,0.689,0.953 +19,271,199.970,35.220,128,248,0.881,1.348,0.742,0.922 +20,350,190.491,26.851,128,232,0.930,1.168,0.856,0.943 +21,159,183.346,29.235,128,224,0.933,1.225,0.816,0.930 +22,412,186.350,26.013,128,224,0.906,1.106,0.904,0.945 +23,426,201.840,36.423,128,248,0.699,1.810,0.553,0.869 +24,260,179.385,28.135,128,240,0.909,1.153,0.867,0.932 +25,506,198.277,28.788,128,248,0.822,1.677,0.596,0.961 +26,289,187.875,30.281,128,240,0.922,1.131,0.884,0.935 +27,676,198.994,28.433,128,240,0.780,1.483,0.675,0.909 +28,175,195.749,28.105,128,232,0.777,1.763,0.567,0.951 +29,361,197.208,29.108,128,232,0.921,1.222,0.818,0.945 +30,545,198.385,30.277,128,240,0.907,1.225,0.817,0.949 +31,610,189.718,28.131,128,232,0.605,2.748,0.364,0.848 +32,14,138.857,9.206,128,152,1.000,1.020,0.981,0.933 +33,641,192.624,33.036,128,248,0.709,1.936,0.517,0.884 +34,195,181.005,28.183,128,232,0.938,1.147,0.872,0.929 +35,593,210.604,34.557,128,248,0.935,1.090,0.918,0.960 +36,22,147.636,15.364,128,176,0.922,1.464,0.683,0.863 +37,268,189.045,27.288,128,232,0.937,1.294,0.773,0.954 +38,902,198.137,31.340,128,248,0.648,2.517,0.397,0.908 +39,473,205.564,31.612,128,248,0.781,1.743,0.574,0.946 +40,239,191.598,32.966,128,232,0.921,1.213,0.824,0.939 +41,167,183.856,29.875,128,232,0.909,1.291,0.775,0.933 +42,413,179.177,25.860,128,232,0.881,1.375,0.727,0.951 +43,415,199.634,32.825,128,248,0.866,1.246,0.802,0.937 +44,244,187.016,29.576,128,248,0.913,1.138,0.879,0.930 +45,377,195.247,31.282,128,240,0.901,1.285,0.778,0.952 +46,652,200.160,32.191,128,240,0.919,1.115,0.897,0.962 +47,379,208.042,38.499,128,248,0.914,1.149,0.871,0.948 +48,578,200.886,29.321,128,240,0.917,1.050,0.952,0.956 +49,69,185.739,35.110,128,232,0.571,2.965,0.337,0.885 +50,170,181.224,28.776,128,232,0.939,1.358,0.736,0.932 +51,472,167.169,25.866,128,232,0.745,2.042,0.490,0.922 +52,613,219.915,37.720,128,248,0.868,1.354,0.739,0.942 +53,543,189.068,24.894,128,216,0.908,1.320,0.757,0.953 +54,204,199.608,32.805,128,240,0.649,2.221,0.450,0.938 +55,555,217.139,36.977,128,248,0.916,1.073,0.932,0.954 +56,858,197.277,30.121,128,248,0.833,1.564,0.639,0.949 +57,281,189.779,30.815,128,232,0.896,1.322,0.756,0.927 +58,215,184.037,28.631,128,224,0.909,1.307,0.765,0.929 +59,3,130.667,4.619,128,136,1.000,1.464,0.683,0.857 +60,1,128.000,0.000,128,128,1.000,1.000,1.000,1.000 +61,81,183.407,34.682,128,248,0.567,3.082,0.324,0.910 +62,90,181.511,25.599,128,216,0.461,4.095,0.244,0.933 +63,53,188.377,38.799,128,248,0.527,2.859,0.350,0.891 +64,49,172.898,28.743,128,224,0.456,4.277,0.234,0.883 diff --git a/image_processing/analyse_banana_data_set.ipynb b/image_processing/analyse_banana_data_set.ipynb index 2e923e6..292df2a 100644 --- a/image_processing/analyse_banana_data_set.ipynb +++ b/image_processing/analyse_banana_data_set.ipynb @@ -2,128 +2,71 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "coral-quantum", "metadata": {}, "outputs": [], "source": [ - "data_folder = '../data/banana/'\n", - "\n" + "from skimage.filters import threshold_otsu, threshold_yen\n", + "\n", + "data_folder = '../data/banana/'" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "dutch-artwork", "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "../data/banana/ [] ['banana0002.tif', 'banana0003.tif', 'banana0004.tif', 'banana0005.tif', 'banana0006.tif', 'banana0007.tif', 'banana0008.tif', 'banana0009.tif', 'banana0010.tif', 'banana0011.tif', 'banana0012.tif', 'banana0013.tif', 'banana0014.tif', 'banana0015.tif', 'banana0016.tif', 'banana0017.tif', 'banana0018.tif', 'banana0019.tif', 'banana0020.tif', 'banana0021.tif', 'banana0022.tif', 'banana0023.tif', 'banana0024.tif', 'banana0025.tif', 'banana0026.tif', 'image_source.txt']\n" - ] + "data": { + "text/plain": [ + "['banana0002.tif',\n", + " 'banana0003.tif',\n", + " 'banana0004.tif',\n", + " 'banana0005.tif',\n", + " 'banana0006.tif',\n", + " 'banana0007.tif',\n", + " 'banana0008.tif',\n", + " 'banana0009.tif',\n", + " 'banana0010.tif',\n", + " 'banana0011.tif',\n", + " 'banana0012.tif',\n", + " 'banana0013.tif',\n", + " 'banana0014.tif',\n", + " 'banana0015.tif',\n", + " 'banana0016.tif',\n", + " 'banana0017.tif',\n", + " 'banana0018.tif',\n", + " 'banana0019.tif',\n", + " 'banana0020.tif',\n", + " 'banana0021.tif',\n", + " 'banana0022.tif',\n", + " 'banana0023.tif',\n", + " 'banana0024.tif',\n", + " 'banana0025.tif',\n", + " 'banana0026.tif']" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ "import os\n", - "for root, dirs, files in os.walk(data_folder):\n", - " print(root, dirs, files)" + "\n", + "# get a list of files in that folder\n", + "file_list = os.listdir(data_folder)\n", + "\n", + "# filter the list so that only tif images remain\n", + "image_file_list = [file for file in file_list if file.endswith(\".tif\")]\n", + "image_file_list" ] }, { "cell_type": "code", "execution_count": 5, - "id": "still-taiwan", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "../data/banana/ [] banana0002.tif\n", - "../data/banana/ [] banana0003.tif\n", - "../data/banana/ [] banana0004.tif\n", - "../data/banana/ [] banana0005.tif\n", - "../data/banana/ [] banana0006.tif\n", - "../data/banana/ [] banana0007.tif\n", - "../data/banana/ [] banana0008.tif\n", - "../data/banana/ [] banana0009.tif\n", - "../data/banana/ [] banana0010.tif\n", - "../data/banana/ [] banana0011.tif\n", - "../data/banana/ [] banana0012.tif\n", - "../data/banana/ [] banana0013.tif\n", - "../data/banana/ [] banana0014.tif\n", - "../data/banana/ [] banana0015.tif\n", - "../data/banana/ [] banana0016.tif\n", - "../data/banana/ [] banana0017.tif\n", - "../data/banana/ [] banana0018.tif\n", - "../data/banana/ [] banana0019.tif\n", - "../data/banana/ [] banana0020.tif\n", - "../data/banana/ [] banana0021.tif\n", - "../data/banana/ [] banana0022.tif\n", - "../data/banana/ [] banana0023.tif\n", - "../data/banana/ [] banana0024.tif\n", - "../data/banana/ [] banana0025.tif\n", - "../data/banana/ [] banana0026.tif\n", - "../data/banana/ [] image_source.txt\n" - ] - } - ], - "source": [ - "for root, dirs, files in os.walk(data_folder):\n", - " for file in files:\n", - " print(root, dirs, file)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "consecutive-landscape", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "../data/banana/ [] banana0002.tif\n", - "../data/banana/ [] banana0003.tif\n", - "../data/banana/ [] banana0004.tif\n", - "../data/banana/ [] banana0005.tif\n", - "../data/banana/ [] banana0006.tif\n", - "../data/banana/ [] banana0007.tif\n", - "../data/banana/ [] banana0008.tif\n", - "../data/banana/ [] banana0009.tif\n", - "../data/banana/ [] banana0010.tif\n", - "../data/banana/ [] banana0011.tif\n", - "../data/banana/ [] banana0012.tif\n", - "../data/banana/ [] banana0013.tif\n", - "../data/banana/ [] banana0014.tif\n", - "../data/banana/ [] banana0015.tif\n", - "../data/banana/ [] banana0016.tif\n", - "../data/banana/ [] banana0017.tif\n", - "../data/banana/ [] banana0018.tif\n", - "../data/banana/ [] banana0019.tif\n", - "../data/banana/ [] banana0020.tif\n", - "../data/banana/ [] banana0021.tif\n", - "../data/banana/ [] banana0022.tif\n", - "../data/banana/ [] banana0023.tif\n", - "../data/banana/ [] banana0024.tif\n", - "../data/banana/ [] banana0025.tif\n", - "../data/banana/ [] banana0026.tif\n" - ] - } - ], - "source": [ - "for root, dirs, files in os.walk(data_folder):\n", - " for file in files:\n", - " if file.endswith('tif'):\n", - " print(root, dirs, file)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, "id": "metallic-punch", "metadata": {}, "outputs": [ @@ -133,20 +76,23 @@ "840" ] }, - "execution_count": 15, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "def process_image(filename):\n", + "def process_image(filename, threshold_function):\n", + " \"\"\"\n", + " Process a given image file name \n", + " \"\"\"\n", + " \n", " # load data\n", " from skimage.io import imread\n", " image = imread(filename)\n", " \n", " # segment it\n", - " from skimage.filters import threshold_otsu\n", - " binary_image = image > threshold_otsu(image)\n", + " binary_image = image > threshold_function(image)\n", " \n", " from skimage.measure import label\n", " labels = label(binary_image)\n", @@ -159,12 +105,12 @@ " import numpy as np\n", " return np.max(areas)\n", "\n", - "process_image('../data/banana/banana0026.tif')" + "process_image('../data/banana/banana0026.tif', threshold_otsu)" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 8, "id": "answering-dispute", "metadata": {}, "outputs": [ @@ -177,61 +123,62 @@ } ], "source": [ - "slice_areas = []\n", - "for root, dirs, files in os.walk(data_folder):\n", - " for file in files:\n", - " if file.endswith('tif'):\n", - " slice_areas.append(process_image(root + file))\n", - "print(slice_areas)" + "slice_areas1 = [process_image(data_folder + file, threshold_otsu) for file in image_file_list]\n", + "print(slice_areas1)" ] }, { "cell_type": "code", - "execution_count": 18, - "id": "raised-polls", + "execution_count": 9, + "id": "alien-choir", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[1302, 3072, 5127, 6486, 7208, 7540, 7689, 7761, 7800, 7767, 7793, 7812, 7908, 8145, 8367, 8581, 8744, 8989, 9010, 8618, 7682, 6012, 3846, 1468, 840]\n" + "[1833, 4199, 6074, 7312, 8012, 8379, 8473, 8461, 8382, 8307, 8257, 8300, 8442, 8681, 8967, 9247, 9592, 9880, 9976, 9757, 8886, 7468, 5478, 2203, 1255]\n" ] } ], "source": [ - "slice_areas = []\n", - "for root, dirs, files in os.walk(data_folder):\n", - " for file in files:\n", - " if file.endswith('tif'):\n", - " \n", - " # load data\n", - " from skimage.io import imread\n", - " image = imread(root + file)\n", - "\n", - " # segment it\n", - " from skimage.filters import threshold_otsu\n", - " binary_image = image > threshold_otsu(image)\n", - "\n", - " from skimage.measure import label\n", - " labels = label(binary_image)\n", + "slice_areas2 = [process_image(data_folder + file, threshold_yen) for file in image_file_list]\n", + "print(slice_areas2)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "1322c391", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "from statsmodels.graphics.agreement import mean_diff_plot\n", "\n", - " # measure radius\n", - " from skimage.measure import regionprops\n", - " statistics = regionprops(labels)\n", - " areas = [s.area for s in statistics]\n", + "m1 = np.asarray(slice_areas1)\n", + "m2 = np.asarray(slice_areas2)\n", "\n", - " # store result in array\n", - " import numpy as np\n", - " slice_areas.append(np.max(areas))\n", - " \n", - "print(slice_areas)\n" + "plot = mean_diff_plot(m1, m2)" ] }, { "cell_type": "code", "execution_count": null, - "id": "alien-choir", + "id": "950b4fa4", "metadata": {}, "outputs": [], "source": [] @@ -253,7 +200,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.9.4" } }, "nbformat": 4, diff --git a/python_basics/12_functional_parameters.ipynb b/python_basics/12_functional_parameters.ipynb new file mode 100644 index 0000000..a66a8b8 --- /dev/null +++ b/python_basics/12_functional_parameters.ipynb @@ -0,0 +1,258 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "036b787c", + "metadata": {}, + "source": [ + "## Functional parameters\n", + "A core concept of the python language is [functional programming](https://en.wikipedia.org/wiki/Functional_programming): We define functions and apply them to our data." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "aa79f8b3", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np \n", + "\n", + "values = np.asarray([1, 2, 3, 4, 10])" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c78903ad", + "metadata": {}, + "outputs": [], + "source": [ + "def double_number(x):\n", + " return x * 2" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6ed20a4f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 2, 4, 6, 8, 20])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "double_number(values)" + ] + }, + { + "cell_type": "markdown", + "id": "14e5744b", + "metadata": {}, + "source": [ + "In python you can also have variables that contain a function and can be executed:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fde42306", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 2, 4, 6, 8, 20])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_function = double_number\n", + "\n", + "my_function(values)" + ] + }, + { + "cell_type": "markdown", + "id": "606bc4e7", + "metadata": {}, + "source": [ + "## Custom functional parameters\n", + "You can also define your custom functions taking functional parameters. For example, we can define a `count_blobs` function that takes an `image` and a `threshold_algorithm`-function as parameter." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "35cd1b2c", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from skimage.measure import label\n", + "\n", + "def count_blobs(image, threshold_algorithm):\n", + " # binarize the image using a given \n", + " # threshold-algorithm\n", + " threshold = threshold_algorithm(image)\n", + " binary = image > threshold\n", + " \n", + " # show intermediate result\n", + " # plt.imshow(binary)\n", + " \n", + " # return count blobs\n", + " labels = label(binary)\n", + " return labels.max()" + ] + }, + { + "cell_type": "markdown", + "id": "c8ccdbee", + "metadata": {}, + "source": [ + "We now open an image and analyse it twice." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ab33a15a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from skimage.io import imread, imshow\n", + "\n", + "blobs_image = imread('../data/blobs.tif')\n", + "\n", + "imshow(blobs_image)" + ] + }, + { + "cell_type": "markdown", + "id": "584e8e62", + "metadata": {}, + "source": [ + "We now count the blobs in this image with two different algorithms we provide as parameter:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "837bf3a6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "64" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from skimage.filters import threshold_otsu\n", + "\n", + "count_blobs(blobs_image, threshold_otsu)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "4e91d17e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "67" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from skimage.filters import threshold_yen\n", + "\n", + "count_blobs(blobs_image, threshold_yen)" + ] + }, + { + "cell_type": "markdown", + "id": "2e38d928", + "metadata": {}, + "source": [ + "## Exercise\n", + "Assume you want to find out which threshold algorithm works best for your image. Therefore, you may want to take a look at the image being thresholded by multiple algoritms. Define a list of threshold algorithms, e.g. from [this list](https://scikit-image.org/docs/dev/search.html?q=threshold_&check_keywords=yes&area=default). Program a for-loop that applies the threshold algorithms to the blobs image and shows the results. The result should look similar to [this example](https://scikit-image.org/docs/dev/auto_examples/segmentation/plot_thresholding.html)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "50d15141", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "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.9.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}