diff --git a/Neural Networks/Vehicle Classifier/README.md b/Neural Networks/Vehicle Classifier/README.md new file mode 100644 index 00000000..cff7e31a --- /dev/null +++ b/Neural Networks/Vehicle Classifier/README.md @@ -0,0 +1,58 @@ +# Vehicle Classifier AI + +## Description + +- Developed a high-performance **Vehicle Image Recognizer** web app using **deep learning techniques**. +- Designed and implemented a **Convolutional Neural Network (CNN)** with **TensorFlow** and **Keras** to classify various vehicle types. +- Integrated a **Flask** server for backend functionality, allowing users to upload vehicle images and receive real-time predictions. +- Supports recognition of vehicles including **bus, family sedan, fire engine, heavy truck, jeep, minibus, racing car, SUV, taxi, and truck**. + +## Features + +- **Real-Time Predictions:** Utilized Flask to manage image uploads and provide on-the-fly predictions for the type of vehicle. +- **Interactive Web App:** Designed an intuitive web interface where users can easily upload images and get immediate classification results. +- **Highly Accurate Model:** Trained the CNN on a dataset of 1,400 images for training and 200 images for validation, leading to a highly performant model. + +## Tech Stack + +- **Programming Language:** Python +- **Machine Learning Libraries:** TensorFlow, Keras +- **Web Framework:** Flask +- **Frontend Technologies:** HTML5, CSS3, JavaScript +- **Dataset:** + - Vehicle classification dataset from Kaggle: [Kaggle Dataset](https://www.kaggle.com/datasets/marquis03/vehicle-classification) + +## Installation Instructions + +`Run all the cells in jupyter, you will have vehicle_model.h5. Now follow the instructions` + +1. Clone the GitHub repository: + ```bash + git clone https://github.com/UppuluriKalyani/ML-Nexus.git + ``` + +2. Navigate to the project directory: + ```bash + cd Neural Networks + cd Vehicle Classifier + ``` + +3. Install the required Python packages: + ```bash + pip install -r requirements.txt + ``` + +4. Run the Flask app: + ```bash + python app.py + ``` + +5. Open your web browser and go to `http://127.0.0.1:5000` to use the app. + +## Screenshot + +![Screenshot 2024-10-18 204728](https://github.com/user-attachments/assets/4706df55-48be-4aca-a606-2c7546318a00) + +## Demo Video + +https://github.com/user-attachments/assets/c9c5d5f9-ba2c-4969-8685-beed10b1e39a diff --git a/Neural Networks/Vehicle Classifier/app.py b/Neural Networks/Vehicle Classifier/app.py new file mode 100644 index 00000000..001e3db4 --- /dev/null +++ b/Neural Networks/Vehicle Classifier/app.py @@ -0,0 +1,62 @@ +from flask import Flask, render_template, request, redirect, url_for +from tensorflow.keras.preprocessing.image import ImageDataGenerator # type: ignore +from tensorflow.keras.models import load_model # type: ignore +from tensorflow.keras.preprocessing import image # type: ignore +import tensorflow as tf +import numpy as np +import os + +app = Flask(__name__) + +train_dir = 'dataset/train' + +model = load_model('vehicle_model.h5') + +batch_size = 32 + +train_datagen = ImageDataGenerator(rescale=1/255) + +classes =['bus', 'family sedan', 'fire engine', 'heavy truck', 'jeep', 'minibus', 'racing car', 'SUV', 'taxi', 'truck'] + +train_generator = train_datagen.flow_from_directory( + train_dir, + target_size=(600, 600), + batch_size=batch_size, + classes = classes, + class_mode='categorical' +) + +loaded_model = tf.keras.models.load_model('vehicle_model.h5') + +def predict_vehicle_with_loaded_model(img_path): + img = image.load_img(img_path, target_size=(600, 600)) + img_array = image.img_to_array(img) + img_array = np.expand_dims(img_array, axis=0) + img_array /= 255.0 + + predictions = loaded_model.predict(img_array) + class_idx = np.argmax(predictions[0]) + class_label = list(train_generator.class_indices.keys())[class_idx] + return class_label + +@app.route('/', methods=['GET', 'POST']) +def upload_file(): + if request.method == 'POST': + print("Received POST request") + if 'file' not in request.files: + print("No file part in request") + return redirect(request.url) + file = request.files['file'] + if file.filename == '': + print("No selected file") + return redirect(request.url) + if file: + file_path = os.path.join('static', file.filename) + print(f"Saving file to {file_path}") + file.save(file_path) + label = predict_vehicle_with_loaded_model(file_path) + return render_template('app.html', label=label, file_path=file.filename) + return render_template('app.html') + +if __name__ == '__main__': + app.run(debug=True) \ No newline at end of file diff --git a/Neural Networks/Vehicle Classifier/requirements.txt b/Neural Networks/Vehicle Classifier/requirements.txt new file mode 100644 index 00000000..84f8da0e --- /dev/null +++ b/Neural Networks/Vehicle Classifier/requirements.txt @@ -0,0 +1,4 @@ +Flask +tensorflow +numpy +keras \ No newline at end of file diff --git a/Neural Networks/Vehicle Classifier/static/css/styles.css b/Neural Networks/Vehicle Classifier/static/css/styles.css new file mode 100644 index 00000000..5aec495c --- /dev/null +++ b/Neural Networks/Vehicle Classifier/static/css/styles.css @@ -0,0 +1,277 @@ +* { + margin: 0; + padding: 0; + box-sizing: border-box; + font-family: 'Poppins', sans-serif; +} + +:root { + --blue: #0071FF; + --light-blue: #B6DBF6; + --dark-blue: #005DD1; + --grey: #f2f2f2; +} + +body { + display: flex; + justify-content: center; + align-items: center; + min-height: 100vh; + background: var(--light-blue); +} + +.container { + max-width: 400px; + width: 100%; + background: #fff; + padding: 30px; + border-radius: 30px; + margin-top:30px; + margin-bottom: 30px; +} + +header { + position: fixed; + top: 0; + left: 0; + width: 100%; + padding: 20px 80px; + display: flex; + background: black; + justify-content: space-between; + align-items: center; + z-index: 99; + font-size: 13px; +} + +.title { + position: relative; + width: 100%; + height: 60px; + background: rgb(226, 220, 220); + margin-bottom: 20px; + border-radius: 15px; + overflow: hidden; + display: flex; + justify-content: center; + align-items: center; + flex-direction: column; + font-size: 25px; + font-weight: 700; +} + +.img-area { + position: relative; + width: 100%; + height: 300px; + background: var(--grey); + margin-bottom: 30px; + border-radius: 15px; + overflow: hidden; + display: flex; + justify-content: center; + align-items: center; + flex-direction: column; +} + +.img-area .icon { + font-size: 100px; +} + +.img-area h3 { + font-size: 20px; + font-weight: 500; + margin-bottom: 6px; +} + +.img-area p { + color: #999; +} + +.img-area img { + position: absolute; + top: 0; + left: 0; + width: 100%; + height: 100%; + object-fit: cover; + object-position: center; + z-index: 100; + display: none; +} + +.img-area.show-img img { + display: block; +} +.img-area::before { + content: attr(data-img); + position: absolute; + top: 0; + left: 0; + width: 100%; + height: 100%; + background: rgba(0, 0, 0, .5); + color: #fff; + font-weight: 500; + text-align: center; + display: flex; + justify-content: center; + align-items: center; + pointer-events: none; + opacity: 0; + transition: all .3s ease; + z-index: 200; +} + +.img-area.active:hover::before { + opacity: 1; +} + +.select-image, +.submit-image, +.upload-another { + display: block; + width: 100%; + padding: 16px 0; + border-radius: 15px; + background: var(--blue); + color: #fff; + font-weight: 500; + font-size: 16px; + border: none; + cursor: pointer; + transition: all .3s ease; + margin-top: 15px; + margin-bottom: 10px; + text-align: center; +} + +.select-image:hover, +.submit-image:hover, +.upload-another:hover { + background: var(--dark-blue); +} + +.submit-image { + margin-top: 10px; +} + +.navigation { + display: flex; + justify-content: space-between; + align-items: center; +} + +.navigation a { + position: relative; + font-size: 1.1em; + color: #fff; + text-decoration: none; + font-weight: 500; + margin-left: 40px; +} + +.navigation a::after { + content: ''; + position: absolute; + left: 0; + bottom: -6px; + width: 100%; + height: 3px; + background: #fff; + border-radius: 5px; + transform-origin: right; + transform: scaleX(0); + transition: transform .5s; +} + +.navigation a:hover::after { + transform-origin: left; + transform: scaleX(1); +} + +.logo { + font-size: 2em; + color: #fff; + user-select: none; +} + +.menu-toggle { + display: none; + color: #fff; + font-size: 2em; + cursor: pointer; +} + +.image_display { + margin-bottom: 20px; +} + +img { + max-width: 100%; + height: auto; + border-radius: 8px; +} + +.info { + position: relative; + overflow: hidden; + display: flex; + justify-content: center; + align-items: center; + flex-direction: column; + margin-top: 100px; + font-size: 25px; + font-weight: 700; + font-size: 1.5rem; /* Adjust font size as needed */ + text-align: center; + padding: 0 20px; /* Adds space on both sides */ +} + + +@media (max-width: 768px) { + header { + padding: 20px; + } + + .navigation { + display: none; + flex-direction: column; + background: black; + width: 100%; + position: absolute; + top: 60px; + left: 0; + } + + .navigation.active { + display: flex; + } + + .navigation a { + margin: 10px 0; + } + + .menu-toggle { + display: block; + + } + + .wrapper { + width: 90%; + max-width: 100%; + height: auto; + margin-top: 70px; + margin-bottom: 10px; + } + + .info { + padding: 0 15px; + } +} + +@media (max-width: 480px) { + .info { + padding: 0 10px; /* Further adjust padding for smaller screens */ + } +} \ No newline at end of file diff --git a/Neural Networks/Vehicle Classifier/templates/app.html b/Neural Networks/Vehicle Classifier/templates/app.html new file mode 100644 index 00000000..74a32557 --- /dev/null +++ b/Neural Networks/Vehicle Classifier/templates/app.html @@ -0,0 +1,83 @@ + + + + + + Vehicle Recognizer + + + + + + + + + + +
+ + + +
+ +
+

