<p>The Vegetable Classification project shows how CNNs can sort vegetables efficiently. As industries like agriculture and food retail grow, automating vegetable identification becomes crucial. This project provides a guide to building both custom and parallel CNN models. These models help improve classification accuracy, reduce manual effort, and enhance quality control.</p><br>
<p>By learning these methods, you can solve harder classification problems in many areas. The project shows how machine learning helps with smart farming, inventory, and sustainability. It highlights how automating vegetable sorting can benefit real-world tasks.</p>

Categorize vegetables automatically using parallel CNN models. Enhance the precision of smart farming by using deep learning, data augmentation, and feature extraction.

This tutorial on Vegetable Classification using Machine Learing, guides you through automating the sorting process, improving quality control, and enhancing efficiency in agriculture and food industries.

Vegetable classification with Parallel CNN model

<h2><strong>Project Overview</strong></h2>
<p>This project aims to build a parallel CNN model that classifies vegetable types. The model analyzes vegetable images and finds key features that set each type apart. It uses two branches of convolutional layers. These branches merge into a dense network for classification. We also trained a traditional CNN model to compare its performance with that of parallel CNN. We check the results to ensure vegetables are sorted correctly into their categories.</p>
<p>This tutorial covers data preparation, model evaluation, and visualization. It also includes troubleshooting steps. Along with vegetable sorting, it teaches key machine learning ideas. These include data cleaning, augmentation, and model improvement. These concepts apply to broader classification tasks as well.</p>
<br><h2><strong>Prerequisites</strong></h2>
<p>Before starting, you should know the basics of Python and machine learning. You should also understand deep learning concepts. Specifically, knowledge of convolutional neural networks (CNNs) will be essential. Familiarity with TensorFlow and Keras will make the implementation easier to follow. Experience with datasets and processing image data using Pandas and NumPy is useful.</p>
<p>You need access to Google Colab or Jupyter Notebook to run the code and handle computations. Additionally, Basic knowledge of metrics like accuracy, precision, recall, and AUC is helpful. It will help you measure the model's performance well.</p>
<br><h2><strong>Approach</strong></h2>
<p>In this project, we use a machine-learning method with parallel CNN models. The traditional CNN model is our benchmark. The parallel CNN uses multiple branches of layers for deeper feature extraction. We train both models on the same vegetable image dataset. We focus on testing how well the models generalize using validation and test sets.</p>
<p>We use image preprocessing methods like resizing, normalization, and data augmentation. These steps help with training and prevent over-fitting. We also use callbacks like early stopping and learning rate reduction. This improves training time and performance. We show the results with a confusion matrix, classification report, and training metrics.</p>
<br><h2><strong>Workflow and Methodology</strong></h2>
<h3><strong>The overall workflow of this project includes:</strong></h3>
<ul>
  <li><strong>Data Collection:</strong> Gathering images of different vegetable types for classification.</li>
</ul>
<ul>
  <li><strong>Data Preprocessing:</strong> Resizing, normalizing, and augmenting images to prepare for training.</li>
  <li><strong>Model Design:</strong> Building both the custom CNN model and the parallel CNN model.</li>
  <li><strong>Training:</strong> Training the models with training data and evaluating them using validation data.</li>
  <li><strong>Evaluation:</strong> Testing the models on unseen test data to check classification accuracy.</li>
  <li><strong>Visualization:</strong> Plotting metrics like accuracy, precision, recall, AUC, and confusion matrix.</li>
  <li><strong>Optimization:</strong> We use callbacks like early stopping and learning rate reduction. These callbacks help improve the model.</li>
</ul>
<br><h3><strong>The methodology involves:</strong></h3>
<ul>
  <li>
    <p><strong>Data Preprocessing:</strong> We resize and normalize raw images. This converts them into tensors for CNN input. This ensures the model processes consistent image sizes.</p>
  </li>
  <li>
    <p><strong>CNN Architecture:</strong> We design convolutional layers for traditional and parallel CNN models. These layers extract important features for classification.</p>
  </li>
  <li>
    <p><strong>Metrics:</strong> We evaluate model performance using accuracy, precision, recall, and AUC. This ensures a thorough performance check.</p>
  </li>
  <li>
    <p><strong>Callbacks:</strong> We use callbacks like early stopping and learning rate reduction. These help prevent overfitting and improve training efficiency.</p>
  </li>
</ul>
<br><h2><strong>Data Collection</strong></h2>
<p>The dataset contains images of vegetables like tomatoes, cucumbers, bean, bitter gourd, brinjal, broccoli, cabbage, capsicum, carrot, cauliflower, papaya, potato, pumpkin and radish.</p>
<h3><strong>We divided the dataset into three parts:</strong></h3>
<ul>
  <li>Training.</li>
  <li>Validation, and</li>
  <li>Test sets.</li>
