From cfebe946543bb369a7ef6591f56849b657a530cf Mon Sep 17 00:00:00 2001 From: Maximilian Filtenborg Date: Mon, 1 Jul 2019 10:58:08 +0200 Subject: [PATCH] Evaluation metrics on components notebook --- doc/notebooks/Evaluation.rst | 553 +++++++++++++++++++ notebooks/Performance/Evaluation.ipynb | 722 +++++++++++++++++++++++++ 2 files changed, 1275 insertions(+) create mode 100644 doc/notebooks/Evaluation.rst create mode 100644 notebooks/Performance/Evaluation.ipynb diff --git a/doc/notebooks/Evaluation.rst b/doc/notebooks/Evaluation.rst new file mode 100644 index 0000000..5c8a72c --- /dev/null +++ b/doc/notebooks/Evaluation.rst @@ -0,0 +1,553 @@ + +.. code:: ipython3 + + import numpy as np + import numpy.ma as ma + import matplotlib.pyplot as plt + import matplotlib as mpl + %matplotlib inline + + +.. code:: ipython3 + + # We create a ground truth (manually) with 7 slums + gt_shape = (75, 75) + ground_truth = np.zeros(gt_shape) + ground_truth[10:12, 10:15] = 1 + ground_truth[15:22, 33:40] = 1 + ground_truth[28:33, 26:35] = 1 + ground_truth[30:34, 6:10] = 1 + ground_truth[5:10, 30:35] = 1 + ground_truth[40:50, 30:37] = 1 + + colors = ['white', 'green'] + bounds = [0, 1, 2] + cmap = mpl.colors.ListedColormap(colors) + norm = mpl.colors.BoundaryNorm(bounds, cmap.N) + + colors = ['white', 'blue'] + bounds = [0, 1, 2] + pred_cmap = mpl.colors.ListedColormap(colors) + pred_norm = mpl.colors.BoundaryNorm(bounds, cmap.N) + + + plt.figure(figsize=(6,6)) + plt.imshow(ground_truth, interpolation='none', cmap=cmap, norm=norm) + + plt.plot(0, 0, "-", c=cmap(0), label='Built-up Area') + plt.plot(0, 0, "-", c=cmap(1), label='Deprived neighborhood') + + plt.legend() + plt.show() + + + + + +.. image:: Evaluation_files/Evaluation_1_0.png + + +.. code:: ipython3 + + # These images show how the component map labels look after using + # scipy.ndimage.measurements.label + import seaborn as sns + from scipy.ndimage.measurements import label + + structure = np.ones((3,3)) + labeled, n_components = label(ground_truth, structure) + + plt.figure(figsize=(6,6)) + sns.heatmap(ground_truth[20:50, 20:50], annot=True) + plt.show() + + plt.figure(figsize=(6,6)) + sns.heatmap(labeled[20:50, 20:50], annot=True) + plt.show() + + + +.. image:: Evaluation_files/Evaluation_2_0.png + + + +.. image:: Evaluation_files/Evaluation_2_1.png + + +.. code:: ipython3 + + + # We manually create a prediction overlay/map of the same shape. + predictions = np.zeros(gt_shape) + predictions[10:12, 10:15] = 1 + predictions[15:22, 33:40] = 1 + predictions[28:32, 6:10] = 1 + predictions[50:55, 5:15] = 1 + predictions[55:63, 50:55] = 1 + predictions[10:14, 50:62] = 1 + predictions[40:54, 30:35] = 1 + predictions[40:54, 30:35] = 1 + predictions[1:7, 30:32] = 1 + + + predictions_mask = ma.masked_array(predictions, mask=predictions == 0) + + plt.figure(figsize=(6, 6)) + plt.imshow(ground_truth, interpolation=None, cmap=cmap, norm=norm) + plt.imshow(predictions_mask, cmap=pred_cmap, norm=pred_norm, alpha=0.5) # interpolation='none' + + plt.plot(0, 0, "-", c=cmap(0), label='Built-up Area') + plt.plot(0, 0, "-", c=cmap(1), label='Deprived neighborhood') + plt.plot(0, 0, "-", c=pred_cmap(1), label='Positive Predictions') + plt.legend(loc='lower left') + plt.show() + + + + + +.. image:: Evaluation_files/Evaluation_3_0.png + + +.. code:: ipython3 + + labels = {'other':0, 'slum': 1} + + + uniq = np.unique(ground_truth, return_counts=True) + + print(f"Built-up area examples, label:[{uniq[0][0]}], #examples: {uniq[1][0]} ") + print(f"Slum examples, label:{uniq[0][1]}, #examples: {uniq[1][1]}") + + +.. parsed-literal:: + + Built-up area examples, label:[0.0], #examples: 5410 + Slum examples, label:1.0, #examples: 215 + + +.. code:: ipython3 + + + from sklearn.metrics import matthews_corrcoef, classification_report, confusion_matrix, accuracy_score + from sklearn.utils.multiclass import unique_labels + + + def plot_confusion_matrix(y_true, y_pred, classes, + normalize=False, + title=None, + cmap=plt.cm.Blues): + """ + This function prints and plots the confusion matrix. + Normalization can be applied by setting `normalize=True`. + """ + if not title: + if normalize: + title = 'Normalized confusion matrix' + else: + title = 'Confusion matrix, without normalization' + + # Compute confusion matrix + cm = confusion_matrix(y_true, y_pred) + # Only use the labels that appear in the data + # classes = classes[unique_labels(y_true, y_pred)] + if normalize: + cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis] + print("Normalized confusion matrix") + else: + print('Confusion matrix, without normalization') + + print(cm) + + fig, ax = plt.subplots() + im = ax.imshow(cm, interpolation='nearest', cmap=cmap) + ax.figure.colorbar(im, ax=ax) + # We want to show all ticks... + ax.set(xticks=np.arange(cm.shape[1]), + yticks=np.arange(cm.shape[0]), + # ... and label them with the respective list entries + xticklabels=classes, yticklabels=classes, + title=title, + ylabel='True label', + xlabel='Predicted label') + + # Rotate the tick labels and set their alignment. + plt.setp(ax.get_xticklabels(), rotation=45, ha="right", + rotation_mode="anchor") + + # Loop over data dimensions and create text annotations. + fmt = '.2f' if normalize else 'd' + thresh = cm.max() / 2. + for i in range(cm.shape[0]): + for j in range(cm.shape[1]): + ax.text(j, i, format(cm[i, j], fmt), + ha="center", va="center", + color="white" if cm[i, j] > thresh else "black") + fig.tight_layout() + return ax + + y_test, y_pred = ground_truth.reshape((-1)), predictions.reshape((-1)) + mcc = matthews_corrcoef(ground_truth.reshape((-1)), predictions.reshape((-1))) + accuracy = accuracy_score(ground_truth.reshape((-1)), predictions.reshape((-1))) + + print("Some performance metrics on this example:") + print(f"Accuracy: {accuracy} \n") + print(f"MCC: {mcc} \n") + print(classification_report(y_test, y_pred, labels=list(labels.values()), target_names=list(labels.keys()))) + print(confusion_matrix(y_test, y_pred)) + + plot_confusion_matrix(y_test, y_pred, classes=labels) + plot_confusion_matrix(y_test, y_pred, classes=labels, normalize=True) + + + +.. parsed-literal:: + + Some performance metrics on this example: + Accuracy: 0.9523555555555555 + + MCC: 0.4563871861708983 + + precision recall f1-score support + + other 0.98 0.97 0.98 5410 + slum 0.41 0.56 0.47 215 + + micro avg 0.95 0.95 0.95 5625 + macro avg 0.70 0.77 0.72 5625 + weighted avg 0.96 0.95 0.96 5625 + + [[5236 174] + [ 94 121]] + Confusion matrix, without normalization + [[5236 174] + [ 94 121]] + Normalized confusion matrix + [[0.96783734 0.03216266] + [0.4372093 0.5627907 ]] + + + + +.. parsed-literal:: + + + + + + +.. image:: Evaluation_files/Evaluation_5_2.png + + + +.. image:: Evaluation_files/Evaluation_5_3.png + + +.. code:: ipython3 + + from scipy.ndimage.measurements import label + + def metrics_per_component(predictions, ground_truth, structure, threshold, threshold_true_negative=0.8): + """Calculates metrics depending on the component on the ground_truth and predictions + + Calculates the true positives, true negatives, false positives and false negatives based + on a prediction map and a ground_truth map. (which should both be 2D and of the same shape) + + For more information see [1]_. + + Parameters + ---------- + predictions: numpy.ndarray + The 2D array of binary predictions + ground_truth : numpy.ndarray + The 2D binary ground truth array + structure: numpy.ndarray + A structure that defines whether components are linked. (i.e. a 3x3 structure of ones) + Reference scipy.ndimage.measurements.label for documentation. + threshold: float + A float between 0 and 1 that defines a threshold per component, if the fraction of predictions + for the component is above the threshold, it is counted as a true positive. + threshold_true_negative: float + Similarly as above, but this is the threshold to determine whether a component is a true negative. + """ + assert predictions.ndim == 2 + assert ground_truth.ndim == 2 + assert predictions.shape == ground_truth.shape + + # Get components in ground_truth + labeled, n_components = label(ground_truth, structure) + component_accuracy_gt, component_labels = component_accuracies(ground_truth, labeled, n_components, predictions) + + # Areas that are slums and are classified as such (with a threshold) + # true_positives = (accuracy_per_pos_group >= threshold).sum() + true_positives = (component_accuracy_gt[component_labels == 1] >= threshold).sum() + + # Areas that are slums but not classified as such (with a threshold) + # false_negatives = (accuracy_per_pos_group < threshold).sum() + false_negatives = (component_accuracy_gt[component_labels == 1] < threshold).sum() + + # Components correctly classified as non slum (commonly is one or zero) + true_negatives = (component_accuracy_gt[component_labels == 0] >= threshold_other).sum() + + # Get components in predictions, we only need this to calculate the number of false positives + pred_labeled, n_components_pred = label(predictions, structure) + component_accuracy_pred = np.zeros(n_components_pred + 1) + component_pred_labels = np.zeros(n_components_pred + 1) + for n in range(0, n_components_pred + 1): + ind = pred_labeled == n + nr_fp = (ground_truth[ind] != predictions[ind]).sum() + + x1,x2 = np.nonzero(ind) + component_pred_labels[n] = predictions[x1[0], x2[0]] + + ratio_fp = nr_fp / ind.sum() + component_accuracy_pred[n] = ratio_fp + + # We calculate the false-positives by taking the 'false positive pixel' predicted components + # and the 'correct ratios' of these components + false_positives = (component_accuracy_pred[component_pred_labels == 1] > threshold).sum() + + return component_accuracy_gt, component_accuracy_pred, true_positives, false_negatives, false_positives, true_negatives + + + def component_accuracies(grid_labels, grid_components, n_components, predictions): + # We calculate the true-positives per component in the ground truth + component_accuracy_gt = np.zeros(n_components + 1) + component_labels = np.zeros(n_components + 1) + for n in range(0, n_components + 1): + ind = grid_components == n + + nr_correct = (grid_labels[ind] == predictions[ind]).sum() + + # if verbose: + # print(f"{nr_correct} / {ind.sum()}") + + # Determine whether this is a 'negative' or 'positive' component + x1,x2 = np.nonzero(ind) + component_labels[n] = grid_labels[x1[0], x2[0]] + + ratio_correct = nr_correct / ind.sum() + component_accuracy_gt[n] = ratio_correct + + return component_accuracy_gt, component_labels + + + def calc_matthews_correlation_coefficient(tp, tn, fp, fn): + sums = [(tp + fp), (tp + fn), (tn + fp), (tn + fn)] + denom = np.sqrt(np.prod(sums)) + if denom == 0: + denom = 1 + + return (tp * tn - fp * fn) / denom + + + def calc_precision(tp, tn, fp, fn): + return tp / (tp + fp) + + + def calc_recall(tp, tn, fp, fn): + return tp / (tp + fn) + + + def calc_accuracy(tp, tn, fp, fn): + return (tp + tn) / (tp + tn + fp + fn) + + # Find connected components (slums): + structure = np.ones((3,3)) + + # indices = np.indices(ground_truth.shape).T[:,:,[1, 0]] + threshold = 0.5 + component_accuracy_gt, component_accuracy_pred, tp, fn, fp, tn = metrics_per_component(predictions, ground_truth, structure, threshold=threshold, verbose=True) + + + precision = calc_precision(tp, tn, fp, fn) + recall = calc_recall(tp, tn, fp, fn) + accuracy = calc_accuracy(tp, tn, fp, fn) + mcc = calc_matthews_correlation_coefficient(tp, tn, fp, fn) + + + print(f"Accuracy per groundtruth component: \t [{component_accuracy_gt}]") + print(f"Accuracy per prediction component: \t [{component_accuracy_pred}]\n") + + print(f"True positives: \t [{tp}]") + print(f"True negatives: \t [{tn}]") + print(f"False positives: \t [{fp}]") + print(f"False negatives: \t [{fn}]") + + print(f"Precision: \t [{ precision }]") + print(f"Recall: \t [{ recall }]") + print(f"Accuracy: [{ accuracy }]") + print(f"F1 Measure: \t [{2 * (precision * recall) / (precision + recall)}]") + print(f"Matthews correlation coefficient: \t [{mcc}]") + + + +.. parsed-literal:: + + Accuracy per groundtruth component: [[0.96783734 0.16 1. 1. 0. 0.5 + 0.71428571]] + Accuracy per prediction component: [[0.01763602 0.66666667 0. 1. 0. 0.5 + 0.28571429 1. 1. ]] + + True positives: [4] + True negatives: [1] + False positives: [4] + False negatives: [2] + Precision: [0.5] + Recall: [0.6666666666666666] + Accuracy: [0.45454545454545453] + F1 Measure: [0.5714285714285715] + Matthews correlation coefficient: [-0.14907119849998599] + + +.. code:: ipython3 + + ps = [] + rs = [] + fs = [] + mccs = [] + + tps = [] + fns = [] + tns = [] + fps = [] + + thresholds = np.linspace(0.1, 1, 10) + for threshold in thresholds: + + accuracy_per_component, accuracy_per_pred_component, tp, fn, fp, tn = metrics_per_component(predictions, ground_truth, structure, threshold=threshold) + + # print("t:", threshold) + # print(accuracy_per_pred_component) + # print("fp", fp, "tp", tp, "fn", fn) + + precision = tp / (tp + fp) + recall = tp / (tp + fn) + f1_score = 2 * (precision * recall) / (precision + recall) + mcc = calc_matthews_correlation_coefficient(tp, tn, fp, fn) + + ps.append(precision) + rs.append(recall) + fs.append(f1_score) + mccs.append(mcc) + + tps.append(tp) + tns.append(tn) + fns.append(fn) + fps.append(fp) + + + + +.. code:: ipython3 + + plt.figure(figsize=(8, 6)) + plt.plot(thresholds, tps, 'D-', label='True Positives') + # plt.plot(thresholds, tns, 'D-', label='True Negatives') + + plt.plot(thresholds, fps, '+-', label='False Positives') + # plt.plot(thresholds, fns, '+-r', label='False Negatives') + + # plt.plot(thresholds, np.add(fps, tps), label='FP + TP') + # plt.plot(thresholds, np.add(fns, tns), label='FN + TN') + # plt.plot(thresholds, np.add(tps, tns) + np.add(fns, tns), label='FN + TN + TP + TN') + plt.xlabel('Threshold') + plt.legend() + plt.show() + + + # plt.figure(figsize=(8, 6)) + # plt.plot(thresholds, fs) + # plt.ylabel('F1-measure') + # plt.xlabel('Threshold') + # plt.show() + + # plt.figure(figsize=(8, 6)) + # plt.plot(thresholds, ps) + # plt.ylabel('Precision') + # plt.xlabel('Threshold') + # plt.show() + + # plt.figure(figsize=(8, 6)) + # plt.plot(thresholds, rs) + # plt.ylabel('Recall') + # plt.xlabel('Threshold') + # plt.show() + + plt.figure(figsize=(8, 6)) + plt.plot(thresholds, rs, 'D-', label='Recall') + plt.plot(thresholds, ps, '+-', label='Precision') + plt.plot(thresholds, fs, 'o-', label='F1-score') + plt.plot(thresholds, mccs, '.-', label='MCC') + plt.ylabel('Metric') + plt.xlabel('Threshold') + plt.legend() + plt.show() + + + + +.. image:: Evaluation_files/Evaluation_8_0.png + + + +.. image:: Evaluation_files/Evaluation_8_1.png + + +.. code:: ipython3 + + import seaborn as sns + + # Get components in ground_truth + labeled, n_components = label(ground_truth, structure) + component_accuracy_gt, component_labels = component_accuracies(ground_truth, labeled, n_components, predictions) + + bins = np.arange(0, 1 + 0.1, step=0.1) + plt.figure(figsize=(8, 6)) + sns.distplot(component_accuracy_gt, bins=bins, kde=False) + + plt.xticks(bins) + plt.xlim(0, 1) + plt.xlabel('Accuracy') + plt.ylabel('Frequency') + plt.title("Accuracy per component distribution") + plt.show() + + sns.kdeplot(component_accuracy_gt, label='Accuracy per group') + plt.legend() + plt.plot([0, 0], [0, 1.6]) + plt.plot([1, 1], [0, 1.]) + plt.title("Component accuracy distribution") + plt.show() + + + labeled, n_components = label(ground_truth, structure) + pred_labeled, n_components_pred = label(predictions, structure) + y_pos = np.arange(2) + plt.bar(y_pos, [n_components, n_components_pred]) + plt.xticks(y_pos, ['#Components in ground truth', 'Predicted #components']) + + + + + +.. image:: Evaluation_files/Evaluation_9_0.png + + + +.. image:: Evaluation_files/Evaluation_9_1.png + + + + +.. parsed-literal:: + + ([, + ], + ) + + + + +.. image:: Evaluation_files/Evaluation_9_3.png + diff --git a/notebooks/Performance/Evaluation.ipynb b/notebooks/Performance/Evaluation.ipynb new file mode 100644 index 0000000..e84f66d --- /dev/null +++ b/notebooks/Performance/Evaluation.ipynb @@ -0,0 +1,722 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import numpy.ma as ma\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "%matplotlib inline \n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "pycharm": { + "is_executing": false, + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# We create a ground truth (manually) with 7 slums\n", + "gt_shape = (75, 75)\n", + "ground_truth = np.zeros(gt_shape)\n", + "ground_truth[10:12, 10:15] = 1\n", + "ground_truth[15:22, 33:40] = 1\n", + "ground_truth[28:33, 26:35] = 1\n", + "ground_truth[30:34, 6:10] = 1\n", + "ground_truth[5:10, 30:35] = 1\n", + "ground_truth[40:50, 30:37] = 1\n", + "\n", + "colors = ['white', 'green']\n", + "bounds = [0, 1, 2]\n", + "cmap = mpl.colors.ListedColormap(colors)\n", + "norm = mpl.colors.BoundaryNorm(bounds, cmap.N)\n", + "\n", + "colors = ['white', 'blue']\n", + "bounds = [0, 1, 2]\n", + "pred_cmap = mpl.colors.ListedColormap(colors)\n", + "pred_norm = mpl.colors.BoundaryNorm(bounds, cmap.N)\n", + "\n", + "\n", + "plt.figure(figsize=(6,6))\n", + "plt.imshow(ground_truth, interpolation='none', cmap=cmap, norm=norm)\n", + "\n", + "plt.plot(0, 0, \"-\", c=cmap(0), label='Built-up Area')\n", + "plt.plot(0, 0, \"-\", c=cmap(1), label='Deprived neighborhood')\n", + "\n", + "plt.legend()\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# These images show how the component map labels look after using\n", + "# scipy.ndimage.measurements.label\n", + "import seaborn as sns\n", + "from scipy.ndimage.measurements import label\n", + "\n", + "structure = np.ones((3,3))\n", + "labeled, n_components = label(ground_truth, structure)\n", + "\n", + "plt.figure(figsize=(6,6))\n", + "sns.heatmap(ground_truth[20:50, 20:50], annot=True)\n", + "plt.show()\n", + "\n", + "plt.figure(figsize=(6,6))\n", + "sns.heatmap(labeled[20:50, 20:50], annot=True)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "pycharm": { + "is_executing": false, + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# We manually create a prediction overlay/map of the same shape.\n", + "predictions = np.zeros(gt_shape)\n", + "predictions[10:12, 10:15] = 1\n", + "predictions[15:22, 33:40] = 1\n", + "predictions[28:32, 6:10] = 1\n", + "predictions[50:55, 5:15] = 1\n", + "predictions[55:63, 50:55] = 1\n", + "predictions[10:14, 50:62] = 1\n", + "predictions[40:54, 30:35] = 1\n", + "predictions[40:54, 30:35] = 1\n", + "predictions[1:7, 30:32] = 1\n", + "\n", + "\n", + "predictions_mask = ma.masked_array(predictions, mask=predictions == 0)\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "plt.imshow(ground_truth, interpolation=None, cmap=cmap, norm=norm)\n", + "plt.imshow(predictions_mask, cmap=pred_cmap, norm=pred_norm, alpha=0.5) # interpolation='none'\n", + "\n", + "plt.plot(0, 0, \"-\", c=cmap(0), label='Built-up Area')\n", + "plt.plot(0, 0, \"-\", c=cmap(1), label='Deprived neighborhood')\n", + "plt.plot(0, 0, \"-\", c=pred_cmap(1), label='Positive Predictions')\n", + "plt.legend(loc='lower left')\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [ + { + "name": "stdout", + "text": [ + "Built-up area examples, label:[0.0], #examples: 5410 \nSlum examples, label:1.0, #examples: 215\n" + ], + "output_type": "stream" + } + ], + "source": [ + "labels = {'other':0, 'slum': 1}\n", + "\n", + "\n", + "uniq = np.unique(ground_truth, return_counts=True) \n", + " \n", + "print(f\"Built-up area examples, label:[{uniq[0][0]}], #examples: {uniq[1][0]} \")\n", + "print(f\"Slum examples, label:{uniq[0][1]}, #examples: {uniq[1][1]}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "pycharm": { + "is_executing": false, + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "text": [ + "Some performance metrics on this example:\nAccuracy: 0.9523555555555555 \n\nMCC: 0.4563871861708983 \n\n precision recall f1-score support\n\n other 0.98 0.97 0.98 5410\n slum 0.41 0.56 0.47 215\n\n micro avg 0.95 0.95 0.95 5625\n macro avg 0.70 0.77 0.72 5625\nweighted avg 0.96 0.95 0.96 5625\n\n[[5236 174]\n [ 94 121]]\nConfusion matrix, without normalization\n[[5236 174]\n [ 94 121]]\nNormalized confusion matrix\n[[0.96783734 0.03216266]\n [0.4372093 0.5627907 ]]\n" + ], + "output_type": "stream" + }, + { + "data": { + "text/plain": "" + }, + "metadata": {}, + "output_type": "execute_result", + "execution_count": 7 + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAT8AAAEYCAYAAAAqD/ElAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3XmcVXX9x/HXexgWWUVwY1FUcAMTFaU0jXLDVMxMxX0rtzTLtPRnmZGWZZlZmlG5tqiZJq6kFqYUAu4Cgqgg4AaIKCDb8Pn9cc7AncssF5g7986c99PHfXjPOd/7PZ8zd/jM9/s953yPIgIzs6ypKHUAZmal4ORnZpnk5GdmmeTkZ2aZ5ORnZpnk5GdmmeTk14xJukLSn9L3W0laJKlVI+9jhqQDGrPOAvZ5jqT30uPptgH1LJK0bWPGViqSJkkaUuo4WhInv3qk//Dfl9QhZ91XJY0pYVi1ioi3IqJjRFSVOpYNIak1cC1wUHo889e3rvTzbzRedI1P0q2SrmyoXET0j4gxTRBSZjj5NawVcMGGVqKEf94N2xxoB0wqdSDlQFJlqWNoqfyPsWHXABdJ2ri2jZL2ljRB0sL0/3vnbBsj6SpJY4ElwLbpuisl/Tftlj0gqZukP0v6KK2jT04dv5I0K932rKR964ijj6SQVCnpM2nd1a+lkmak5SokXSLpdUnzJd0taZOcek6SNDPddll9PxhJG0n6RVp+oaSnJW2UbhuWdtU+TI95p5zPzZB0kaSX0s/dJamdpO2BqWmxDyX9K/e48n6uX03f95X0ZFrPPEl35ZQLSX3T910k3S5pbhrv96r/GEk6NY3955IWSHpT0iH1HPcMSRen8S+W9EdJm0t6RNLHkh6X1DWn/N8kvZvG+B9J/dP1ZwInAN+p/l3Iqf+7kl4CFqff6erhB0kPS/pFTv13Srq5vu/KahERftXxAmYABwD3Alem674KjEnfbwIsAE4CKoHj0uVu6fYxwFtA/3R763TddGA7oAswGZiW7qcSuB24JSeGE4Fu6bZvA+8C7dJtVwB/St/3AQKozDuG1sCTwE/S5QuAcUAvoC3wO+Cv6badgUXAfum2a4GVwAF1/HxuSI+nJ0kLee/0c9sDi4ED0/1/Jz3mNjk/1/FAj/RnOAU4u7bjqO240n1+NX3/V+Aykj/k7YDP5pQLoG/6/nbgfqBTWuc04Ix026nACuBr6XGcA7wNqJ7fi3EkrdSewPvAc8BuaQz/An6QU/70dL9tgeuAF3K23Ur6u5VX/wtAb2Cj3N/F9P0W6T6/QJI83wA6lfrfS3N7lTyAcn6xJvkNABYCm1Iz+Z0EjM/7zP+AU9P3Y4ARedvHAJflLP8CeCRn+fDcfxy1xLQA2DV9fwUNJ7/fAg8CFenyFGD/nO1bpv/wK4HLgTtztnUAllNL8kuTzSfVseRt+z5wd17ZOcCQnJ/riTnbfwbcVNtx1HZc1Ex+twMjgV61xBFAX5KEthzYOWfbWTnf46nA9Jxt7dPPblHP78UJOct/B36bs3w+8I86PrtxWneXdPlWak9+p9f2u5izfBQwC5hHTsL3q/CXu70FiIhXSBLIJXmbegAz89bNJGkNVJtVS5Xv5bz/pJbljtULafdwStpl+pCktdi9kLglnQUMAY6PiFXp6q2B+9Lu6IckybCKpBXTIzfeiFgM1HXCoTtJK+f1WrbV+Lmk+55FzZ/Luznvl5BzzOvoO4CA8Wk3+/Q6Ym1Nze8q/3taHU9ELEnf1hdTQd+hpFaSrk6HGT4iSWLVMdWntt+bXA+QJPWpEfF0A2WtFk5+hfsBSbco9x/M2yTJJNdWJK2caus9bU46vvcd4Biga0RsTNICVYGf/RFwRER8lLNpFnBIRGyc82oXEXOAd0i6WtV1tCfpctdmHrCUpPuer8bPRZLSeufUUrYhi9P/t89Zt0X1m4h4NyK+FhE9SFpzN1aP8+XFuoKa31X+91QsxwNHkPQgupC0ZGHNd1jX70dDvzdXkfzh2lLScRsYYyY5+RUoIqYDdwHfyFn9MLC9pOPTQeljScbNHmyk3XYiGXObC1RKuhzo3NCHJPUG7gZOjohpeZtvAq6StHVadlNJR6Tb7gEOk/RZSW2AEdTxO5K25m4GrpXUI23hfEZS23Tfh0raX8mlK98GlgH/XaejT/YzlyRJnZju43RyEq6koyX1ShcXkCSNVXl1VKUxXSWpU3rsFwJ/Wtd41kMnkmOfT5LAf5y3/T1gna5FlLQfcBpwMnAK8GtJPev/lOVz8ls3I0jGwQCI5Bq0w0j+cc8naaUdFhHzGml/o4FHSQbnZ5K0tBrqDgHsT9KNvUdrzvhWXzryK2AU8E9JH5MM3A9Oj2cS8HXgLyStwAXA7Hr2cxHwMjAB+AD4KcnY4lSSEzW/Jml1HQ4cHhHLCzzufF8DLib5GfenZhLdE3hG0qL0uC6I2q/tO5+kFfkG8HR6jE1xhvR2ku9uDsnJrXF52/8I7JwOQ/yjocokdU7rPC8i5kTEU2kdt6QtbCuQ0sFTM7NMccvPzDLJyc/MMsnJz8wyycnPzDKpRd80rcqNQm06lToMy7PbTluVOgTLM3PmDObNm9eoZ4tbdd46YuUnDZaLT+aOjoihjbnvQrTs5NemE213OKbUYViesc/8ptQhWJ59Bg9q9Dpj5ScF/ftb+sINBd2x1NhadPIzsxKSoKJR59ZtVE5+ZlY8ZTyFpZOfmRVPGd904uRnZkUit/zMLIOEx/zMLIvkbq+ZZZS7vWaWSW75mVnm+Do/M8ssd3vNLHt8qYuZZVWFx/zMLGt8nZ+ZZZO7vWaWVb7UxcwyyS0/M8scX+dnZpnlbq+ZZY9PeJhZVrnlZ2aZI0FF+aaY8o3MzJo/t/zMLJM85mdmmeSWn5lljq/zM7Osklt+ZpY1wsnPzLJI6atMOfmZWZGIigqf7TWzDHK318wyycnPzLKnzMf8yrdDbmbNmtIxv4ZeBdUlDZU0VdJ0SZfUsn0rSf+W9LyklyR9saE6nfzMrGgkNfgqoI5WwA3AIcDOwHGSds4r9j3g7ojYDRgO3NhQvU5+ZlY0jZH8gL2A6RHxRkQsB+4EjsgrE0Dn9H0X4O2GKvWYn5kVh0CFPbe3u6SJOcsjI2JkznJPYFbO8mxgcF4dVwD/lHQ+0AE4oKGdOvmZWVGIglt28yJi0Abu7jjg1oj4haTPAHdIGhARq+r6gJOfmRVNI13qMgfonbPcK12X6wxgKEBE/E9SO6A78H5dlXrMz8yKRwW8GjYB6CdpG0ltSE5ojMor8xawP4CknYB2wNz6KnXLz8yKQzTK7W0RsVLSecBooBVwc0RMkjQCmBgRo4BvA7+X9C2Skx+nRkTUV6+Tn5kVTWPd4RERDwMP5627POf9ZGCfdanTyc/MimIdTniUhJOfmRVP+eY+Jz8zK5JGGvMrFic/Myuacu72lm9azogD996JF+/7Pq/c/wMuOu3AtbZvtWVXHr7pfMbfdSmjf38BPTfbGID9BvVj3J2XrH4tGPdLDh/yqaYOv8X65+hH+VT/Hei/Y1+u+dnVa21ftmwZJx5/LP137Mu+ew9m5owZAEwYP57Bewxk8B4D2Wv3Xbn/H/c1ceRlpnEudSmKJk1+kjaWdG7O8hBJDzZlDOWkokJcd8kxHHHejex21JUcPXQPdtx2ixplfvKtI/nzQ+PZ69if8OORjzDi/GEA/Gfia3x6+NV8evjVHHLm9SxZupzHx00pxWG0OFVVVXzzG1/n/gce4fmXJvO3O//KlMmTa5S59eY/0nXjrkx6dTrnX/AtLvu/7wLQf8AAxj4zkWeefYH7H3qU8889i5UrV5biMMpCI93bWxRN3fLbGDi3wVIFktSsu+17DujD67PmMWPOfFasrOJvo5/jsLzW247bbsmT46cC8OSEaRw2ZJe16jnygN3459jJfLJ0RZPE3dJNGD+e7bbryzbbbkubNm04+tjhPPjA/TXKPPjA/Zxw0ikAfPmorzDmX08QEbRv357KyuTXctnSpWXd7Ss2qfGmtCqGou5Z0oWSXklf3wSuBraT9IKka9JiHSXdI+lVSX9W+tsiaQ9JT0p6VtJoSVum68dIui69EfqCYsZfbD0268Ls9xasXp7z3gJ6btqlRpmXp83hiC8MBOCIL+xK544bsUmXDjXKHH3w7tz96LPFDzgj3n57Dr16rbmbqmfPXsyZM2ftMr2TMpWVlXTu0oX58+cDMP6ZZ9h91/4M2m0Xrr/hptXJMIvKueVXtG9F0h7AaSSzLwh4BjgRGBARA9MyQ4DdgP4kU9CMBfaR9Azwa+CIiJgr6VjgKuD0tPo2dd0ILelM4EwAWncsyrE1pUt/eR+//O7RnDhsMGOfm86c9xZQVbXmXu0tunemf78ePPa/yfXUYk1pr8GDee7FSbw6ZQpfPf0UDh56CO3atSt1WKVRxg3fYv5J+ixwX0QsBpB0L7BvLeXGR8TstMwLQB/gQ2AA8Fj6l6EV8E7OZ+6qa6fpVDgjASrab1bv7S2l9vb7C+m1edfVyz0378qcuQtrlHln7kKGX/QHADps1IYv7T+QhYs+Wb39qAN3Z9S/XmLlyjonr7B11KNHT2bPXjOD0pw5s+nZs+faZWbNolevXqxcuZKPFi6kW7duNcrsuNNOdOzYkUmvvMIegzZ00pLmqZy7/eVwtndZzvsqkoQsYFJEDExfu0TEQTnlFjdphEUycdJM+m61KVv36EbrylYcffDuPDTmpRplum3cYfUv0MWnH8xt94+rsf2YoXtw96MTscYzaM89mT79NWa8+SbLly/nb3fdyaGHDatR5tDDhvHnO24D4N6/38PnPv8FJDHjzTdXn+CYOXMmU6e+ytZ9+jT1IZQFKTmp19CrVIrZ8nsKuFXS1STJ7EjgFJIbkBsyFdhU0mfS6WlaA9tHxKTihdv0qqpW8a2f3s0DN36dVhXitvvHMeWNd/n+OYfy3OS3eOjJl9lvUD9GnD+MCHj6uel88yd3r/78VltuQq8tuvLUs9NLeBQtT2VlJb/81W84/NCDqaqq4pRTT2fn/v0ZccXl7L7HIA47fBinnn4Gp596Ev137EvXrptwx5/vBOC/Y5/m59dcTevK1lRUVPCrX99I9+7dS3xEpVLet7epgYkPNqxy6ULWjNP9ISKuk/QX4FPAI8BDwEURcVha/jckszTcKmkgcD3JlNSVwHUR8XtJY9LPNNjcqWi/WbTd4ZhGPy7bMAsm/KbUIViefQYP4tlnJzZqpmq3xfax1cnXN1jutWsOebYRJjNdZ0U9DRUR1wLX5q07Pq/YmJxt5+W8fwHYr5Y6hzRqkGZWNOXc8svuOXgzKyoJWrVy8jOzDCrjhp+Tn5kVj7u9ZpY9csvPzDJIyPP5mVk2ueVnZpnkMT8zyx6P+ZlZFglKeu9uQ5z8zKxo3O01s0wq49zn5GdmxVE9pVW5cvIzsyIp7ymtnPzMrGjKOPc5+ZlZ8bjlZ2aZ4zE/M8sst/zMLJPKOPc5+ZlZ8bjlZ2aZI5X20ZQNKd/Jtsys2ZMafhVWj4ZKmippuqRL6ihzjKTJkialT4msl1t+ZlY0FY3Q7ZXUCrgBOBCYDUyQNCoiJueU6QdcCuwTEQskbdZQvXUmP0md6/tgRHxUaPBmlk2NNOS3FzA9It5I6tSdwBHA5JwyXwNuiIgFABHxfkOV1tfymwQEycw01aqXA9hqXaI3s2yRoFVhY37dJU3MWR4ZESNzlnsCs3KWZwOD8+rYPtmnxgKtgCsi4tH6dlpn8ouI3oVEbWZWlwLP9s6LiEEbuKtKoB8wBOgF/EfSLhHxYV0fKOiEh6Thkv4vfd9L0h4bGKiZZUAjnfCYA+Q2xnql63LNBkZFxIqIeBOYRpIM69Rg8pP0G+DzwEnpqiXATQWFbGaZJZInuDX0XwEmAP0kbSOpDTAcGJVX5h8krT4kdSfpBr9RX6WFnO3dOyJ2l/Q8QER8kAZgZlY3qdAxv3pFxEpJ5wGjScbzbo6ISZJGABMjYlS67SBJk4Eq4OKImF9fvYUkvxWSKkhOciCpG7BqA47FzDKisW7wiIiHgYfz1l2e8z6AC9NXQQoZ87sB+DuwqaQfAk8DPy10B2aWTSK5zq+hV6k02PKLiNslPQsckK46OiJeKW5YZtYSlPGtvQXf4dEKWEHS9fUtcWbWoHKfz6+Qs72XAX8FepCcYv6LpEuLHZiZNX/NutsLnAzsFhFLACRdBTwP/KSYgZlZ81e+7b7Ckt87eeUq03VmZvVqlvP5SfolyRjfB8AkSaPT5YNILjo0M6uTGuk6v2Kpr+VXfUZ3EvBQzvpxxQvHzFqSMm741TuxwR+bMhAza3maZbe3mqTtgKuAnYF21esjYvsixmVmzVxykXOpo6hbIdfs3QrcQnIshwB3A3cVMSYzayHK+VKXQpJf+4gYDRARr0fE90iSoJlZnaTyTn6FXOqyLJ3Y4HVJZ5PMo9WpuGGZWUtQxkN+BSW/bwEdgG+QjP11AU4vZlBm1jI06xMeEfFM+vZj1kxoamZWL9FMr/OTdB/pHH61iYgvFyUiM2sZ1uG5vKVQX8vvN00WRZH06L055/3iW6UOw/KcdMdzpQ7B8rw5f0lR6m2W3d6IeKIpAzGzlkVAq+aY/MzMNlQZD/k5+ZlZ8bSI5CepbUQsK2YwZtZyJM/lLd/sV8hMzntJehl4LV3eVdKvix6ZmTV7rSoafpVKIbu+HjgMmA8QES+SPMTczKxOzf7pbUBFRMzMa75WFSkeM2tByvlpZ4Ukv1mS9gJCUivgfGBaccMys5agjIf8Ckp+55B0fbcC3gMeT9eZmdWpOU9jD0BEvA8Mb4JYzKyFKePcV9BMzr+nlnt8I+LMokRkZi1C9QmPclVIt/fxnPftgCOBWcUJx8xakjLOfQV1e2tMWS/pDuDpokVkZi2DWt69vdsAmzd2IGbWspT7A4wKGfNbwJoxvwqSh5hfUsygzKxlaLbJT8mVzbuSPLcDYFVE1DnBqZlZrnK+t7fe5BcRIenhiBjQVAGZWcsglfbe3YYUEtoLknYreiRm1uKU8729dSY/SdWtwt2ACZKmSnpO0vOSPA+5mdWr+oRHQ6+C6pKGpjlouqQ6zzlIOkpSSBrUUJ31dXvHA7sDwwoLz8yspsZo2KVzCtwAHAjMJmmMjYqIyXnlOgEXAM+sXcva6kt+AoiI19crYjPLNKHGus5vL2B6RLwBIOlO4Ahgcl65HwE/BS4upNL6kt+mki6sa2NEXFvIDswsowrv1naXNDFneWREjMxZ7knNu8pmA4Nr7EraHegdEQ9J2uDk1wroSNoCNDNbVwWe0JgXEQ2O0dVFUgVwLXDqunyuvuT3TkSMWN+AzCzbRKPd2zsH6J2z3Is11x4DdAIGAGPS6wq3AEZJGhYRuS3KGhoc8zMzW1+NNJ/fBKCfpG1Ikt5w4PjqjRGxEOhevSxpDHBRfYkP6r/Ob/8NidbMsk0kCaahV0MiYiVwHjAamALcHRGTJI2QtN5Xo9TZ8ouID9a3UjMzGvHRlRHxMPBw3rrL6yg7pJA6/dByMyuach47c/Izs6IQLW8+PzOzgpRx7nPyM7NiUfOd0srMbH1Vn+0tV05+ZlY0zf3pbWZm664RL3UpBic/MysKd3vNLLPc7TWzTCrj3OfkZ2bFkXR7yzf7OfmZWdG45WdmGVTap7M1xMnPzIrC3V4zyya522tmGeXkZ2aZ4ymtzCyz5DE/M8uiMm74OfmV2tTxT/LgDVeyalUVe37xGIYcd3at5V75z6P8+Yfn8fUb76PXDrusXv/he2/zy9OHsv8p32C/Y77aVGG3eAN7dua0wb2oEDwxbT7/ePm9GtuH9N2Ek/bsyQeLVwDwyJS5/Ou1+QB079Cas/fZmm4d2gDBjx97nbmLljf1IZQFt/zyFPpouZZuVVUVo66/gjN+dhudN92CG879Mjt9Zn8279OvRrllSxYx9t7b6L3TrmvV8dBvr2L7vfZrqpAzoUJwxqd786PRr/HBkhX85PAdmPjWQmYvXFqj3H/fXMAfx81e6/Pn7duHe196l5fe/ph2lRWsimiq0MuKUFmP+ZXzpAst3qxXX6Rbz63ZpMdWVLZuw66fP5Qp/318rXL/vOU6Pjf8TCrbtK2xftLTj9F1y95rJUvbMH27d+Ddj5fx/qLlrFwVjH1jAYO26lLQZ3t1aUerCvHS2x8DsHTlKpZXZTP5VV/q0tCrVIqe/CR1kPSQpBclvSLp2Lzti3Lef0XSren7WyX9VtI4SW9IGiLpZklTqss0dx/Ne48um265ernzpluwcF7N7tWcaa+wcO477Pjpz9dYv+yTxTx55+/Y/+TzmyTWLNmkfWvmL17TTf1gyQq6dWi9VrnBW3fl50fsxLc/v83q7Vt2acvi5VVc9IVt+dmwHTlpUE8a57ndzZMKeJVKU7T8hgJvR8SuETEAeHQdPtsV+AzwLWAU8EugP7CLpIG1fUDSmZImSpq4+MPm/ejhVatW8dBNP+bQsy9da9sTt13PZ79yGm036lCCyGzirIWc+7dXuOj+Kbz49sect28fILm0Y6fNO3L7+Nlc8sCrbNapDUP6dittsCUikimtGnqVSlOM+b0M/ELST4EHI+KpdZjd9YGICEkvA+9FxMsAkiYBfYAX8j8QESOBkQC9dtilrPsbnbtvzsK576xe/mjuu3Tpvvnq5eVLFvPem68x8sITAFj0wVxu//5ZnPyj3zFryou8/J9HeWTkz1i66CNUUUFlmzbs/aWTm/w4Wpqkpddm9XLSElxRo8yiZVWr3/9r2jxOGtQTgPlLljPjgyW8n57gmPDWQvpt2gHSkyFZU8ZDfsVPfhExTdLuwBeBKyU9kV8k5327vG3L0v+vynlfvdzsz1T32vFTzJszkw/emUXn7pvz4r8fYvhl167e3q5jJ75/34TVyyMvPJ4vnnUpvXbYhbN+defq9Y/f9ivabNTBia+RTJ+3mC07t2Wzjm34YMkK9tm2K796ckaNMhtvVMmHn6wEYFDvLsz+MDkZ8vq8JbRv04rObSv5aNlKBmzZidfnLW7qQygbmT7bK6kH8EFE/EnSh0D+9RjvSdoJmAocCXxc7JjKRatWlQw7/wfc/N3TiFVVDDrkaDbvsz2P3XIdPXcYwM57H1DqEDNpVcAfx83isoP6UiHx79fmM/vDpRy725a8Pm8JE2ct5Is7b8ag3l2oimDRsipueHrG6s/eMWEOlw/thwRvzFvCE9Oy2eqDjLf8gF2AayStAlYA5wA/z9l+CfAgMBeYCHRsgpjKxo6Dh7Dj4CE11h142jdrLXvmtX+pdf0Bp1zQ2GFl3vOzP+L52ZNrrLvr+TVDFH959m3+8uzbtX72pbc/5qL7pxQ1vuaijHNfk3R7RwOj81YPydl+D3BPLZ87Nef9DGBAbdvMrDwJP73NzLLIU1qZWVaVce5z8jOzIirj7OfkZ2ZF4md4mFkGlfr2tYZ4YgMzK55GurlX0lBJUyVNl3RJLdsvlDRZ0kuSnpC0dUN1OvmZWdGogP8arENqBdwAHALsDBwnaee8Ys8DgyLiUySXzv2soXqd/MysaCrU8KsAewHTI+KNiFgO3AkckVsgIv4dEUvSxXFArwZjW7dDMTMrUCFd3iT5da+eiSl9nZlXU09gVs7y7HRdXc4AHmkoPJ/wMLOiKXBig3kRMahR9iedCAwCPtdQWSc/MyuKZD6/RqlqDtA7Z7lXuq7m/qQDgMuAz0XEsvzt+dztNbPiaZyzvROAfpK2kdQGGE4yufGa3Ui7Ab8DhkXE+4VU6pafmRVNY8znFxErJZ1HMkFKK+DmiJgkaQQwMSJGAdeQzAj1t3QyhbciYlh99Tr5mVnRNNYNHhHxMPBw3rrLc96v8+SXTn5mVjRlfHebk5+ZFUcypFe+2c/Jz8yKw/P5mVlWlXHuc/Izs2KRp7E3s2wq49zn5GdmxVHu8/k5+ZlZ8ZRx9nPyM7Oi8TT2ZpZJ5Zv6nPzMrFh8nZ+ZZVf5Zj8nPzMrikacz68onPzMrGjc7TWzTPLEBmaWTeWb+5z8zKw4VPijKUvCyc/MisbdXjPLpvLNfU5+ZlY8ZZz7nPzMrFjke3vNLHtEeV/n54eWm1kmueVnZkVTzi0/Jz8zKw55Pj8zyyBPY29m2VXG2c/Jz8yKxnd4mFkm+d5eM8smJz8zy6Jy7vYqIkodQ9FImgvMLHUcjaQ7MK/UQVgNLek72ToiNm3MCiU9SvIzasi8iBjamPsuRItOfi2JpIkRMajUcdga/k6aN9/eZmaZ5ORnZpnk5Nd8jCx1ALYWfyfNmMf8zCyT3PIzs0xy8jOzTHLyM7NMcvIrY9KaydAkdS5lLGYtjZNfmZKkSM9GSToTOENS6xKHZdT8o2TNl5NfmcpJfPsAhwA3R8SK0kZleX+UepU6Hlt/Tn5lSlKFpH7ATUBroFWJQzJq/FE6D7hX0i2S9pDUpsSh2Tpy8isjud2piFgVEa8BFwAbA/u621s6kipy3vcFDgaGA/OB0/D30+x4SqsyktOqOBvYGVhC0vL7MXAREJIejYjlpYsymyJiFYCk4UBb4LWIeEPSJcD/AV8G2kh63MMTzYNbfmVG0teBrwB3APsCX4+Ih4EbgR8CB5QwvEyTdBzJH6KdSE5AnRYRKyNiBLAIOJBkiMKaAbf8yk83YBjwVeAj4DJJbSPiHkmfAJNKGl1GSToQ+CJwbERMkPQ48HNJRMQtEfFdSd0jYkmJQ7UCOfmVSDq+p+ruVM66XsB4YGpEHJKuP1vSkoi4vTTRGrA10I9kbO/ViHhc0reBWyStjIg7IqKlTGyaCe72lk67nHGkAyV9Lh3zuxr4EHgu3XYayUmPcSWLNMMk7SfpKuCPwK+BXYD9JLWPiCeAk4GxpYzR1o9bfiUgaTvgp5LOIOlKfQ/4WNKTwH0kye4GSQNJWoJHRcS0kgWcIZIqImJVztnd1sBmwKUR8WNJ7UhObrRNTz6NKVWstmGc/EpjJTADuJmk69tfUnfgu8ChwJ+BvYF2QJuI+LBUgWZNzjDENhHxuqSnSL6voyVdFhFXSdqI5MTT6JIFahvM8/k1IUkdI2JR+n434HPApcBnI+I1SdsA55IkvVsz0In3AAAFRklEQVQi4rnSRZstkgaRtPCeADYF3gKGR8TdaWtvX5I/Tv+JiBGSukTEwtJFbBvKY35NRFJb4CRJwyR9meRylvuAu4ErJfWJiDdJrutbCMwqXbSZtAtwOfD5iJgNHAbcJOmoiFgaEY8B7wO9JXVz4mv+3PJrQpJ2BsYAy0m6VSvS1t6pwPbA99KuVmVErCxdpNlRPcaXvr+AZNjh+oh4UNLBJH+cziUZIjoBOCki3itZwNZo3PIrstzbolJjgbnAkQBpa+/3wJvA9yVVAlVNGmRGpZMUVCe+c4CPgYeBb0s6LCJGk7TQjwSOBi524ms5fMKjyHL+cZ1FcsvaDJK7N34kqUNE3AL0AR4CprjF13Rybic8CzgDOCIi5khaApwraXlE/DM9C6+IWFbKeK1xudvbBCQdBYwg6TadAcwE2gMnAROBrUjuHJhdsiAzKj1z+1fgtyTXVn6Z5PKig0iGJ0ak433Wwrjb2zR2IDl7+wLwbZL7QDchGVSfCpzuxFcaEfEJSVf3apILmbcD5pC0xG8GfH1lC+WWXxOQ9CWSaY8ujYjJ6bongROc9EovvZRlF+D1iPhAUnULfahn0Gm5PObXNMYAg4ATJI0BNgI6AB5DKgMRsRSYkE4gewbwTeA4J76WzS2/JiKpB8l40jCSbu8PI+LF0kZluSS1B44FxkXElFLHY8Xl5NfE0n9giojFpY7F1pb7jA5r2Zz8zCyTfLbXzDLJyc/MMsnJz8wyycnPzDLJyc/MMsnJr4WTVCXpBUmvSPpbeqnN+tY1RNKD6fth6TNr6yq7saRz12MfV0i6qND1eWVulfSVddhXH0mvrGuM1jI4+bV8n0TEwIgYQHKj/tm5G5VY59+DiBgVEVfXU2RjknnwzMqSk1+2PAX0TVs8UyXdDrxCMjvxQZL+J+m5tIXYEUDSUEmvSqqe8YR0/amSfpO+31zSfZJeTF97k0wUsF3a6rwmLXexpAmSXpL0w5y6LpM0TdLTJJNA1EvS19J6XpT097zW7AGSJqb1HZaWbyXpmpx9n7WhP0hr/pz8MiKdJPUQ4OV0VT/gxojoDywmeYLcARGxO8k0WxemN/z/Hjgc2APYoo7qrweejIhdgd1JHqx+CclEAQMj4mJJB6X73AsYCOyRPhZyD2B4uu6LwJ4FHM69EbFnur8pJJMQVOuT7uNQkmno26XbF0bEnmn9X0tn0LYM88QGLd9Gkl5I3z9FMm1TD2BmRFQ/C/jTJBOtjpUE0Ab4H7Aj8GZEvAYg6U/AmbXs4wskz68lIqqAhZK65pU5KH09ny53JEmGnYD7ImJJuo9RBRzTAElXknStO1LzKWp3pxPIvibpjfQYDgI+lTMe2CXdt6eryjAnv5bvk4gYmLsiTXC59xYLeCwijssrV+NzG0jATyLid3n7+OZ61HUr8KWIeFHSqcCQnG3592tGuu/z02npc/fdZz32bS2Eu70GMA7YR1JfAEkdJG0PvAr0UfKQdYDj6vj8E8A56WdbSepC8jyMTjllRgOn54wl9pS0GfAf4EuSNpLUiaSL3ZBOwDuSWpPMjp3r6HRqqu2AbUkmix0NnJOWR9L2kjoUsB9rwdzyMyJibtqC+quSR2xC8iS5aZLOBB5Kn2vxFDUTWrULgJHpXHhVwDkR8T9JY9NLSR5Jx/12Av6XtjwXASdGxHOS7gJeJHk05IQCQv4+8AzJg6CeyYvpLWA80Bk4OyKWSvoDyVjgc0p2Phf4UmE/HWupPKuLmWWSu71mlklOfmaWSU5+ZpZJTn5mlklOfmaWSU5+ZpZJTn5mlkn/D6AeTrj7OjrLAAAAAElFTkSuQmCC\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "from sklearn.metrics import matthews_corrcoef, classification_report, confusion_matrix, accuracy_score\n", + "from sklearn.utils.multiclass import unique_labels\n", + "\n", + "\n", + "def plot_confusion_matrix(y_true, y_pred, classes,\n", + " normalize=False,\n", + " title=None,\n", + " cmap=plt.cm.Blues):\n", + " \"\"\"\n", + " This function prints and plots the confusion matrix.\n", + " Normalization can be applied by setting `normalize=True`.\n", + " \"\"\"\n", + " if not title:\n", + " if normalize:\n", + " title = 'Normalized confusion matrix'\n", + " else:\n", + " title = 'Confusion matrix, without normalization'\n", + "\n", + " # Compute confusion matrix\n", + " cm = confusion_matrix(y_true, y_pred)\n", + " # Only use the labels that appear in the data\n", + " # classes = classes[unique_labels(y_true, y_pred)]\n", + " if normalize:\n", + " cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n", + " print(\"Normalized confusion matrix\")\n", + " else:\n", + " print('Confusion matrix, without normalization')\n", + "\n", + " print(cm)\n", + "\n", + " fig, ax = plt.subplots()\n", + " im = ax.imshow(cm, interpolation='nearest', cmap=cmap)\n", + " ax.figure.colorbar(im, ax=ax)\n", + " # We want to show all ticks...\n", + " ax.set(xticks=np.arange(cm.shape[1]),\n", + " yticks=np.arange(cm.shape[0]),\n", + " # ... and label them with the respective list entries\n", + " xticklabels=classes, yticklabels=classes,\n", + " title=title,\n", + " ylabel='True label',\n", + " xlabel='Predicted label')\n", + "\n", + " # Rotate the tick labels and set their alignment.\n", + " plt.setp(ax.get_xticklabels(), rotation=45, ha=\"right\",\n", + " rotation_mode=\"anchor\")\n", + "\n", + " # Loop over data dimensions and create text annotations.\n", + " fmt = '.2f' if normalize else 'd'\n", + " thresh = cm.max() / 2.\n", + " for i in range(cm.shape[0]):\n", + " for j in range(cm.shape[1]):\n", + " ax.text(j, i, format(cm[i, j], fmt),\n", + " ha=\"center\", va=\"center\",\n", + " color=\"white\" if cm[i, j] > thresh else \"black\")\n", + " fig.tight_layout()\n", + " return ax\n", + "\n", + "y_test, y_pred = ground_truth.reshape((-1)), predictions.reshape((-1))\n", + "mcc = matthews_corrcoef(ground_truth.reshape((-1)), predictions.reshape((-1)))\n", + "accuracy = accuracy_score(ground_truth.reshape((-1)), predictions.reshape((-1)))\n", + "\n", + "print(\"Some performance metrics on this example:\")\n", + "print(f\"Accuracy: {accuracy} \\n\")\n", + "print(f\"MCC: {mcc} \\n\")\n", + "print(classification_report(y_test, y_pred, labels=list(labels.values()), target_names=list(labels.keys())))\n", + "print(confusion_matrix(y_test, y_pred))\n", + "\n", + "plot_confusion_matrix(y_test, y_pred, classes=labels)\n", + "plot_confusion_matrix(y_test, y_pred, classes=labels, normalize=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "pycharm": { + "is_executing": false, + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "text": [ + "Accuracy per groundtruth component: \t [[0.96783734 0.16 1. 1. 0. 0.5\n 0.71428571]]\nAccuracy per prediction component: \t [[0.01763602 0.66666667 0. 1. 0. 0.5\n 0.28571429 1. 1. ]]\n\nTrue positives: \t [4]\nTrue negatives: \t [1]\nFalse positives: \t [4]\nFalse negatives: \t [2]\nPrecision: \t [0.5]\nRecall: \t [0.6666666666666666]\nAccuracy: [0.45454545454545453]\nF1 Measure: \t [0.5714285714285715]\nMatthews correlation coefficient: \t [-0.14907119849998599]\n" + ], + "output_type": "stream" + } + ], + "source": [ + "from scipy.ndimage.measurements import label\n", + "\n", + "def metrics_per_component(predictions, ground_truth, structure, threshold, threshold_true_negative=0.8):\n", + " \"\"\"Calculates metrics depending on the component on the ground_truth and predictions\n", + "\n", + " Calculates the true positives, true negatives, false positives and false negatives based\n", + " on a prediction map and a ground_truth map. (which should both be 2D and of the same shape)\n", + "\n", + " For more information see [1]_.\n", + "\n", + " Parameters\n", + " ----------\n", + " predictions: numpy.ndarray\n", + " The 2D array of binary predictions\n", + " ground_truth : numpy.ndarray\n", + " The 2D binary ground truth array\n", + " structure: numpy.ndarray\n", + " A structure that defines whether components are linked. (i.e. a 3x3 structure of ones)\n", + " Reference scipy.ndimage.measurements.label for documentation.\n", + " threshold: float\n", + " A float between 0 and 1 that defines a threshold per component, if the fraction of predictions\n", + " for the component is above the threshold, it is counted as a true positive.\n", + " threshold_true_negative: float\n", + " Similarly as above, but this is the threshold to determine whether a component is a true negative.\n", + " \"\"\"\n", + " assert predictions.ndim == 2\n", + " assert ground_truth.ndim == 2\n", + " assert predictions.shape == ground_truth.shape\n", + " \n", + " # Get components in ground_truth\n", + " labeled, n_components = label(ground_truth, structure)\n", + " component_accuracy_gt, component_labels = component_accuracies(ground_truth, labeled, n_components, predictions)\n", + " \n", + " # Areas that are slums and are classified as such (with a threshold)\n", + " # true_positives = (accuracy_per_pos_group >= threshold).sum()\n", + " true_positives = (component_accuracy_gt[component_labels == 1] >= threshold).sum()\n", + " \n", + " # Areas that are slums but not classified as such (with a threshold)\n", + " # false_negatives = (accuracy_per_pos_group < threshold).sum()\n", + " false_negatives = (component_accuracy_gt[component_labels == 1] < threshold).sum()\n", + " \n", + " # Components correctly classified as non slum (commonly is one or zero)\n", + " true_negatives = (component_accuracy_gt[component_labels == 0] >= threshold_other).sum()\n", + " \n", + " # Get components in predictions, we only need this to calculate the number of false positives\n", + " pred_labeled, n_components_pred = label(predictions, structure)\n", + " component_accuracy_pred = np.zeros(n_components_pred + 1)\n", + " component_pred_labels = np.zeros(n_components_pred + 1)\n", + " for n in range(0, n_components_pred + 1):\n", + " ind = pred_labeled == n\n", + " nr_fp = (ground_truth[ind] != predictions[ind]).sum()\n", + " \n", + " x1,x2 = np.nonzero(ind)\n", + " component_pred_labels[n] = predictions[x1[0], x2[0]]\n", + " \n", + " ratio_fp = nr_fp / ind.sum()\n", + " component_accuracy_pred[n] = ratio_fp\n", + " \n", + " # We calculate the false-positives by taking the 'false positive pixel' predicted components\n", + " # and the 'correct ratios' of these components\n", + " false_positives = (component_accuracy_pred[component_pred_labels == 1] > threshold).sum()\n", + " \n", + " return component_accuracy_gt, component_accuracy_pred, true_positives, false_negatives, false_positives, true_negatives\n", + "\n", + "\n", + "def component_accuracies(grid_labels, grid_components, n_components, predictions):\n", + " # We calculate the true-positives per component in the ground truth\n", + " component_accuracy_gt = np.zeros(n_components + 1)\n", + " component_labels = np.zeros(n_components + 1)\n", + " for n in range(0, n_components + 1):\n", + " ind = grid_components == n \n", + " \n", + " nr_correct = (grid_labels[ind] == predictions[ind]).sum()\n", + " \n", + " # if verbose:\n", + " # print(f\"{nr_correct} / {ind.sum()}\")\n", + " \n", + " # Determine whether this is a 'negative' or 'positive' component\n", + " x1,x2 = np.nonzero(ind)\n", + " component_labels[n] = grid_labels[x1[0], x2[0]]\n", + " \n", + " ratio_correct = nr_correct / ind.sum()\n", + " component_accuracy_gt[n] = ratio_correct\n", + " \n", + " return component_accuracy_gt, component_labels\n", + "\n", + "\n", + "def calc_matthews_correlation_coefficient(tp, tn, fp, fn):\n", + " sums = [(tp + fp), (tp + fn), (tn + fp), (tn + fn)]\n", + " denom = np.sqrt(np.prod(sums))\n", + " if denom == 0:\n", + " denom = 1\n", + "\n", + " return (tp * tn - fp * fn) / denom\n", + "\n", + "\n", + "def calc_precision(tp, tn, fp, fn):\n", + " return tp / (tp + fp)\n", + "\n", + "\n", + "def calc_recall(tp, tn, fp, fn):\n", + " return tp / (tp + fn)\n", + "\n", + "\n", + "def calc_accuracy(tp, tn, fp, fn):\n", + " return (tp + tn) / (tp + tn + fp + fn)\n", + " \n", + "# Find connected components (slums):\n", + "structure = np.ones((3,3))\n", + "\n", + "# indices = np.indices(ground_truth.shape).T[:,:,[1, 0]]\n", + "threshold = 0.5\n", + "component_accuracy_gt, component_accuracy_pred, tp, fn, fp, tn = metrics_per_component(predictions, ground_truth, structure, threshold=threshold, verbose=True)\n", + "\n", + "\n", + "precision = calc_precision(tp, tn, fp, fn)\n", + "recall = calc_recall(tp, tn, fp, fn)\n", + "accuracy = calc_accuracy(tp, tn, fp, fn)\n", + "mcc = calc_matthews_correlation_coefficient(tp, tn, fp, fn)\n", + "\n", + "\n", + "print(f\"Accuracy per groundtruth component: \\t [{component_accuracy_gt}]\")\n", + "print(f\"Accuracy per prediction component: \\t [{component_accuracy_pred}]\\n\")\n", + "\n", + "print(f\"True positives: \\t [{tp}]\")\n", + "print(f\"True negatives: \\t [{tn}]\")\n", + "print(f\"False positives: \\t [{fp}]\")\n", + "print(f\"False negatives: \\t [{fn}]\")\n", + "\n", + "print(f\"Precision: \\t [{ precision }]\")\n", + "print(f\"Recall: \\t [{ recall }]\")\n", + "print(f\"Accuracy: [{ accuracy }]\")\n", + "print(f\"F1 Measure: \\t [{2 * (precision * recall) / (precision + recall)}]\")\n", + "print(f\"Matthews correlation coefficient: \\t [{mcc}]\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "pycharm": { + "is_executing": false, + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "ps = []\n", + "rs = []\n", + "fs = []\n", + "mccs = []\n", + "\n", + "tps = []\n", + "fns = []\n", + "tns = []\n", + "fps = []\n", + "\n", + "thresholds = np.linspace(0.1, 1, 10)\n", + "for threshold in thresholds:\n", + " \n", + " accuracy_per_component, accuracy_per_pred_component, tp, fn, fp, tn = metrics_per_component(predictions, ground_truth, structure, threshold=threshold)\n", + " \n", + " # print(\"t:\", threshold)\n", + " # print(accuracy_per_pred_component)\n", + " # print(\"fp\", fp, \"tp\", tp, \"fn\", fn)\n", + " \n", + " precision = tp / (tp + fp)\n", + " recall = tp / (tp + fn)\n", + " f1_score = 2 * (precision * recall) / (precision + recall)\n", + " mcc = calc_matthews_correlation_coefficient(tp, tn, fp, fn)\n", + " \n", + " ps.append(precision)\n", + " rs.append(recall)\n", + " fs.append(f1_score)\n", + " mccs.append(mcc)\n", + " \n", + " tps.append(tp)\n", + " tns.append(tn)\n", + " fns.append(fn)\n", + " fps.append(fp)\n", + " \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "pycharm": { + "is_executing": false, + "name": "#%%\n" + }, + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8, 6))\n", + "plt.plot(thresholds, tps, 'D-', label='True Positives')\n", + "# plt.plot(thresholds, tns, 'D-', label='True Negatives')\n", + "\n", + "plt.plot(thresholds, fps, '+-', label='False Positives')\n", + "# plt.plot(thresholds, fns, '+-r', label='False Negatives')\n", + "\n", + "# plt.plot(thresholds, np.add(fps, tps), label='FP + TP')\n", + "# plt.plot(thresholds, np.add(fns, tns), label='FN + TN')\n", + "# plt.plot(thresholds, np.add(tps, tns) + np.add(fns, tns), label='FN + TN + TP + TN')\n", + "plt.xlabel('Threshold')\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "\n", + "# plt.figure(figsize=(8, 6))\n", + "# plt.plot(thresholds, fs)\n", + "# plt.ylabel('F1-measure')\n", + "# plt.xlabel('Threshold')\n", + "# plt.show()\n", + "\n", + "# plt.figure(figsize=(8, 6))\n", + "# plt.plot(thresholds, ps)\n", + "# plt.ylabel('Precision')\n", + "# plt.xlabel('Threshold')\n", + "# plt.show()\n", + "\n", + "# plt.figure(figsize=(8, 6))\n", + "# plt.plot(thresholds, rs)\n", + "# plt.ylabel('Recall')\n", + "# plt.xlabel('Threshold')\n", + "# plt.show()\n", + "\n", + "plt.figure(figsize=(8, 6))\n", + "plt.plot(thresholds, rs, 'D-', label='Recall')\n", + "plt.plot(thresholds, ps, '+-', label='Precision')\n", + "plt.plot(thresholds, fs, 'o-', label='F1-score')\n", + "plt.plot(thresholds, mccs, '.-', label='MCC')\n", + "plt.ylabel('Metric')\n", + "plt.xlabel('Threshold')\n", + "plt.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "pycharm": { + "is_executing": false, + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfkAAAGDCAYAAAAoD2lDAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xm4JHV97/H3B4awBITITARhmHHBBY0LjgaNGuKSi8SIGjQQF/CixF0TzTV6uUo0PldvEowKiUElLO5rQhJc0IAGE5ABWQRURkQZMYrIpqAIfu8fVaPN8Sw9S50+53fer+fpZ2rrqm//uqc/XVW/U5WqQpIktWerSRcgSZKGYchLktQoQ16SpEYZ8pIkNcqQlySpUYa8JEmNMuQlLQlJ9k+yfmT8kiT7b6F1PyPJp0fGK8k9t8S6+/X9MMndt9T6tHQY8pqYJGcmuS7JtpOuRYtLktV9kC7b1HVU1f2q6swtsZ2qem9V/e6m1jJlm2cmee6U9e9YVVdsifVraTHkNRFJVgOPAgp40jxve5ODYVIWY81Lhe+NFjJDXpPybOBs4ETgsNEZSbZP8jdJvpnkhiRnJdm+n/fIJP+Z5PokVyU5vJ9+h72fJIcnOWtkvJK8KMnlwOX9tLf267gxyXlJHjWy/NZJXpPk60lu6uevTHJckr+ZUu+pSf5kuhfZb/elSa5I8v0kf5Vkq5H5/zPJZf0RjU8lWTVbzdOsf6b22DnJyUmu6dvxqA3b7dvmC0ne0j/viiSP6KdfleR7SQ4b2caJSd6R5PS+LT43pc5HJDm3f6/OTfKIkXlnJnlDv72bknw6yfKR+fuN1H/h6OHzOZ77+f7f6/tD2Q+fpm2272u/LsmlwEOnzL8yyeP64YclWdt/Fr6b5JiZtjOl/a4Fjp76eesdON37nuToJO8ZqePnRwuSvJHux++x/faOHfks3HPM9/asJH/dv+5vJHnCL31wtHRUlQ8f8/4A1gEvBB4C/BS4y8i844AzgT2ArYFHANsCq4CbgEOBbYBdgQf1zzkTeO7IOg4HzhoZL+B04M7A9v20Z/brWAa8AvhvYLt+3p8BFwP3BgI8sF/2YcDVwFb9csuBm0frn/I6Czij3+5ewNc21Akc1LfDffsajgL+c7aap6x7tvY4GfhnYCdgdb/dI0ba5jbgOX37/iXwrb7dtwV+t1/vjv3yJ/bjj+7nv3VD2/a1XQc8q38Nh/bju468L18H7gVs34+/qZ+3B3AtcCDdDsfj+/EVYzx3dd8+y2b5jL0J+I++xpXAl4H1I/OvBB7XD/8X8Kx+eEdgv5m2M9J+L+lf8/ZM/3mb6X0/GnjPyLJ32AZTPssj67vnmO/tT4Hn9e/tC+g+r5n0/3kfk3lMvAAfS+8BPLL/Ilrej38F+JN+eCvgFuCB0zzv1cDHZ1jnHb4YZ/jSfcwcdV23YbvAV4GDZljuMuDx/fCLgdNmWWcBB4yMvxD4bD/8iQ1fziOv/WZg1Tg1z9Qe/Zf7rcA+I9P+GDhzpG0uH5n3G/22Rn9oXcsvfjCcCHxgZN6OwO10wfks4ItTtv9fwOEj78tRU17/J/vhVwGnTHnup4DDxnjuauYO+SumtP2RzBzynwf+YsNncmSZX9pO337fmrLcdJ+3md73o9nEkB/zvV03Mm+H/rm7be7/Wx+L8+Hhek3CYcCnq+r7/fj7+MUh++XAdnR7cFOtnGH6uK4aHUnyyv5Q+Q1Jrgd27rc/17ZOojsKQP/vKRux3W8Cd+2HVwFv7Q9VXw/8gO6owR4z1TzFTDUup9uz/+aU7Y6u97sjw7cAVNXUaTtOV0dV/bCv9a79Y3Q7023rv0eGbx5Z7yrgaRtef98GjwR2H+O547grv9z2MzmC7ojBV/pTDk+cY92zvS/TLTP6vm+Ocd7bn7dZVd3cD25Mu6khdhjRvEp3bv3pwNZJNnwZbQvskuSBdIfIfwzcA7hwytOvojtcPp0f0e21bLDbNMv8/JaL6c6//y/gscAlVfWzJNfRheyGbd2D7hDvVO8BvtzXe1/gn2aoaYOVwCX98F50h083bOONVfXeWZ47220iZ2qP79MdKVkFXDqy3W/PUedsVm4YSLIj3WHoq/vHqinL7gV8cox1XkW3J/+8TahnnNtnfodfbvvpV1Z1OXBof277qcBHkuw6y3bG2f5M7/tcn9XZ1j3Ee6uGuSev+fZkukO9+wAP6h/3pTt3+uyq+hlwAnBMkrum6wD38HR/Zvde4HFJnt53Uto1yYP69V4APDXJDn0HpSPmqGMnuvOq1wDLkrwWuNPI/HcBb0iydzoP6L/0qar1wLl0e/Afrapb5tjWnyX5tSQrgZcBH+ynvwN4dZL7wc87VD1tjnWNmrY9qup24EPAG5Ps1HeS+1O6Hyeb6sB0nfx+BXgDcHZVXQWcBtwryR/1Nfwh3Xv7r2Os8z3A7yf5H/37vF26v2Xfc4znXgP8DJjtb8c/RNe+v9av8yUzLZjkmUlW9J+/6/vJPxtzOzOZ6X2/AHh0kr2S7Ex32mXUd2fa3kDvrRpmyGu+HQb8Y1V9q6r+e8MDOBZ4Rro/R3ol3R79uXSHhd9M19HtW3SdtF7RT7+ArkMcwFvozlV+l+5w+mx7x9Cd+/0kXaelb9IdPRg9vHoM3Zfpp4EbgXfTdbDa4CS6c9lzHaqHrpPUeX29/9avi6r6eP/aPpDkRrqjBmP3hJ6jPV5Ct8d4BXAW3SmRE8Zd9zTeB7yu385D6E9XVNW1wBP7Gq6lOzryxJFTMbPVfxVd58PX0IXpVXQdHuf8XuoPQ78R+EJ/qH+/aRb7C7r39ht07+Ns79UBwCVJfkjXsfCQqrplzO3MZKb3/XS6wL+onz/1B9FbgYP73vFvm2a9W/q9VcNSNc5RJ0mjkjyabu9pVc3ynyhJAXtX1bp5K24LS3IiXYe1oyZdi6SN4568tJGSbEN3+PVdswW8JE2aIS9thCT3pTtnuzvwtxMuR5Jm5eF6SZIa5Z68JEmNMuQlSWrUorsYzvLly2v16tWTLkOSpHlz3nnnfb+qVmzs8xZdyK9evZq1a9dOugxJkuZNktkuyzwjD9dLktQoQ16SpEYZ8pIkNcqQlySpUYa8JEmNMuQlSWqUIS9JUqMMeUmSGmXIS5LUKENekqRGDRbySbZL8sUkFya5JMlfTLPMtkk+mGRdknOSrB6qHkmSlpoh9+R/Ajymqh4IPAg4IMl+U5Y5Ariuqu4JvAV484D1SJK0pAwW8tX5YT+6Tf+oKYsdBJzUD38EeGySDFWTJElLyaB3oUuyNXAecE/guKo6Z8oiewBXAVTVbUluAHYFvj9lPUcCRwLstddeQ5YsSWrc+8751qRLmDeDdryrqtur6kHAnsDDktx/E9dzfFWtqao1K1Zs9O10JUlakuald31VXQ+cARwwZda3gZUASZYBOwPXzkdNkiS1bsje9SuS7NIPbw88HvjKlMVOBQ7rhw8G/r2qpp63lyRJm2DIc/K7Ayf15+W3Aj5UVf+a5PXA2qo6FXg3cEqSdcAPgEMGrEeSpCVlsJCvqouAB08z/bUjwz8GnjZUDZIkLWVe8U6SpEYZ8pIkNcqQlySpUYa8JEmNMuQlSWqUIS9JUqMMeUmSGmXIS5LUKENekqRGGfKSJDXKkJckqVGGvCRJjTLkJUlqlCEvSVKjDHlJkhplyEuS1ChDXpKkRhnykiQ1ypCXJKlRhrwkSY0y5CVJapQhL0lSowx5SZIaZchLktQoQ16SpEYZ8pIkNcqQlySpUYa8JEmNMuQlSWqUIS9JUqMMeUmSGmXIS5LUKENekqRGGfKSJDXKkJckqVGGvCRJjTLkJUlqlCEvSVKjDHlJkhplyEuS1ChDXpKkRhnykiQ1ypCXJKlRg4V8kpVJzkhyaZJLkrxsmmX2T3JDkgv6x2uHqkeSpKVm2YDrvg14RVWdn2Qn4Lwkp1fVpVOW+4+qeuKAdUiStCQNtidfVd+pqvP74ZuAy4A9htqeJEm6o3k5J59kNfBg4JxpZj88yYVJPpHkfjM8/8gka5OsveaaawasVJKkdgwe8kl2BD4KvLyqbpwy+3xgVVU9EHg78E/TraOqjq+qNVW1ZsWKFcMWLElSIwYN+STb0AX8e6vqY1PnV9WNVfXDfvg0YJsky4esSZKkpWLI3vUB3g1cVlXHzLDMbv1yJHlYX8+1Q9UkSdJSMmTv+t8CngVcnOSCftprgL0AquodwMHAC5LcBtwCHFJVNWBNkiQtGYOFfFWdBWSOZY4Fjh2qBkmSljKveCdJUqMMeUmSGmXIS5LUKENekqRGGfKSJDXKkJckqVGGvCRJjTLkJUlqlCEvSVKjDHlJkhplyEuS1ChDXpKkRhnykiQ1ypCXJKlRhrwkSY0y5CVJapQhL0lSowx5SZIaZchLktQoQ16SpEYZ8pIkNcqQlySpUYa8JEmNMuQlSWqUIS9JUqMMeUmSGmXIS5LUKENekqRGGfKSJDXKkJckqVGGvCRJjTLkJUlqlCEvSVKjDHlJkhplyEuS1ChDXpKkRhnykiQ1ypCXJKlRhrwkSY0y5CVJapQhL0lSowx5SZIaNVjIJ1mZ5Iwklya5JMnLplkmSd6WZF2Si5LsO1Q9kiQtNcsGXPdtwCuq6vwkOwHnJTm9qi4dWeYJwN794zeBv+//lSRJm2mwPfmq+k5Vnd8P3wRcBuwxZbGDgJOrczawS5Ldh6pJkqSlZF7OySdZDTwYOGfKrD2Aq0bG1/PLPwQkSdImGDzkk+wIfBR4eVXduInrODLJ2iRrr7nmmi1boCRJjRo05JNsQxfw762qj02zyLeBlSPje/bT7qCqjq+qNVW1ZsWKFcMUK0lSY4bsXR/g3cBlVXXMDIudCjy772W/H3BDVX1nqJokSVpKhuxd/1vAs4CLk1zQT3sNsBdAVb0DOA04EFgH3Aw8Z8B6JElaUgYL+ao6C8gcyxTwoqFqkCRpKfOKd5IkNcqQlySpUYa8JEmNMuQlSWqUIS9JUqMMeUmSGmXIS5LUKENekqRGGfKSJDXKkJckqVGGvCRJjTLkJUlqlCEvSVKjDHlJkhplyEuS1KixQj7JbwxdiCRJ2rLG3ZP/uyRfTPLCJDsPWpEkSdoixgr5qnoU8AxgJXBekvclefyglUmSpM0y9jn5qrocOAp4FfDbwNuSfCXJU4cqTpIkbbpxz8k/IMlbgMuAxwC/X1X37YffMmB9kiRpEy0bc7m3A+8CXlNVt2yYWFVXJzlqkMokSdJmGTfkfw+4papuB0iyFbBdVd1cVacMVp0kSdpk456T/wyw/cj4Dv00SZK0QI0b8ttV1Q83jPTDOwxTkiRJ2hLGDfkfJdl3w0iShwC3zLK8JEmasHHPyb8c+HCSq4EAuwF/OFhVkiRps40V8lV1bpL7APfuJ321qn46XFmSJGlzjbsnD/BQYHX/nH2TUFUnD1KVJEnabGOFfJJTgHsAFwC395MLMOQlSVqgxt2TXwPsU1U1ZDGSJGnLGbd3/ZfpOttJkqRFYtw9+eXApUm+CPxkw8SqetIgVUmSpM02bsgfPWQRkiRpyxv3T+g+l2QVsHdVfSbJDsDWw5YmSZI2x7i3mn0e8BHgH/pJewD/NFRRkiRp843b8e5FwG8BNwJU1eXArw9VlCRJ2nzjhvxPqurWDSNJltH9nbwkSVqgxg35zyV5DbB9kscDHwb+ZbiyJEnS5ho35P8cuAa4GPhj4DTgqKGKkiRJm2/c3vU/A97ZPyRJ0iIw7rXrv8E05+Cr6u5bvCJJkrRFbMy16zfYDngacOctX44kSdpSxjonX1XXjjy+XVV/C/zewLVJkqTNMO7h+n1HRrei27Of9blJTgCeCHyvqu4/zfz9gX8GvtFP+lhVvX6ceiRJ0tzGPVz/NyPDtwFXAk+f4zknAscy+z3n/6OqnjhmDZIkaSOM27v+dzZ2xVX1+SSrN/Z5kiRpyxj3cP2fzja/qo7ZxO0/PMmFwNXAK6vqkhm2fyRwJMBee+21iZuSJGlpGfdiOGuAF9DdmGYP4PnAvsBO/WNTnA+sqqoHAm9nlhveVNXxVbWmqtasWLFiEzcnSdLSMu45+T2BfavqJoAkRwP/VlXP3NQNV9WNI8OnJfm7JMur6vubuk5JkvQL4+7J3wW4dWT81n7aJkuyW5L0ww/ra7l2c9YpSZJ+Ydw9+ZOBLyb5eD/+ZOCk2Z6Q5P3A/sDyJOuB1wHbAFTVO4CDgRckuQ24BTikqryznSRJW8i4vevfmOQTwKP6Sc+pqi/N8ZxD55h/LN2f2EmSpAGMe7geYAfgxqp6K7A+yd0GqkmSJG0BY4V8ktcBrwJe3U/aBnjPUEVJkqTNN+6e/FOAJwE/Aqiqq9n0P52TJEnzYNyQv7XvFFcASX51uJIkSdKWMG7IfyjJPwC7JHke8BngncOVJUmSNte4vev/OsnjgRuBewOvrarTB61MkiRtljlDPsnWwGf6m9QY7JIkLRJzHq6vqtuBnyXZeR7qkSRJW8i4V7z7IXBxktPpe9gDVNVLB6lKkiRttnFD/mP9Q5IkLRKzhnySvarqW1U163XqJUnSwjPXOfmf3+M9yUcHrkWSJG1Bc4V8RobvPmQhkiRpy5or5GuGYUmStMDN1fHugUlupNuj374fph+vqrrToNVJkqRNNmvIV9XW81WIJEnasjbmfvKSJGkRMeQlSWqUIS9JUqMMeUmSGmXIS5LUKENekqRGGfKSJDXKkJckqVGGvCRJjTLkJUlqlCEvSVKjDHlJkhplyEuS1ChDXpKkRhnykiQ1ypCXJKlRhrwkSY0y5CVJapQhL0lSowx5SZIaZchLktQoQ16SpEYZ8pIkNcqQlySpUYa8JEmNMuQlSWqUIS9JUqMGC/kkJyT5XpIvzzA/Sd6WZF2Si5LsO1QtkiQtRUPuyZ8IHDDL/CcAe/ePI4G/H7AWSZKWnMFCvqo+D/xglkUOAk6uztnALkl2H6oeSZKWmmUT3PYewFUj4+v7ad+ZumCSI+n29lm+2x6875xvzUuBS9Uf/eZeky5BC9Bi/H+3GD/Li62dF2MbLyWLouNdVR1fVWuqas1Ou9x50uVIkrQoTDLkvw2sHBnfs58mSZK2gEmG/KnAs/te9vsBN1TVLx2qlyRJm2awc/JJ3g/sDyxPsh54HbANQFW9AzgNOBBYB9wMPGeoWiRJWooGC/mqOnSO+QW8aKjtS5K01C2KjneSJGnjGfKSJDXKkJckqVGGvCRJjTLkJUlqlCEvSVKjDHlJkhplyEuS1ChDXpKkRhnykiQ1ypCXJKlRhrwkSY0y5CVJapQhL0lSowx5SZIaZchLktQoQ16SpEYZ8pIkNcqQlySpUYa8JEmNMuQlSWqUIS9JUqMMeUmSGmXIS5LUKENekqRGGfKSJDXKkJckqVGGvCRJjTLkJUlqlCEvSVKjDHlJkhplyEuS1ChDXpKkRhnykiQ1ypCXJKlRhrwkSY0y5CVJapQhL0lSowx5SZIaZchLktQoQ16SpEYZ8pIkNcqQlySpUYOGfJIDknw1ybokfz7N/MOTXJPkgv7x3CHrkSRpKVk21IqTbA0cBzweWA+cm+TUqrp0yqIfrKoXD1WHJElL1ZB78g8D1lXVFVV1K/AB4KABtydJkkYMGfJ7AFeNjK/vp031B0kuSvKRJCunW1GSI5OsTbL2put/MEStkiQ1Z9Id7/4FWF1VDwBOB06abqGqOr6q1lTVmp12ufO8FihJ0mI1ZMh/GxjdM9+zn/ZzVXVtVf2kH30X8JAB65EkaUkZMuTPBfZOcrckvwIcApw6ukCS3UdGnwRcNmA9kiQtKYP1rq+q25K8GPgUsDVwQlVdkuT1wNqqOhV4aZInAbcBPwAOH6oeSZKWmsFCHqCqTgNOmzLttSPDrwZePWQNkiQtVZPueCdJkgZiyEuS1ChDXpKkRhnykiQ1ypCXJKlRhrwkSY0y5CVJapQhL0lSowx5SZIaZchLktQoQ16SpEYZ8pIkNcqQlySpUYa8JEmNMuQlSWqUIS9JUqMMeUmSGmXIS5LUKENekqRGGfKSJDXKkJckqVGGvCRJjTLkJUlqlCEvSVKjDHlJkhplyEuS1ChDXpKkRhnykiQ1ypCXJKlRhrwkSY0y5CVJapQhL0lSowx5SZIaZchLktQoQ16SpEYZ8pIkNcqQlySpUYa8JEmNMuQlSWqUIS9JUqMMeUmSGmXIS5LUqEFDPskBSb6aZF2SP59m/rZJPtjPPyfJ6iHrkSRpKRks5JNsDRwHPAHYBzg0yT5TFjsCuK6q7gm8BXjzUPVIkrTUDLkn/zBgXVVdUVW3Ah8ADpqyzEHASf3wR4DHJsmANUmStGQMGfJ7AFeNjK/vp027TFXdBtwA7DpgTZIkLRnLJl3AOJIcCRzZj/7kGfut+vIk69kEy4HvT7qIcT1jkdXbs+bhLbZ6/SzPA9t43tx7U540ZMh/G1g5Mr5nP226ZdYnWQbsDFw7dUVVdTxwPECStVW1ZpCKB7LYal5s9YI1z4fFVi9Y83xYbPXC4q15U5435OH6c4G9k9wtya8AhwCnTlnmVOCwfvhg4N+rqgasSZKkJWOwPfmqui3Ji4FPAVsDJ1TVJUleD6ytqlOBdwOnJFkH/IDuh4AkSdoCBj0nX1WnAadNmfbakeEfA0/byNUevwVKm2+LrebFVi9Y83xYbPWCNc+HxVYvLKGa49FxSZLa5GVtJUlq1IIN+cV4Sdwxan50kvOT3Jbk4EnUOKWeuer90ySXJrkoyWeTrJpEnVNqmqvm5ye5OMkFSc6a5iqL826umkeW+4MklWSivX7HaOPDk1zTt/EFSZ47iTqn1DRnGyd5ev95viTJ++a7xim1zNXGbxlp368luX4SdU6paa6a90pyRpIv9d8ZB06izik1zVXzqv677aIkZybZcxJ1jtRzQpLvJZn2z8TTeVv/ei5Ksu+cK62qBfeg66j3deDuwK8AFwL7TFnmhcA7+uFDgA8ugppXAw8ATgYOXgT1/g6wQz/8gkXSxncaGX4S8MmFXnO/3E7A54GzgTULuV7gcODYSbbrJtS8N/Al4Nf68V9fyPVOWf4ldB2XF3obHw+8oB/eB7hyEdT8YeCwfvgxwCkTrvnRwL7Al2eYfyDwCSDAfsA5c61zoe7JL8ZL4s5Zc1VdWVUXAT+bRIFTjFPvGVV1cz96Nt21DiZpnJpvHBn9VWDSnU7G+SwDvIHu3g0/ns/ipjFuvQvJODU/Dziuqq4DqKrvzXONoza2jQ8F3j8vlc1snJoLuFM/vDNw9TzWN51xat4H+Pd++Ixp5s+rqvo83V+azeQg4OTqnA3skmT32da5UEN+MV4Sd5yaF5KNrfcIul+QkzRWzUlelOTrwP8DXjpPtc1kzpr7Q24rq+rf5rOwGYz7ufiD/nDhR5KsnGb+fBqn5nsB90ryhSRnJzlg3qr7ZWP/3+tPkd2NXwTRpIxT89HAM5Osp/urqpfMT2kzGqfmC4Gn9sNPAXZKspAvrb7RObNQQ14LSJJnAmuAv5p0LeOoquOq6h7Aq4CjJl3PbJJsBRwDvGLStWyEfwFWV9UDgNP5xRG1hWwZ3SH7/en2jN+ZZJeJVjSeQ4CPVNXtky5kDIcCJ1bVnnSHlU/pP98L2SuB307yJeC36a7CuhjaemwL9Q3YmEviklkuiTuPxql5IRmr3iSPA/438KSq+sk81TaTjW3jDwBPHrSiuc1V807A/YEzk1xJd57t1Al2vpuzjavq2pHPwruAh8xTbTMZ53OxHji1qn5aVd8AvkYX+pOwMZ/jQ5j8oXoYr+YjgA8BVNV/AdvRXSN+Usb5LF9dVU+tqgfTfc9RVRPv5DiLjc+ZSXYymKXzwTLgCrrDVBs6TNxvyjIv4o4d7z600GseWfZEJt/xbpw2fjBdx5W9J/2Z2Iia9x4Z/n26qysu6JqnLH8mk+14N04b7z4y/BTg7IXexsABwEn98HK6Q567LtR6++XuA1xJfz2TRdDGnwAO74fvS3dOfmK1j1nzcmCrfviNwOsXQFuvZuaOd7/HHTvefXHO9U36Bc3yQg+k+7X9deB/99NeT7dHCd2vxA8D64AvAndfBDU/lG6P4kd0Rx0uWeD1fgb4LnBB/zh1EbTxW4FL+nrPmO7Lc6HVPGXZM5lgyI/Zxv+3b+ML+za+z0Jv4/5L8RjgUuBi4JCFXG8/fjTwpkm37Ua08T7AF/rPxQXA7y6Cmg8GLu+XeRew7YTrfT/wHeCnfVYcATwfeH4/P8Bx/eu5eJzvCq94J0lSoxbqOXlJkrSZDHlJkhplyEuS1ChDXpKkRhnykiQ1ypCXGpXkyf1d7e4z6VokTYYhL7XrUOCs/t9BJNl6qHVL2nyGvNSgJDsCj6S7mMYhI9NfleTiJBcmeVM/7Z5JPtNPOz/JPZLsn+RfR553bJLD++Erk7w5yfnA05I8L8m5/fM/mmSHfrm7JPl4P/3CJI9I8vokLx9Z7xuTvGxeGkVagpZNugBJgzgI+GRVfS3JtUkeAvx6P/03q+rmJHful30v3ZXVPp5kO7of/3PdWe7aqtoXIMmuVfXOfvgv6X5YvB14G/C5qnpKv8e/I92lTj8G/G1/85JD6G4JKmkAhrzUpkPpLvEL3Y16DqW7JOY/VtXNAFX1gyQ7AXtU1cf7aT8GSDLX+j84Mnz/Ptx3oQvyT/XTHwM8u1/v7XS3g76h/9HxYOAuwJeqapI3lpKaZshLjen30B8D/EaSArYGiu5eD+O6jTuezttuyvwfjQyfCDy5qi7sD+nvP8e63wUcDuwGnLARNUnaSJ6Tl9pzMHBKVa2qqtVVtRL4Bt2e9HNGzpnfuapuAtYneXI/bdt+/jeBffrxXYDHzrK9nYDvJNkGeMbI9M8CL+jXu3WSnfvpH6e7K9xD+cVev6QBGPJSew6lC9JRHwV2B04F1ia5AHhlP+9ZwEuTXAT8J7BbVV1Fd2/wL/f/fmmW7f0f4By6O5B9ZWT6y4DfSXIxcB7dXcqoqlvp7l73of4wvqSBeBc6SfOq73B3PvC0qrp80vVILXNPXtK8SbIPsA74rAEvDc89eUmSGuWevCRJjTLkJUlqlCEvSVKjDHlJkhplyEuS1ChDXpKkRv1/zCvuJiWHAAAAAklEQVQyTZnm1OYAAAAASUVORK5CYII=\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" + }, + { + "data": { + "text/plain": [ + "([,\n", + " ],\n", + " )" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "\n", + "# Get components in ground_truth\n", + "labeled, n_components = label(ground_truth, structure)\n", + "component_accuracy_gt, component_labels = component_accuracies(ground_truth, labeled, n_components, predictions)\n", + "\n", + "bins = np.arange(0, 1 + 0.1, step=0.1) \n", + "plt.figure(figsize=(8, 6))\n", + "sns.distplot(component_accuracy_gt, bins=bins, kde=False)\n", + "\n", + "plt.xticks(bins)\n", + "plt.xlim(0, 1)\n", + "plt.xlabel('Accuracy')\n", + "plt.ylabel('Frequency')\n", + "plt.title(\"Accuracy per component distribution\")\n", + "plt.show()\n", + "\n", + "sns.kdeplot(component_accuracy_gt, label='Accuracy per group')\n", + "plt.legend()\n", + "plt.plot([0, 0], [0, 1.6])\n", + "plt.plot([1, 1], [0, 1.])\n", + "plt.title(\"Component accuracy distribution\")\n", + "plt.show()\n", + "\n", + "\n", + "labeled, n_components = label(ground_truth, structure)\n", + "pred_labeled, n_components_pred = label(predictions, structure)\n", + "y_pos = np.arange(2)\n", + "plt.bar(y_pos, [n_components, n_components_pred])\n", + "plt.xticks(y_pos, ['#Components in ground truth', 'Predicted #components'])\n", + "\n" + ] + } + ], + "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.7.1" + }, + "pycharm": { + "stem_cell": { + "cell_type": "raw", + "source": [], + "metadata": { + "collapsed": false + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} \ No newline at end of file