A Deep Learning Model Developed Using Convolutional Neural Networks (CNN)

+
+

Vechicle Recognizer AI

+ {% if file_path %} +
+

This is {{ label }}

+ Uploaded Image + +
+ {% else %} +
+ +
+ +

Upload Image

+ +
+ + +
+ {% endif %} +
+
+ + + + + + + diff --git a/Neural Networks/Vehicle Classifier/vehicle_recognizer.ipynb b/Neural Networks/Vehicle Classifier/vehicle_recognizer.ipynb new file mode 100644 index 00000000..4974c9e1 --- /dev/null +++ b/Neural Networks/Vehicle Classifier/vehicle_recognizer.ipynb @@ -0,0 +1,438 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "4745c9c9-6773-4dad-ad46-f269b94812f1", + "metadata": {}, + "outputs": [], + "source": [ + "from keras.models import Sequential\n", + "from keras.layers import Convolution2D\n", + "from keras.layers import MaxPooling2D\n", + "from keras.layers import Flatten\n", + "from keras.layers import Dense\n", + "from keras.models import model_from_json\n", + "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n", + "import tensorflow as tf\n", + "from tensorflow.keras.optimizers import RMSprop" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "93635a6d-96a1-47e1-9fde-d2f4b763e5e9", + "metadata": {}, + "outputs": [], + "source": [ + "batch_size = 32\n", + "\n", + "train_dir = 'dataset/train'\n", + "val_dir = 'dataset/val'\n", + "\n", + "classes =['bus', 'family sedan', 'fire engine', 'heavy truck', 'jeep', 'minibus', 'racing car', 'SUV', 'taxi', 'truck']" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9d366c7e-2eed-4784-be8c-84248ef61d04", + "metadata": {}, + "outputs": [], + "source": [ + "train_datagen = ImageDataGenerator(rescale=1/255)\n", + "val_datagen = ImageDataGenerator(rescale=1/255)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4f5f99ff-6add-44a1-84d8-5f9739d613c3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 1400 images belonging to 10 classes.\n" + ] + } + ], + "source": [ + "train_generator = train_datagen.flow_from_directory(\n", + " train_dir, \n", + " target_size=(600, 600), \n", + " batch_size=batch_size,\n", + " classes = classes,\n", + " class_mode='categorical')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1d853664-01ce-44f0-87c8-dcf3c5aebd3f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 200 images belonging to 10 classes.\n" + ] + } + ], + "source": [ + "val_generator = val_datagen.flow_from_directory(\n", + " val_dir, \n", + " target_size=(600, 600), \n", + " batch_size=batch_size,\n", + " classes = classes,\n", + " class_mode='categorical')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "118d0f9f-a436-4f99-97a2-5d8bd0487d9f", + "metadata": {}, + "outputs": [], + "source": [ + "model = tf.keras.models.Sequential([\n", + " tf.keras.layers.Input(shape=(600, 600, 3)),\n", + " tf.keras.layers.Conv2D(16, (3,3)),\n", + " tf.keras.layers.LeakyReLU(negative_slope=0.01), # LeakyReLU after Conv2D\n", + " tf.keras.layers.MaxPooling2D(2, 2),\n", + " tf.keras.layers.Conv2D(32, (3,3)),\n", + " tf.keras.layers.LeakyReLU(negative_slope=0.01),\n", + " tf.keras.layers.MaxPooling2D(2, 2),\n", + " tf.keras.layers.Conv2D(64, (3,3)),\n", + " tf.keras.layers.LeakyReLU(negative_slope=0.01),\n", + " tf.keras.layers.MaxPooling2D(2, 2),\n", + " tf.keras.layers.Conv2D(128, (3,3)),\n", + " tf.keras.layers.LeakyReLU(negative_slope=0.01),\n", + " tf.keras.layers.MaxPooling2D(2, 2),\n", + " tf.keras.layers.Flatten(),\n", + " tf.keras.layers.Dense(256),\n", + " tf.keras.layers.LeakyReLU(negative_slope=0.01),\n", + " tf.keras.layers.Dense(10, activation='softmax')\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0baa61e0-59b0-46fe-979f-df17b34eedb3", + "metadata": {}, + "outputs": [], + "source": [ + "from tensorflow.keras.optimizers import RMSprop\n", + "\n", + "model.compile(\n", + " loss='categorical_crossentropy',\n", + " optimizer=RMSprop(learning_rate=0.001), metrics=['acc'])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "dbc50552-5ef9-4216-91f0-1574ccff6ac9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1400" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_sample=train_generator.n\n", + "train_sample" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c7a09f48-947b-4a72-a0d9-b4b878f6a548", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "200" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "val_sample=val_generator.n\n", + "val_sample" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a82bd180-fc56-45f7-9faf-4aedde9b94a5", + "metadata": {}, + "outputs": [], + "source": [ + "n_epochs = 30" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "054e3705-f37f-4605-91b6-9765f28b4784", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/30\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\rakhe\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\keras\\src\\trainers\\data_adapters\\py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n", + " self._warn_if_super_not_called()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m200s\u001b[0m 4s/step - acc: 0.1179 - loss: 4.7891 - val_acc: 0.2552 - val_loss: 2.0665\n", + "Epoch 2/30\n", + "\u001b[1m 1/43\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m2:11\u001b[0m 3s/step - acc: 0.2500 - loss: 1.9044" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\rakhe\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\contextlib.py:158: UserWarning: Your input ran out of data; interrupting training. Make sure that your dataset or generator can generate at least `steps_per_epoch * epochs` batches. You may need to use the `.repeat()` function when building your dataset.\n", + " self.gen.throw(value)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 8ms/step - acc: 0.2500 - loss: 1.9044 - val_acc: 0.5000 - val_loss: 1.8021\n", + "Epoch 3/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m163s\u001b[0m 4s/step - acc: 0.3685 - loss: 1.8555 - val_acc: 0.4375 - val_loss: 1.7510\n", + "Epoch 4/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 6ms/step - acc: 0.4062 - loss: 1.8584 - val_acc: 0.5000 - val_loss: 1.7094\n", + "Epoch 5/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m168s\u001b[0m 4s/step - acc: 0.6178 - loss: 1.2165 - val_acc: 0.6354 - val_loss: 1.1232\n", + "Epoch 6/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 6ms/step - acc: 0.7812 - loss: 0.8972 - val_acc: 0.5000 - val_loss: 1.1300\n", + "Epoch 7/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m160s\u001b[0m 3s/step - acc: 0.7984 - loss: 0.5823 - val_acc: 0.5469 - val_loss: 1.4398\n", + "Epoch 8/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 6ms/step - acc: 0.9375 - loss: 0.2473 - val_acc: 0.6250 - val_loss: 1.4157\n", + "Epoch 9/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m162s\u001b[0m 4s/step - acc: 0.9828 - loss: 0.0883 - val_acc: 0.5365 - val_loss: 1.8304\n", + "Epoch 10/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 6ms/step - acc: 0.8438 - loss: 0.4114 - val_acc: 0.6250 - val_loss: 0.8229\n", + "Epoch 11/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m161s\u001b[0m 4s/step - acc: 0.9928 - loss: 0.0343 - val_acc: 0.5885 - val_loss: 2.2273\n", + "Epoch 12/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 6ms/step - acc: 0.9688 - loss: 0.0801 - val_acc: 0.8750 - val_loss: 0.2140\n", + "Epoch 13/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m159s\u001b[0m 3s/step - acc: 1.0000 - loss: 0.0062 - val_acc: 0.6771 - val_loss: 2.0711\n", + "Epoch 14/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 7ms/step - acc: 1.0000 - loss: 0.0013 - val_acc: 0.3750 - val_loss: 3.4740\n", + "Epoch 15/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m162s\u001b[0m 4s/step - acc: 0.9997 - loss: 0.0027 - val_acc: 0.2396 - val_loss: 11.3730\n", + "Epoch 16/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 6ms/step - acc: 0.3750 - loss: 6.3655 - val_acc: 0.5000 - val_loss: 4.3587\n", + "Epoch 17/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m159s\u001b[0m 3s/step - acc: 0.9217 - loss: 0.4085 - val_acc: 0.6458 - val_loss: 1.9645\n", + "Epoch 18/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 4ms/step - acc: 1.0000 - loss: 0.0011 - val_acc: 0.6250 - val_loss: 1.4815\n", + "Epoch 19/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m131s\u001b[0m 3s/step - acc: 1.0000 - loss: 0.0020 - val_acc: 0.6510 - val_loss: 2.1541\n", + "Epoch 20/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 5ms/step - acc: 1.0000 - loss: 1.6152e-04 - val_acc: 0.6250 - val_loss: 3.4187\n", + "Epoch 21/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m153s\u001b[0m 3s/step - acc: 0.9586 - loss: 0.3736 - val_acc: 0.6562 - val_loss: 2.0194\n", + "Epoch 22/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 5ms/step - acc: 1.0000 - loss: 0.0030 - val_acc: 0.6250 - val_loss: 1.5402\n", + "Epoch 23/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m144s\u001b[0m 3s/step - acc: 0.9987 - loss: 0.0045 - val_acc: 0.6562 - val_loss: 2.3526\n", + "Epoch 24/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 5ms/step - acc: 1.0000 - loss: 0.0026 - val_acc: 0.6250 - val_loss: 2.0948\n", + "Epoch 25/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m132s\u001b[0m 3s/step - acc: 1.0000 - loss: 1.7686e-04 - val_acc: 0.6562 - val_loss: 2.6822\n", + "Epoch 26/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 5ms/step - acc: 1.0000 - loss: 8.8277e-05 - val_acc: 0.3750 - val_loss: 3.6568\n", + "Epoch 27/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m147s\u001b[0m 3s/step - acc: 1.0000 - loss: 3.6146e-05 - val_acc: 0.6354 - val_loss: 3.1757\n", + "Epoch 28/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 4ms/step - acc: 1.0000 - loss: 1.8068e-06 - val_acc: 0.7500 - val_loss: 1.4301\n", + "Epoch 29/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m134s\u001b[0m 3s/step - acc: 1.0000 - loss: 1.0706e-05 - val_acc: 0.6354 - val_loss: 3.4502\n", + "Epoch 30/30\n", + "\u001b[1m43/43\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 5ms/step - acc: 1.0000 - loss: 4.1983e-06 - val_acc: 0.7500 - val_loss: 0.9373\n" + ] + } + ], + "source": [ + "history = model.fit(\n", + " train_generator, \n", + " steps_per_epoch=int(train_sample/batch_size), \n", + " epochs=n_epochs,\n", + " validation_data=val_generator,\n", + " validation_steps=int(val_sample/batch_size),\n", + " verbose=1\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "f90d0aab-c8b7-46c2-86ba-916dd727ce88", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Final Training Accuracy: 1.0\n", + "Final Validation Accuracy: 0.75\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "train_acc = history.history['acc']\n", + "val_acc = history.history['val_acc']\n", + "\n", + "plt.plot(range(1, n_epochs+1), train_acc, label='Training Accuracy')\n", + "plt.plot(range(1, n_epochs+1), val_acc, label='Validation Accuracy')\n", + "plt.title('Training and Validation Accuracy')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Accuracy')\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "print(\"Final Training Accuracy:\", train_acc[-1])\n", + "print(\"Final Validation Accuracy:\", val_acc[-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "c292490c-5167-4d56-9b79-0ae176c7ddf9", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" + ] + } + ], + "source": [ + "model.save('vehicle_model.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "69d90ad7-82dd-4c89-b29f-87563707e384", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:absl:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from tensorflow.keras.preprocessing import image\n", + "loaded_model = tf.keras.models.load_model('vehicle_model.h5')\n", + "\n", + "def predict_vehicle_with_loaded_model(img_path):\n", + " img = image.load_img(img_path, target_size=(600, 600))\n", + " img_array = image.img_to_array(img)\n", + " img_array = np.expand_dims(img_array, axis=0)\n", + " img_array /= 255.0\n", + "\n", + " predictions = loaded_model.predict(img_array)\n", + " class_idx = np.argmax(predictions[0])\n", + " class_label = list(train_generator.class_indices.keys())[class_idx]\n", + " return class_label" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "857fa4c2-9770-4cc9-bc82-36d0506cdec5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 105ms/step\n", + "The predicted vehicle is: fire engine\n" + ] + } + ], + "source": [ + "img_path = 'dataset/val/fire engine/4d05406e038cc708cccb6fc4951e8d83.jpg'\n", + "print(f'The predicted vehicle is: {predict_vehicle_with_loaded_model(img_path)}')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.12.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}