</ul>
<p>The images are stored in separate directories for easy model training and evaluation. You can upload the dataset to Google Drive and mount it in Google Colab for quick access during the project.</p>
<br><h2><strong>Data Preparation</strong></h2>
<p>The images first resize to 224x224 pixels to ensure uniformity in the dataset. Next, we apply normalization to scale pixel values between 0 and 1, which speeds up model training. Additionally, We use data augmentation methods like flipping, rotation, and zooming. This creates more diverse training data. This process reduces overfitting and improves the model's ability to generalize.</p>
<br><h2><strong>Data Preparation Workflow</strong></h2>
<ul>
  <li>Image Resizing: We make sure all images are 224x224 pixels. This keeps the dimensions uniform.</li>
  <li>Normalization: We scale pixel values from 0-255 to 0-1. This improves training efficiency.</li>
  <li>Augmentation: We use data augmentation methods like flipping, rotation, and zooming. This creates more diverse training data.</li>
  <li>Dataset Splitting: We split the dataset of training, validation, and test. This helps us develop and evaluate the model properly.</li>
</ul>


<h2>Code Explanation</h2>
<h3 class="">Mount Google Drive</h3>
<p>You can mount your Google Drive in a You can mount your Google Drive in a <a href="https://colab.research.google.com/">Google Colab notebook</a> with this piece of code. This makes it easy to view files saved in Google Drive. In Colab, you can change and analyze data. You can also train models.</p>


<h4><strong>Import the necessary packages.</strong></h4>
<p>This block of code sets up the necessary tools and layers to build a CNN model. It trains and evaluates the model for image classification using TensorFlow and Keras.</p>


<h4><strong>Check GPU availability</strong></h4>
<p>This code checks for available GPUs and sets them to use memory dynamically. It then returns the number of GPUs detected.</p>


<h4><strong>Data processing</strong></h4>
<p>This block of code initializes variables for a TensorFlow data pipeline. It sets the batch size and image dimensions. It also defines a random seed and the path to the dataset. Additionally, it enables automatic tuning for better data-loading performance.</p>


<p>This code creates a training dataset by loading images from `{PATH}/train`. It resizes the images to specific dimensions. The `image_dataset_from_directory` function batches and shuffles the dataset. A seed is used for randomization.</p>


<p>This code creates a testing dataset by loading and resizing images from `{PATH}/test`. The `image_dataset_from_directory` function resizes images and batches them. It keeps the original order (shuffle=False) for consistent evaluation.</p>


<p>This code creates a validation dataset. It loads and resizes images from the directory `{PATH}/validation`. Furthermore, the image_dataset_from_directory function resizes and batches the images. It shuffles the images (shuffle=True) using a seed. This ensures a random order for robust model evaluation.</p>


<h4>Show class names</h4>
<p>This code gets and shows the list of class names (labels) in the training dataset (`train_data`). Additionally, these class names match the different vegetable categories in your dataset.</p>


<h4>Counting Unique Classes in the Dataset</h4>
<p>This code calculates the total number of unique classes in the dataset. It does this by determining the length of the class_names list. Then, it displays the result. This gives you the number of different vegetable types that the model will classify.</p>


<h4>Data Analysis and Visualization</h4>
<h5><strong>Plotting distributions</strong></h5>
<p>This plot_label_distribution function visualizes label distribution in a dataset using Plotly. It combines all labels into a single array, maps them to class names, and creates a DataFrame. Then, it uses Plotly's px.histogram to create a count plot. Each label is shown with distinct colors. It adds titles and labels to the plot. Finally, it displays the plot.</p>


<h4>Show plot of train data distribution</h4>
<p>This block of code is called the plot_label_distribution function. The function creates a visual plot to show the distribution of labels. It shows how many images belong to each vegetable class in the train_data dataset. The plot helps you check if the dataset is balanced. It also highlights any classes with significantly more or fewer images. This information is important for model training.</p>


<h4>Show plot of validation data distribution</h4>
<p>This code creates a visual plot of label distribution for the validation dataset. It uses the `plot_label_distribution` function. It shows the distribution of images across vegetable classes in the validation set. This helps ensure that the validation data is balanced. It also checks if the validation data is representative of the training data.</p>


<h4>Show plot of test data distribution</h4>
<p>This code creates a visual plot of label distribution for the test dataset. It uses the `plot_label_distribution` function. It shows how images are spread across vegetable classes in the test set. This allows you to assess the balance of the test data. It helps check if the test data is suitable for evaluating the model's performance.</p>


