{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":3649,"databundleVersionId":46718,"sourceType":"competition"}],"dockerImageVersionId":30698,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load\n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\n# Input data files are available in the read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))\n\n# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2024-05-14T17:27:47.808780Z","iopub.execute_input":"2024-05-14T17:27:47.809976Z","iopub.status.idle":"2024-05-14T17:27:49.037520Z","shell.execute_reply.started":"2024-05-14T17:27:47.809928Z","shell.execute_reply":"2024-05-14T17:27:49.036682Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import numpy as np\nimport pandas as pd\nimport seaborn as sns\nimport matplotlib.pyplot as plt\nimport keras\nfrom keras.datasets import cifar10\nfrom keras.models import Sequential\nfrom keras.layers import Dense, Activation, Dropout, Flatten\nfrom keras.layers import Conv2D, MaxPooling2D\nfrom keras.callbacks import EarlyStopping\nfrom keras.optimizers import Adam","metadata":{"execution":{"iopub.status.busy":"2024-05-14T17:30:32.866475Z","iopub.execute_input":"2024-05-14T17:30:32.866892Z","iopub.status.idle":"2024-05-14T17:30:32.873955Z","shell.execute_reply.started":"2024-05-14T17:30:32.866850Z","shell.execute_reply":"2024-05-14T17:30:32.873069Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"(x_train, y_train), (x_test, y_test) = cifar10.load_data()","metadata":{"execution":{"iopub.status.busy":"2024-05-14T17:28:04.824871Z","iopub.execute_input":"2024-05-14T17:28:04.825483Z","iopub.status.idle":"2024-05-14T17:28:19.191533Z","shell.execute_reply.started":"2024-05-14T17:28:04.825451Z","shell.execute_reply":"2024-05-14T17:28:19.190591Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(f'x_train shape: {x_train.shape}')\nprint(f'y_train shape: {y_train.shape}')\nprint(f'x_test shape: {x_test.shape}')\nprint(f'y_test shape: {y_test.shape}')\nprint(f'No of x_train sample: {x_train.shape[0]}')\nprint(f'No of y_train sample: {y_train.shape[0]}')","metadata":{"execution":{"iopub.status.busy":"2024-05-14T17:28:19.193782Z","iopub.execute_input":"2024-05-14T17:28:19.194702Z","iopub.status.idle":"2024-05-14T17:28:19.202049Z","shell.execute_reply.started":"2024-05-14T17:28:19.194668Z","shell.execute_reply":"2024-05-14T17:28:19.200679Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(type(x_train)) ","metadata":{"execution":{"iopub.status.busy":"2024-05-14T17:28:19.203492Z","iopub.execute_input":"2024-05-14T17:28:19.203915Z","iopub.status.idle":"2024-05-14T17:28:19.213441Z","shell.execute_reply.started":"2024-05-14T17:28:19.203877Z","shell.execute_reply":"2024-05-14T17:28:19.212178Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df = pd.DataFrame(y_train, columns=['classes'])\ndf.value_counts()","metadata":{"execution":{"iopub.status.busy":"2024-05-14T17:28:19.214789Z","iopub.execute_input":"2024-05-14T17:28:19.215176Z","iopub.status.idle":"2024-05-14T17:28:19.245310Z","shell.execute_reply.started":"2024-05-14T17:28:19.215148Z","shell.execute_reply":"2024-05-14T17:28:19.244359Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"fig, axs = plt.subplots()\nsns.countplot(x = 'classes', data = df, palette='cool')\nplt.xlabel(\"Class Label\")\nplt.ylabel(\"Number of Samples\")\nplt.title(\"Number of Samples per Class Distribution\")","metadata":{"execution":{"iopub.status.busy":"2024-05-14T17:28:19.246481Z","iopub.execute_input":"2024-05-14T17:28:19.246781Z","iopub.status.idle":"2024-05-14T17:28:19.633345Z","shell.execute_reply.started":"2024-05-14T17:28:19.246756Z","shell.execute_reply":"2024-05-14T17:28:19.632223Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df = pd.DataFrame(y_test, columns=['classes'])\nprint(df.value_counts())","metadata":{"execution":{"iopub.status.busy":"2024-05-14T17:28:19.634638Z","iopub.execute_input":"2024-05-14T17:28:19.634946Z","iopub.status.idle":"2024-05-14T17:28:19.645202Z","shell.execute_reply.started":"2024-05-14T17:28:19.634913Z","shell.execute_reply":"2024-05-14T17:28:19.644212Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"fig, axs = plt.subplots()\nsns.countplot(x = 'classes', data = df, palette='cool')\nplt.xlabel(\"Class Label\")\nplt.ylabel(\"Number of Samples\")\nplt.title(\"Number of Samples per Class Distribution\")","metadata":{"execution":{"iopub.status.busy":"2024-05-14T17:28:19.646404Z","iopub.execute_input":"2024-05-14T17:28:19.646753Z","iopub.status.idle":"2024-05-14T17:28:20.004168Z","shell.execute_reply.started":"2024-05-14T17:28:19.646727Z","shell.execute_reply":"2024-05-14T17:28:20.003019Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"As we can see, each classe contain exacly 6000 examples( 5000 for training and 1000 for test).\n\nThe graph above shows us that data is balanced and for example if we had just 1000 samples of label 1 that will be a problem , the model will find difficulties to detect label 1\"less accuracy \", so that's not going to happend everything look fine. It's important to know the distribution of dataset behind different classes because the goodness of our model depend on it.\n\nNow let's doing some preprocessing.\n\nThe output variable have 10 posible values. This is a multiclass classification problem. We need to encode these lables to one hot vectors (ex : \"bird\" -> [0,0,1,0,0,0,0,0,0,0]).As we can see, each classe contain exacly 6000 examples( 5000 for training and 1000 for test).","metadata":{}},{"cell_type":"markdown","source":"# Normalizing\nWe have to normalize the data in order to reduce the pixel values. Currently, all the image pixels are in a range from 0–255, and we want the values in the range of 0 and 1. So we can either divide all the pixel values by 255.0 or use the ‘normalize’ command from keras library.","metadata":{}},{"cell_type":"markdown","source":"**key benefits of normalizing:**\n\n1. Improved Model Convergence:\n2. Fairer Treatment of Features:\n3. Enhanced Interpretability:\n4. Optimized Algorithm Performance:\n5. Reduced Risk of Vanishing:","metadata":{}},{"cell_type":"code","source":"# before scaling\nprint(x_train[0].shape)\nprint(x_train[0])","metadata":{"execution":{"iopub.status.busy":"2024-05-14T17:28:20.008931Z","iopub.execute_input":"2024-05-14T17:28:20.009510Z","iopub.status.idle":"2024-05-14T17:28:20.015611Z","shell.execute_reply.started":"2024-05-14T17:28:20.009479Z","shell.execute_reply":"2024-05-14T17:28:20.014559Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"x_train = x_train/255\nx_test = x_test/255","metadata":{"execution":{"iopub.status.busy":"2024-05-14T17:28:20.016859Z","iopub.execute_input":"2024-05-14T17:28:20.017457Z","iopub.status.idle":"2024-05-14T17:28:20.661109Z","shell.execute_reply.started":"2024-05-14T17:28:20.017427Z","shell.execute_reply":"2024-05-14T17:28:20.659973Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# after scaling\nprint(x_train[0].shape)","metadata":{"execution":{"iopub.status.busy":"2024-05-14T17:28:20.662737Z","iopub.execute_input":"2024-05-14T17:28:20.663209Z","iopub.status.idle":"2024-05-14T17:28:20.668905Z","shell.execute_reply.started":"2024-05-14T17:28:20.663170Z","shell.execute_reply":"2024-05-14T17:28:20.667717Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Activation function","metadata":{}},{"cell_type":"markdown","source":"Befor using ANN first try to learn what is activation function\n**Activation function**\nThe activation function can be defined as a mathematical function that introduces non-linearity to the neural network. This enables the models to learn complex patterns and helps them make accurate predictions.\n\nIn simple words, think of it like a switch, that decides whether a neuron should be activated or not. If the input is above a certain threshold or meets certain criteria, the neuron will activate/fire, or else it remains inactive.\n\nfor more better understanding please refer this article --link text\nwe have many activation function\n1. Step Function:\n2. Sigmoid Function: \n3. ReLU:","metadata":{}},{"cell_type":"markdown","source":"**ReLu:**\nReLU is the most popular and commonly used activation function. It outputs the input value if it is positive or returns zero. It has advantage over sigmoid and tanh\n\n![image.png](attachment:3e4b39c9-d231-4a92-9d89-5b5d80c662a2.png)","metadata":{},"attachments":{"3e4b39c9-d231-4a92-9d89-5b5d80c662a2.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"ReLU is majorly used in the hidden layers of the neural network since it brings sparsity to the data.\n1. Non-linearity:\n2. Computationally Efficient:\n3. No Vanishing Gradient Problem:","metadata":{}},{"cell_type":"markdown","source":"**Defining the model architecture Using ConVnets**\nNow Let us define a suitable deep net.\n\nIn the first stage, Our net will learn **32** convolutional filters, each of which with a** 3 x 3 size**. The output dimension is the same one of the input shape, so it will be **32 x 32** and activation is relu, which is a simple way of introducing non-linearity; folowed by another 32 convolutional filters, each of which with a 3 x 3 size and activation is also relu. After that we have a max-pooling operation with pool size **2 x 2** and a dropout at 25%.\nIn the next stage in the deep pipeline, Our net will learn 64 convolutional filters, each of which with a **3 x 3** size. The output dimension is the same one of the input shape and activation is relu; folowed by another **64 convolutional filters**, each of which with a 3 x 3 size and activation is also relu. After that we have a max-pooling operation with pool size 2 x 2 and a dropout at 25%.\nAnd the Final stage in the deep pipeline is a dense network with **512** units and relu activation followed by a dropout at 50% and by a softmax layer with **10 classes** as output, one for each category.\nNow let us look at the code review for our architecture.","metadata":{}},{"cell_type":"code","source":"#define the convnet\ncnn_classifier = Sequential()\n# CONV => RELU => CONV => RELU => POOL => DROPOUT\ncnn_classifier.add(Conv2D(32, (3, 3), padding='same',input_shape=x_train.shape[1:]))\ncnn_classifier.add(Activation('relu'))\ncnn_classifier.add(Conv2D(32, (3, 3)))\ncnn_classifier.add(Activation('relu'))\ncnn_classifier.add(MaxPooling2D(pool_size=(2, 2)))\ncnn_classifier.add(Dropout(0.25))\n\n# CONV => RELU => CONV => RELU => POOL => DROPOUT\ncnn_classifier.add(Conv2D(64, (3, 3), padding='same'))\ncnn_classifier.add(Activation('relu'))\ncnn_classifier.add(Conv2D(64, (3, 3)))\ncnn_classifier.add(Activation('relu'))\ncnn_classifier.add(MaxPooling2D(pool_size=(2, 2)))\ncnn_classifier.add(Dropout(0.25))\n\n# FLATTERN => DENSE => RELU => DROPOUT\ncnn_classifier.add(Flatten())\ncnn_classifier.add(Dense(512))\ncnn_classifier.add(Activation('relu'))\ncnn_classifier.add(Dropout(0.5))\n# a softmax classifier\ncnn_classifier.add(Dense(10))\ncnn_classifier.add(Activation('softmax'))\n\ncnn_classifier.summary()","metadata":{"execution":{"iopub.status.busy":"2024-05-14T17:29:27.429209Z","iopub.execute_input":"2024-05-14T17:29:27.429599Z","iopub.status.idle":"2024-05-14T17:29:27.685187Z","shell.execute_reply.started":"2024-05-14T17:29:27.429570Z","shell.execute_reply":"2024-05-14T17:29:27.683879Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Optimization\nThe optimization algorithm is called “**gradient descent**“, where “gradient” refers to the calculation of an error gradient or **slope of error** and “descent” refers to the moving down along that **slope towards some minimum** level of error.","metadata":{}},{"cell_type":"code","source":"\n# compile the neural network\n\n# compilation is a step that transforms the simple sequence of layers\n# that we previously defined into a highly efficient series of matrix transformations\n\n# Optimizer it helps in reducing the overall loss and improving accuracy.\n\n# Adam optimization is a stochastic gradient descent method that is based on\n# adaptive estimation of first-order and second-order moments.\n\n# sparse_categarical_cross. when each sample belongs exactly to one\n# categorical crossentropy when one sample can have multiple classes or labels are\n\n# soft probabilities (like [0.5, 0.3, 0.2]).\n\ncnn_classifier.compile(optimizer = 'adam', loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])","metadata":{"execution":{"iopub.status.busy":"2024-05-14T17:29:27.687347Z","iopub.execute_input":"2024-05-14T17:29:27.687708Z","iopub.status.idle":"2024-05-14T17:29:27.704610Z","shell.execute_reply.started":"2024-05-14T17:29:27.687678Z","shell.execute_reply":"2024-05-14T17:29:27.703254Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Epoch\nThe number of epochs is a hyperparameter that defines the number times that the learning algorithm will work through the entire training dataset.\nThe number of epochs can be set to an integer value between **one and infinity**. You can run the algorithm for as long as you like and even stop it using other criteria besides a fixed number of epochs just like here i have use fixed number of **epochs equeal to 50** as well as other stoping criteria that is **Early stopping**","metadata":{}},{"cell_type":"markdown","source":"# Batch\nThe batch size is a hyperparameter that defines the number of samples to work through before updating the internal model parameters.\n\n**1<= batch size <= number of samples in the training dataset.**\n\nThink of a batch as a for-loop iterating over one or more samples and making predictions. At the end of the batch, the predictions are compared to the expected output variables and an error is calculated. From this error, the update algorithm is used to improve the model, e.g. move down along the error gradient.\n\n**Depending upon size of batch we divide it into 3 category**\n1. **Batch Gradient Descent**. Batch Size = Size of Training Set\n2. **Stochastic Gradient Descent**. Batch Size = 1\n3. **Mini-Batch Gradient Descent**. 1 < Batch Size < Size of Training Set","metadata":{}},{"cell_type":"code","source":"# Define early stopping callback\nearly_stopping = EarlyStopping(monitor='val_loss', patience=10)\n\n# training the neural network\n# validation_split is Fraction of the training data to be used as validation data\n# Epoch is the total number of iterations of the training data in one cycle\nhistory = cnn_classifier.fit(x_train, y_train, validation_split=0.1, epochs=100, batch_size=64, callbacks=[early_stopping])","metadata":{"execution":{"iopub.status.busy":"2024-05-14T17:30:46.951323Z","iopub.execute_input":"2024-05-14T17:30:46.951701Z","iopub.status.idle":"2024-05-14T18:25:46.562272Z","shell.execute_reply.started":"2024-05-14T17:30:46.951672Z","shell.execute_reply":"2024-05-14T18:25:46.560936Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**We got accuracy of 87.62% with training dataset and 80.34 with validation dataset**\nwhich is quit good, Now will see using transfer learning in next notebook.","metadata":{}},{"cell_type":"markdown","source":"Now we can save our trained model, since it takes lots of resuources to train our model everytime so we can save and later we load and use it directly.","metadata":{}},{"cell_type":"code","source":"cnn_classifier.save('cnn_classifier.h5')","metadata":{"execution":{"iopub.status.busy":"2024-05-14T18:25:46.564813Z","iopub.execute_input":"2024-05-14T18:25:46.565196Z","iopub.status.idle":"2024-05-14T18:25:46.641513Z","shell.execute_reply.started":"2024-05-14T18:25:46.565164Z","shell.execute_reply":"2024-05-14T18:25:46.640563Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"loss, accuracy = cnn_classifier.evaluate(x_test, y_test)\nprint('Test Accuracy =', accuracy)","metadata":{"execution":{"iopub.status.busy":"2024-05-14T18:25:46.643161Z","iopub.execute_input":"2024-05-14T18:25:46.644334Z","iopub.status.idle":"2024-05-14T18:25:53.639371Z","shell.execute_reply.started":"2024-05-14T18:25:46.644297Z","shell.execute_reply":"2024-05-14T18:25:53.638417Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"h = history\nplt.title('ANN')\n# plot the loss value\nplt.plot(h.history['loss'], label='train loss')\nplt.plot(h.history['val_loss'], label='validation loss')\nplt.legend()\nplt.show()\n\n# plot the accuracy value\nplt.plot(h.history['accuracy'], label='train accuracy')\nplt.plot(h.history['val_accuracy'], label='validation accuracy')\nplt.legend()\n\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-05-14T18:25:53.641930Z","iopub.execute_input":"2024-05-14T18:25:53.643224Z","iopub.status.idle":"2024-05-14T18:25:54.221825Z","shell.execute_reply.started":"2024-05-14T18:25:53.643182Z","shell.execute_reply":"2024-05-14T18:25:54.220485Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}