diff --git a/BreastCancerDetection_VariousMLAlgorithm.ipynb b/BreastCancerDetection_VariousMLAlgorithm.ipynb new file mode 100644 index 0000000..534d9f3 --- /dev/null +++ b/BreastCancerDetection_VariousMLAlgorithm.ipynb @@ -0,0 +1,938 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AhpeX5Dm_eLW" + }, + "source": [ + "# **Day-10_BreastCancerDetection_VariousMLAlgorithm**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8rvHswu2td0Z" + }, + "source": [ + "### *Importing Libraries*" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "P-YXxKhu_Uk4" + }, + "source": [ + "import pandas as pd #useful for loading the dataset\n", + "import numpy as np #to perform array\n", + "from matplotlib import pyplot" + ], + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mOt3nocbwvZk" + }, + "source": [ + "### *Choose Dataset from Local Directory*" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "xB2NMwXtw2dG", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 73 + }, + "outputId": "ec354929-3ba9-42a1-b9bb-ccf832a4bb1b" + }, + "source": [ + "from google.colab import files\n", + "uploaded = files.upload()" + ], + "execution_count": 2, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving data.csv to data.csv\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "69Kx6TycwzHo" + }, + "source": [ + "### *Load Dataset*" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "7aXWQK9Cw7Dz" + }, + "source": [ + "dataset = pd.read_csv('data.csv')" + ], + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "huZ5AaCtxD0p" + }, + "source": [ + "### *Summarize Dataset*" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "SmD4EDrkxFzq", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "c8de07bb-c31d-45b6-d7f1-f37549d27d5f" + }, + "source": [ + "print(dataset.shape)\n", + "print(dataset.head(5))" + ], + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(569, 33)\n", + " id diagnosis radius_mean texture_mean perimeter_mean area_mean \\\n", + "0 842302 M 17.99 10.38 122.80 1001.0 \n", + "1 842517 M 20.57 17.77 132.90 1326.0 \n", + "2 84300903 M 19.69 21.25 130.00 1203.0 \n", + "3 84348301 M 11.42 20.38 77.58 386.1 \n", + "4 84358402 M 20.29 14.34 135.10 1297.0 \n", + "\n", + " smoothness_mean compactness_mean concavity_mean concave points_mean \\\n", + "0 0.11840 0.27760 0.3001 0.14710 \n", + "1 0.08474 0.07864 0.0869 0.07017 \n", + "2 0.10960 0.15990 0.1974 0.12790 \n", + "3 0.14250 0.28390 0.2414 0.10520 \n", + "4 0.10030 0.13280 0.1980 0.10430 \n", + "\n", + " ... texture_worst perimeter_worst area_worst smoothness_worst \\\n", + "0 ... 17.33 184.60 2019.0 0.1622 \n", + "1 ... 23.41 158.80 1956.0 0.1238 \n", + "2 ... 25.53 152.50 1709.0 0.1444 \n", + "3 ... 26.50 98.87 567.7 0.2098 \n", + "4 ... 16.67 152.20 1575.0 0.1374 \n", + "\n", + " compactness_worst concavity_worst concave points_worst symmetry_worst \\\n", + "0 0.6656 0.7119 0.2654 0.4601 \n", + "1 0.1866 0.2416 0.1860 0.2750 \n", + "2 0.4245 0.4504 0.2430 0.3613 \n", + "3 0.8663 0.6869 0.2575 0.6638 \n", + "4 0.2050 0.4000 0.1625 0.2364 \n", + "\n", + " fractal_dimension_worst Unnamed: 32 \n", + "0 0.11890 NaN \n", + "1 0.08902 NaN \n", + "2 0.08758 NaN \n", + "3 0.17300 NaN \n", + "4 0.07678 NaN \n", + "\n", + "[5 rows x 33 columns]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-MFwV-9k3Tu1" + }, + "source": [ + "### *Mapping Class String Values to Numbers*" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "yJvwzEfF3ZMe", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "7138e1d5-0f52-4a8d-80e1-63f3280ea23f" + }, + "source": [ + "dataset['diagnosis'] = dataset['diagnosis'].map({'B': 0, 'M': 1}).astype(int)\n", + "print(dataset.head)" + ], + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0qgR6rGRxH5y" + }, + "source": [ + "### *Segregate Dataset into X(Input/IndependentVariable) & Y(Output/DependentVariable)*" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8qOVIILpxefB", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "a50556fe-21af-46eb-ff7e-056be4e2d174" + }, + "source": [ + "X = dataset.iloc[:, 2:32].values\n", + "X" + ], + "execution_count": 6, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[1.799e+01, 1.038e+01, 1.228e+02, ..., 2.654e-01, 4.601e-01,\n", + " 1.189e-01],\n", + " [2.057e+01, 1.777e+01, 1.329e+02, ..., 1.860e-01, 2.750e-01,\n", + " 8.902e-02],\n", + " [1.969e+01, 2.125e+01, 1.300e+02, ..., 2.430e-01, 3.613e-01,\n", + " 8.758e-02],\n", + " ...,\n", + " [1.660e+01, 2.808e+01, 1.083e+02, ..., 1.418e-01, 2.218e-01,\n", + " 7.820e-02],\n", + " [2.060e+01, 2.933e+01, 1.401e+02, ..., 2.650e-01, 4.087e-01,\n", + " 1.240e-01],\n", + " [7.760e+00, 2.454e+01, 4.792e+01, ..., 0.000e+00, 2.871e-01,\n", + " 7.039e-02]])" + ] + }, + "metadata": {}, + "execution_count": 6 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "TE6LNAwmxkBn", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "93adc199-d960-4cdd-9d42-3ad978584020" + }, + "source": [ + "Y = dataset.iloc[:,1].values\n", + "Y" + ], + "execution_count": 7, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1,\n", + " 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1,\n", + " 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0,\n", + " 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1,\n", + " 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0,\n", + " 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n", + " 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1,\n", + " 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1,\n", + " 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0,\n", + " 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0,\n", + " 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,\n", + " 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,\n", + " 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0,\n", + " 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0])" + ] + }, + "metadata": {}, + "execution_count": 7 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oOzExtMjxmup" + }, + "source": [ + "### *Splitting Dataset into Train & Test*" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "uJXcK2PHxqJ9" + }, + "source": [ + "from sklearn.model_selection import train_test_split\n", + "X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size = 0.25, random_state = 0)" + ], + "execution_count": 8, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "89y8rh-3yv15" + }, + "source": [ + "### *Feature Scaling*\n", + "### we scale our data to make all the features contribute equally to the result\n", + "###Fit_Transform - fit method is calculating the mean and variance of each of the features present in our data\n", + "###Transform - Transform method is transforming all the features using the respective mean and variance,\n", + "###We want our test data to be a completely new and a surprise set for our model" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ehsC_5BSy-Pa" + }, + "source": [ + "from sklearn.preprocessing import StandardScaler\n", + "sc = StandardScaler()\n", + "X_train = sc.fit_transform(X_train)\n", + "X_test = sc.transform(X_test)" + ], + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "X1gsZ3YZ51gz" + }, + "source": [ + "### *Validating some ML algorithm by its accuracy - Model Score*" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ekrjJPx_5-rJ" + }, + "source": [ + "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.tree import DecisionTreeClassifier\n", + "from sklearn.neighbors import KNeighborsClassifier\n", + "from sklearn.naive_bayes import GaussianNB\n", + "from sklearn.svm import SVC\n", + "\n", + "from sklearn.model_selection import cross_val_score\n", + "from sklearn.model_selection import StratifiedKFold" + ], + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "7fmWEBDq6fUM" + }, + "source": [ + "models = []\n", + "models.append(('LR', LogisticRegression(solver='liblinear', multi_class='ovr')))\n", + "models.append(('LDA', LinearDiscriminantAnalysis()))\n", + "models.append(('KNN', KNeighborsClassifier()))\n", + "models.append(('CART', DecisionTreeClassifier()))\n", + "models.append(('NB', GaussianNB()))\n", + "models.append(('SVM', SVC(gamma='auto')))" + ], + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "r0dYFpqw6iXs", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 923 + }, + "outputId": "c7d83a67-7567-499b-b99c-3792b5c0f9c5" + }, + "source": [ + "results = []\n", + "names = []\n", + "res = []\n", + "for name, model in models:\n", + " kfold = StratifiedKFold(n_splits=10, random_state=None)\n", + " cv_results = cross_val_score(model, X_train, y_train, cv=kfold, scoring='accuracy')\n", + " results.append(cv_results)\n", + " names.append(name)\n", + " res.append(cv_results.mean())\n", + " print('%s: %f' % (name, cv_results.mean()))\n", + "\n", + "pyplot.ylim(.900, .999)\n", + "pyplot.bar(names, res, color ='maroon', width = 0.6)\n", + "\n", + "pyplot.title('Algorithm Comparison')\n", + "pyplot.show()" + ], + "execution_count": 12, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.11/dist-packages/sklearn/linear_model/_logistic.py:1256: FutureWarning: 'multi_class' was deprecated in version 1.5 and will be removed in 1.7. Use OneVsRestClassifier(LogisticRegression(..)) instead. Leave it to its default value to avoid this warning.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.11/dist-packages/sklearn/linear_model/_logistic.py:1256: FutureWarning: 'multi_class' was deprecated in version 1.5 and will be removed in 1.7. Use OneVsRestClassifier(LogisticRegression(..)) instead. Leave it to its default value to avoid this warning.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.11/dist-packages/sklearn/linear_model/_logistic.py:1256: FutureWarning: 'multi_class' was deprecated in version 1.5 and will be removed in 1.7. Use OneVsRestClassifier(LogisticRegression(..)) instead. Leave it to its default value to avoid this warning.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.11/dist-packages/sklearn/linear_model/_logistic.py:1256: FutureWarning: 'multi_class' was deprecated in version 1.5 and will be removed in 1.7. Use OneVsRestClassifier(LogisticRegression(..)) instead. Leave it to its default value to avoid this warning.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.11/dist-packages/sklearn/linear_model/_logistic.py:1256: FutureWarning: 'multi_class' was deprecated in version 1.5 and will be removed in 1.7. Use OneVsRestClassifier(LogisticRegression(..)) instead. Leave it to its default value to avoid this warning.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.11/dist-packages/sklearn/linear_model/_logistic.py:1256: FutureWarning: 'multi_class' was deprecated in version 1.5 and will be removed in 1.7. Use OneVsRestClassifier(LogisticRegression(..)) instead. Leave it to its default value to avoid this warning.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.11/dist-packages/sklearn/linear_model/_logistic.py:1256: FutureWarning: 'multi_class' was deprecated in version 1.5 and will be removed in 1.7. Use OneVsRestClassifier(LogisticRegression(..)) instead. Leave it to its default value to avoid this warning.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.11/dist-packages/sklearn/linear_model/_logistic.py:1256: FutureWarning: 'multi_class' was deprecated in version 1.5 and will be removed in 1.7. Use OneVsRestClassifier(LogisticRegression(..)) instead. Leave it to its default value to avoid this warning.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.11/dist-packages/sklearn/linear_model/_logistic.py:1256: FutureWarning: 'multi_class' was deprecated in version 1.5 and will be removed in 1.7. Use OneVsRestClassifier(LogisticRegression(..)) instead. Leave it to its default value to avoid this warning.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.11/dist-packages/sklearn/linear_model/_logistic.py:1256: FutureWarning: 'multi_class' was deprecated in version 1.5 and will be removed in 1.7. Use OneVsRestClassifier(LogisticRegression(..)) instead. Leave it to its default value to avoid this warning.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "LR: 0.981285\n", + "LDA: 0.957863\n", + "KNN: 0.964839\n", + "CART: 0.929568\n", + "NB: 0.941417\n", + "SVM: 0.979014\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ospEktZ3_KgQ" + }, + "source": [ + "### *Training & Prediction using the algorithm with high accuracy*" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "zbi3Uvd0_Yn7", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "c3532d24-4239-4945-daee-c3d5ba95fcda" + }, + "source": [ + "from sklearn.svm import SVC\n", + "model.fit(X_train, y_train)\n", + "y_pred = model.predict(X_test)\n", + "print(np.concatenate((y_pred.reshape(len(y_pred),1), y_test.reshape(len(y_test),1)),1))" + ], + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[[1 1]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [1 0]\n", + " [0 0]\n", + " [1 1]\n", + " [0 0]\n", + " [1 1]\n", + " [1 1]\n", + " [1 1]\n", + " [1 1]\n", + " [1 1]\n", + " [0 0]\n", + " [0 0]\n", + " [1 1]\n", + " [0 0]\n", + " [0 0]\n", + " [1 1]\n", + " [0 0]\n", + " [1 1]\n", + " [0 0]\n", + " [1 1]\n", + " [0 0]\n", + " [1 1]\n", + " [0 0]\n", + " [1 1]\n", + " [0 0]\n", + " [1 1]\n", + " [0 0]\n", + " [1 1]\n", + " [1 1]\n", + " [0 0]\n", + " [1 1]\n", + " [0 0]\n", + " [0 0]\n", + " [1 1]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [1 1]\n", + " [1 1]\n", + " [1 1]\n", + " [1 1]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [1 1]\n", + " [1 1]\n", + " [1 1]\n", + " [0 0]\n", + " [0 0]\n", + " [1 1]\n", + " [0 0]\n", + " [1 1]\n", + " [1 1]\n", + " [1 1]\n", + " [0 0]\n", + " [0 0]\n", + " [1 1]\n", + " [0 0]\n", + " [1 1]\n", + " [1 1]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [1 1]\n", + " [1 1]\n", + " [1 1]\n", + " [0 0]\n", + " [1 1]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [1 1]\n", + " [1 1]\n", + " [0 0]\n", + " [0 1]\n", + " [1 0]\n", + " [1 1]\n", + " [0 0]\n", + " [0 0]\n", + " [1 1]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [1 1]\n", + " [0 0]\n", + " [1 1]\n", + " [0 0]\n", + " [0 1]\n", + " [1 1]\n", + " [0 0]\n", + " [1 1]\n", + " [1 1]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [1 1]\n", + " [0 0]\n", + " [1 1]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [1 1]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [0 1]\n", + " [1 1]\n", + " [0 0]\n", + " [0 0]\n", + " [0 0]\n", + " [1 1]]\n" + ] + } + ] + } + ] +} \ No newline at end of file