<h4><strong>Prepare dataset for training and evaluation</strong></h4>
<p>This block of code preprocesses train_data, test_data, and val_data by unbatching them first. For `train_data` and `val_data`, it caches, shuffles, and re-batches them with a set batch size. It also improves performance. `Test_data` is unbatched, then re-batched without caching or shuffling. It also prefers to load data efficiently during training and evaluation.</p>


<h4>Plotting example images</h4>
<p>The function `closestDivisors` finds two divisors of a number n. It returns the closest pair of these divisors. It starts from the square root of n and decrements until it finds a divisor. Then, it returns the closest divisors.</p>


<p>The `plot_images` function shows a batch of images from a dataset. It defaults to `train_data`. It calculates the grid layout by finding the closest divisors of the batch size for rows and columns. Then, it displays the images in a grid. It sets each subplot title to the corresponding class name. It hides the axes to create a cleaner view.</p>


<h3 class="" style='font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif; color: rgb(41, 41, 41);'>Input Code</h3>


<h4><strong>Choosing an AI Model</strong></h4>
<p>When selecting an AI model, consider the complexity of the classification task. For this project, convolutional neural networks (CNNs) are ideal because they excel at image recognition tasks. Additionally, CNNs are highly effective at capturing patterns and features in images, which makes them perfect for classifying vegetables.</p><br>
<p>We used both a traditional CNN and a parallel CNN model to compare their performance. The traditional CNN processes features through a single path, while the parallel CNN splits into two branches to capture deeper, more complex patterns. This approach enhances classification accuracy, especially when distinguishing between visually similar vegetables.</p><br>
<p>By carefully evaluating both models, we ensured the selected architecture aligned with the project's goal of efficient and accurate vegetable classification.</p><br>
<h4><strong>Build Custom CNN model (Prepare layers)</strong></h4>
<p>This block of code defines a preprocessing step to resize the images. It also normalizes pixel values to a 0-1 range. This is done before feeding the images into the model.</p>


<br><p>This code defines a sequential CNN model. The model is called `model_1`. It is used for image classification with TensorFlow and Keras. Moreover, it consists of multiple convolutional layers with different filter sizes and activations. These layers are interspersed with max pooling and batch normalization layers. Max pooling reduces the dimensions, and batch normalization normalizes activations. A flattening layer converts the 2D feature maps into a 1D vector. This is followed by fully connected layers with ReLU activations. A dropout layer is added for regularization. Finally, a softmax output layer classifies the images into num_classes categories.</p>


<br><p>This code defines two callbacks to improve neural network training and prevent overfitting. The EarlyStopping callback monitors validation loss (val_loss) during training. It stops training if the loss doesn't improve for 5 epochs, starting from the 3rd epoch. It also restores the best weights after stopping. The `ReduceLROnPlateau` callback lowers the learning rate by 0.15. It triggers if `val_loss` does not improve for 2 consecutive epochs. The minimum learning rate is set to 1e-10, with a min_delta of 0.0004. It reduces the rate when no new minimum loss is observed.</p>


<br><p>This block of code defines custom metrics for precision, recall, and AUC. These metrics are designed for sparse categorical predictions. It subclasses TensorFlow's metrics and overrides the update_state method. The method converts predicted probabilities to class indices using tf.argmax. It compiles `model_1` with custom metrics. It uses the Adam optimizer and sparse categorical cross-entropy loss. Finally, it trains the model for 40 epochs on the training data. It uses validation data. It also includes callbacks for early stopping and learning rate reduction. The training history is saved in history_model_1.</p>


<br><p>This code shows a summary of 'model_1', giving an overview of its architecture. It includes the layers, output shapes, and the number of parameters for each layer and the whole model. Additionally, it offers a detailed breakdown of the model's structure.</p>


<br><p>This code creates a visual of 'model_1', showing the input and output shapes for each layer. The image resolution is set by `dpi=75`.</p>


<br><h4><strong>Build Parallel CNN Model</strong></h4>
<p><strong>Normalization layer:</strong> This code creates a normalization layer that rescales input pixels. It divides pixel values by 255 to normalize them from 0-255 to 0-1.</p>


<br><p>This code defines an input layer with shape (img_width, img_height, 3). It adds Gaussian noise with a 0.1 standard deviation. This helps regularize the model and make it more robust.</p>


<br><h4><strong>First branch</strong></h4>
<p>This code defines the first branch of a neural network. It begins with a normalization layer. Then it adds convolutional layers with ReLU activations, batch normalization, and max pooling. These layers reduce the spatial size and increase feature depth. They extract important features from the input.</p>


<br><h4><strong>Second Branch</strong></h4>
<p>This block of code defines the second branch of a neural network, mirroring the first branch. It begins with a normalization layer and Gaussian noise. Then, it uses convolutional layers with ReLU activation. Next, it applies batch normalization. Finally, it performs max pooling. These layers gradually extract features from the input data.</p>


<br><h4><strong>Merging layers</strong></h4>
<p>This code combines the outputs of the two branches along a specific axis (axis=1). It flattens the merged output into a 1D vector. This prepares it for the next dense layers in the neural network.</p>


<br><h4><strong>Output layers</strong></h4>
<p>This code defines the output layers of the neural network. It starts with two dense layers using ReLU activations. Then, a dropout layer with a 0.4 rate is applied for regularization. Finally, a dense layer with softmax activation outputs class probabilities for `num_classes` classification.</p>


<br><h4><strong>Creating model instance</strong></h4>
<p>This code creates a Keras model, `model_2`. It sets `input_layer` as the input. It sets `output_layers` as the output. It connects all the layers into a complete neural network.</p>


<br><h4><strong>Compiling an optimizer</strong></h4>
<p>This code defines custom metrics for sparse categorical predictions. It subclasses TensorFlow's Precision, Recall, and AUC metrics.The `update_state` method is updated. It converts predicted probabilities to class indices using `tf.argmax`. It compiles model_2 with the Adam optimizer and a learning rate of 1e-4. It uses sparse categorical cross-entropy loss. Custom metrics like accuracy, precision, recall, and AUC track performance during training.</p>


<br><p>This block of code displays a summary of model_2. It provides details about the model's architecture. Each layer's type and output shape are included. It also shows the number of parameters for each layer. The total number of parameters is displayed as well.</p>


<br><p>This block of code defines two callbacks for training model_2. The first callback is EarlyStopping. It stops training if the validation loss doesn't improve for 5 epochs. It also restores the best weights. The second callback is ReduceLROnPlateau. It reduces the learning rate by 0.1 if validation loss doesn't improve for 2 consecutive epochs. The minimum learning rate is set to 1e-10. The improvement threshold is 0.0004.</p>


<br><p>This code trains `model_2` for up to 30 epochs using `train_data` and `val_data`. It uses a set batch size and callbacks like early stopping and reduced learning rate. Training stops if validation loss doesn't improve. The learning rate adjusts as needed. Progress is displayed during training.</p>


<br><p>This code generates a visual of `model_2`, showing the input and output shapes for each layer. The resolution is set to `dpi=75`.</p>


<h4><strong>Plotting Matrices</strong></h4>
<p>The `plot_metrics` function shows training and validation metrics. It arranges them in a 2x3 grid. It then evaluates the model on a test dataset. The function prints the test metrics and counts the misclassified images. Finally, it returns the test metrics for further analysis.</p>


<br><p>This code calls the `plot_metrics` function to visualize `model_1`'s training history. It evaluates `model_1` on the test data and stores the test metrics in variables.</p>


<br><p>This code defines the `get_actual_predicted_labels` function. It gets actual labels from an unbatched dataset. It generates predictions using a model. It stacks the actual labels. It converts predicted probabilities to class indices with `tf.argmax`. Finally, it returns both the actual and predicted labels.</p>


<br><p>The `plot_confusion_matrix` function creates a confusion matrix and visualizes it using Seaborn's heatmap. It adds titles, labels, and class names, adjusting the size and font for readability.</p>


<br><h4><strong>Plot Confusion Matrix for Custom CNN Model</strong></h4>
<p>This code collects true labels and model predictions from the parallel CNN model. It uses these for the validation dataset. It then converts these labels and predictions into arrays. After that, it prints a detailed classification report using classification_report. The report shows precision, recall, and F1-score for each class. Metrics are displayed with four decimal places.</p>


<br><p>This code evaluates the combined predictions of model_1 and model_2. It uses a validation dataset for this evaluation. It averages their predicted probabilities. Then, it compares the combined predictions to the true labels. It creates a detailed classification report. It includes precision, recall, and F1-score metrics.</p>


<p>This block of code evaluates the combined predictions of model_1 and model_2 on a validation dataset by averaging their predicted probabilities and comparing the combined predictions to the true labels. It then generates and prints a detailed classification report, including precision, recall, and F1-score metrics.</p>


<p>This code calculates precision and recall for each class. It applies to multi-class classification problems. It uses a confusion matrix for this calculation. True positives (TP) are taken from the diagonal of the matrix. It then derives false positives (FP) and false negatives (FN). These values are used to calculate precision and recall for each class.</p>


<br><p>This block of code calculates the precision and recall for each class in the test dataset. It uses the calculate_classification_metrics function with the actual and predicted labels. Then, it prints out the resulting precision and recall values for the model.</p>


<h4>Visualizing Predictions</h4>
<p>This block of code iterates through the test_data dataset, storing each batch in a list. It then extracts individual images and labels from these batches. The images are appended to the test_images list, and the labels are added to the test_labels list. Finally, it converts these lists into numpy arrays.</p>
