<h1><strong>Stock Market Forecasting with&nbsp;LSTM</strong></h1><p>A Comprehensive Guide to Stock Market Forecasting with LSTM and&nbsp;Python</p><img src="https://cdn-images-1.medium.com/max/1800/1*t2NAznkRiQEmF7hDFc2JxQ.png"><p style="text-align: center"><strong>TSLA Stock Price Forecasting using&nbsp;LSTM</strong></p><p>Stock market forecasting has always been a fascinating challenge for investors, analysts, and researchers.</p><p>As stock prices move in complex patterns influenced by numerous factors, predicting future price movements has remained elusive for many years.</p><p>However, with advancements in machine learning, particularly the use of Long Short-Term Memory (LSTM) models, predicting stock market trends has become more accessible.</p><p>LSTM is a type of Recurrent Neural Network (RNN) that excels at learning from sequential data.</p><p>Since the stock market is inherently sequential, with prices depending on past behavior, LSTM models have proven to be highly effective in predicting future trends based on historical data.</p><h2>What Makes LSTM Ideal for Stock Forecasting?</h2><blockquote><p>LSTM networks are designed to process sequences of data.</p></blockquote><p>Unlike traditional machine learning models, LSTMs have the ability to <em>remember</em> information for long periods, making them well-suited for time series forecasting.</p><p>In the context of stock market data, an LSTM can look back at past stock prices (often over days, months, or years) and recognize patterns that can provide valuable insights into future price movements.</p><p>The key advantage of LSTM models is their capacity to retain important information over time.</p><p>Stock prices don’t change in isolation; they are influenced by a variety of factors such as market sentiment, global events, and economic data.</p><p>LSTM models can capture these complex relationships in a way that traditional models cannot, enabling them to make more accurate predictions.</p><h2>Key Considerations in Using LSTM for Stock Forecasting</h2><p>While LSTM offers a promising approach to forecasting stock prices, several considerations should be taken into account before diving in.</p><ol><li><p><strong>Data Quality</strong>: The first step in any machine learning project is gathering the right data. For stock forecasting, this typically means historical price data, such as the open, close, high, and low prices, along with trading volume. But data alone isn’t enough; the quality and granularity of the data matter. Data must be cleaned and properly preprocessed to ensure accurate predictions.</p></li><li><p><strong>Time Window</strong>: LSTM models perform better when given a window of past data to learn from. In the case of stock prices, this might mean using the last 30 days of price movements to predict the next day’s price. However, the ideal time window (often referred to as <code>time_step</code>) depends on the nature of the stock being analyzed and the frequency of trading data (daily, hourly, etc.).</p></li><li><p><strong>Overfitting</strong>: Like any machine learning model, LSTM can suffer from overfitting, especially when the model learns too much from historical data and becomes overly tailored to it. This can make the model ineffective on new, unseen data. Techniques like regularization, dropout layers, and careful tuning of model parameters can help mitigate this risk.</p></li><li><p><strong>Feature Selection</strong>: It’s tempting to use a lot of different features, like technical indicators (moving averages, RSI, etc.), sentiment analysis data, or even news articles. While more data can be useful, it’s important to focus on features that genuinely affect stock prices. Too many irrelevant features can overwhelm the model and reduce its performance.</p></li><li><p><strong>Model Evaluation</strong>: It’s important to evaluate the performance of the LSTM model not just on training data, but on a separate test set. You can look at metrics like Mean Squared Error (MSE) or Mean Absolute Error (MAE) to assess how well the model is predicting stock prices. Visualizing predictions alongside actual stock prices is also a helpful way to gauge the model’s effectiveness.</p></li></ol><h2>The Usefulness of LSTM in Stock Market Forecasting</h2><p>LSTM-based forecasting models offer several compelling advantages for stock market analysis:</p><ol><li><p><strong>Predicting Trends, Not Just Prices</strong>: LSTM models are not only good for predicting stock prices for the next day or week but can also help investors identify long-term trends. By capturing patterns in historical data, LSTMs can provide insights into potential upward or downward movements over longer periods, helping investors make strategic decisions.</p></li><li><p><strong>Handling Complex Relationships</strong>: The stock market is influenced by a myriad of factors, many of which are non-linear and interdependent. LSTM models can capture these complexities far better than traditional statistical models, which often assume linear relationships between variables.</p></li><li><p><strong>Real-Time Predictions</strong>: LSTMs can be updated in real-time with new data, allowing for continuous forecasting. As new stock price data comes in, the model can adjust its predictions to reflect the most current information, making it a valuable tool for day trading and real-time market analysis.</p></li><li><p><strong>Risk Management</strong>: Traders and institutions can use LSTM models to better manage risk by forecasting potential price fluctuations and predicting market crashes or bullish trends. By incorporating LSTM models into their decision-making process, traders can gain a more accurate understanding of market behavior.</p></li></ol><h2>Limitations and Challenges of LSTM for Stock Forecasting</h2><p>While LSTM models offer great promise, they are not a magic bullet for predicting stock prices. The following are some limitations and challenges you should be aware of:</p><ul><li><p><strong>Data Dependency</strong>: The performance of an LSTM model heavily depends on the quality and quantity of data. If the historical data is noisy or incomplete, the model’s predictions will likely be unreliable.</p></li><li><p><strong>Unpredictable Events</strong>: LSTMs are trained on historical data, meaning they are often not equipped to predict unpredictable events like sudden market crashes, geopolitical events, or natural disasters. While LSTMs can forecast trends, they can’t predict <em>black swan</em> events that defy historical patterns.</p></li><li><p><strong>Market Efficiency</strong>: The Efficient Market Hypothesis (EMH) suggests that stock prices already reflect all available information, meaning forecasting stock prices might be inherently impossible. While LSTM models can often find patterns that humans cannot, it’s worth considering that some degree of unpredictability is built into the market.</p></li></ul><h2>Stock Forecasting with&nbsp;Python</h2><p>You can find all the code on <a target="_blank" rel="noopener" class="link markup--anchor markup--p-anchor" href="https://github.com/Brianhulela/LSTM_stock_forecasting"><strong>GitHub</strong></a><strong>.</strong></p><h3>Set Up the Environment</h3><p>To forecast stock prices with LSTM, you’ll need Python along with a few essential libraries. In your python environment, install the following libraries:</p><div class="code-block-wrapper"><div class="code-language">Bash</div><pre data-language="bash"><code class="language-bash">pip install numpy pandas matplotlib scikit-learn tensorflow yfinance</code></pre></div><p>Once the libraries have been installed, add the following import to your&nbsp;<code>.ipynb</code> jupyter notebook.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python"># Import necessary libraries
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
from datetime import datetime
import yfinance as yf
from sklearn.preprocessing import MinMaxScaler
import numpy as np</code></pre></div><h3>Prepare Data</h3><p>We’ll use historical data from <a target="_blank" rel="noopener ugc nofollow noopener noopener" class="link markup--anchor markup--p-anchor" href="https://finance.yahoo.com/"><strong>Yahoo Finance</strong></a> to apply our strategy. For this example, let’s use Tesla’s stock (TSLA).</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python"># Define the stock symbol and the date range for our data
stock_symbol = 'TSLA'
start_date = '2016-01-01'
end_date = datetime.today().strftime('%Y-%m-%d')  # Sets end date to today's date
print(f"Ticker: {stock_symbol}\nStart Date: {start_date}\nEnd Date: {end_date}")</code></pre></div><p>After downloading the data, we can now preprocess it for easy forecasting:</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python">df = yf.download(stock_symbol, start=start_date, end=end_date)

# Select the desired columns (first level of MultiIndex)
df.columns = df.columns.get_level_values(0)
# Keep only the columns you are interested in
df = df[['Open', 'Close', 'Volume', 'Low', 'High']]
# If the index already contains the dates, rename the index
df.index.name = 'Date'  # Ensure the index is named "Date"
    
# Resetting the index if necessary
df.reset_index(inplace=True)
# Ensure that the index is of type datetime
df['Date'] = pd.to_datetime(df['Date'])
# Set the 'Date' column as the index again (in case it's reset)
df.set_index('Date', inplace=True)
df.head()</code></pre></div><h3>Visualize the&nbsp;Chart</h3><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python"># Plot the closing price over time
plt.figure(figsize=(14, 7))
plt.plot(df['Close'], label='Closing Price')
plt.title('Tesla Stock Closing Price Over Time')
plt.xlabel('Date')
plt.ylabel('Price')
plt.legend()
plt.grid(True)
plt.show()</code></pre></div><img src="https://cdn-images-1.medium.com/max/1800/1*gGJPnJ91gp4Zr-UzQmd-TA.png"><p style="text-align: center"><strong>TSLA Closing Price Visualization</strong></p><h3>Scale the&nbsp;Data</h3><p>In this step, we extract the <code>Close</code> prices for forecasting and reshape the data to a 2D array. The <code>MinMaxScaler</code> is then used to normalize the data, scaling it to a range between 0 and 1 to prepare it for training the model.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python"># Use the 'Close' prices for forecasting
data = df['Close'].values

# Reshape the data to 2D array (required for MinMaxScaler)
data = data.reshape(-1, 1)

# Normalize the data using MinMaxScaler
scaler = MinMaxScaler(feature_range=(0, 1))
scaled_data = scaler.fit_transform(data)</code></pre></div><h3>Data Split</h3><p>The dataset is split into training (80%) and testing (20%) sets. A function is defined to prepare the data for the LSTM model by creating sequences of 30 previous days’ prices to predict the next day’s price. The data is then reshaped into 3D arrays to match the LSTM input format.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python"># Split the data into training and test sets (80% training, 20% testing)
train_size = int(len(scaled_data) * 0.8)
train_data, test_data = scaled_data[:train_size], scaled_data[train_size:]

# Create a function to prepare the data for LSTM
def create_dataset(data, time_step):
    X, y = [], []
    for i in range(len(data) - time_step - 1):
        X.append(data[i:(i + time_step), 0])
        y.append(data[i + time_step, 0])
    return np.array(X), np.array(y)

# Prepare training and testing data
time_step = 30  # Using 30 previous days to predict the next one
X_train, y_train = create_dataset(train_data, time_step)
X_test, y_test = create_dataset(test_data, time_step)

# Reshape the data into 3D array for LSTM input (samples, time steps, features)
X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)
X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], 1)

X_train.shape, X_test.shape</code></pre></div><h3><strong>Build the LSTM&nbsp;Model</strong></h3><p>An LSTM model is built with two LSTM layers, each having 50 units. The first layer returns sequences to feed into the second layer, while the output layer uses the <code>ReLU</code> activation function to ensure non-negative predictions. The model is compiled using the <code>Adam optimizer</code> and <code>mean squared error</code> loss. The model summary is displayed to show the architecture.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python"># Build the LSTM model
model = Sequential()

# First LSTM layer
model.add(LSTM(units=50, return_sequences=True, input_shape=(X_train.shape[1], 1)))

# Second LSTM layer
model.add(LSTM(units=50, return_sequences=False))

# Output layer with ReLU activation to ensure non-negative predictions
model.add(Dense(units=1, activation='relu'))  # ReLU prevents negative predictions

# Compile the model
model.compile(optimizer='adam', loss='mean_squared_error')

# Summarize the model
model.summary()</code></pre></div><h3><strong>Begin Training</strong></h3><p>The model is trained using the training data for 50 epochs with a batch size of 32. Validation data (test set) is provided to monitor performance during training and prevent overfitting.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python"># Train the LSTM model
history = model.fit(X_train, y_train, epochs=50, batch_size=32, validation_data=(X_test, y_test))

# Save the trained model to a file
model.save(f'{stock_symbol}_lstm_stock_model.h5')

print("Model saved successfully!")</code></pre></div><h3>Visualize Training&nbsp;Results</h3><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python"># Plot training and validation loss
plt.figure(figsize=(10, 6))
plt.plot(history.history['loss'], label='Training Loss', color='blue')
plt.plot(history.history['val_loss'], label='Validation Loss', color='orange')

# Customize the plot
plt.title('Training and Validation Loss Over Epochs')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.grid(True)

# Show the plot
plt.show()</code></pre></div><img src="https://cdn-images-1.medium.com/max/1800/1*zFzVdgv7JsCFDhFA9oCgiw.png"><p style="text-align: center">Training Results&nbsp;Plot</p><h3><strong>Predict Future&nbsp;Data</strong></h3><p>The model predicts stock prices on the test data, and both predicted and actual values are inverse-transformed to their original scale. Additionally, the model forecasts the next 30 days of stock prices using the most recent data, with each prediction used to update the input for subsequent forecasts.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python"># Predict on the test data
predicted_prices = model.predict(X_test)

# Inverse transform the predictions and actual values to get the original scale
predicted_prices = scaler.inverse_transform(predicted_prices)
y_test_actual = scaler.inverse_transform(y_test.reshape(-1, 1))

# Forecast
last_n_days = scaled_data[-time_step:].reshape(1, -1)
last_n_days = last_n_days.reshape((last_n_days.shape[0], last_n_days.shape[1], 1))

next_n = 30

predicted_next_n = []
for _ in range(next_n):
    next_day = model.predict(last_n_days)
    predicted_next_n.append(next_day[0, 0])
    last_n_days = np.append(last_n_days[:, 1:, :], next_day.reshape(1, 1, 1), axis=1)

predicted_next_n = scaler.inverse_transform(np.array(predicted_next_n).reshape(-1, 1))</code></pre></div><h3>Plot the Prediction Results</h3><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python"># Plot the historical data and forecasted target data
plt.figure(figsize=(14, 7))

# Plot the full historical closing prices
plt.plot(df.index, data, label='Historical Prices', color='blue', alpha=0.6)

# Plot the actual closing prices from test data (this part will be part of the full data)
plt.plot(df.index[-len(y_test_actual):], y_test_actual, label='Actual Prices (Test Data)', color='blue', linestyle='--')

# Plot the predicted prices from the model (for test data)
plt.plot(df.index[-len(predicted_prices):], predicted_prices, label='Predicted Prices (Test Data)', color='red')

# Post-process the forecasted values to make sure they are non-negative
predicted_next_n[predicted_next_n &lt; 0] = 0  # Prevent negative forecasted prices

# Plot the forecasted prices
forecast_dates = pd.date_range(df.index[-1], periods=next_n+1, freq='D')[1:]  # Generate dates for the forecast
plt.scatter(forecast_dates, predicted_next_n, label=f'Forecasted Prices (Next {next_n} Days)', color='lime', s=20, alpha=0.7)
plt.plot(forecast_dates, predicted_next_n, color='green', linestyle='-', linewidth=2)

# Customize the plot
plt.title(F'{stock_symbol} Closing Price Forecasting with LSTM')
plt.xlabel('Date')
plt.ylabel('Price')
plt.legend()
plt.grid(True)

# Save plot in 300 dpi
plt.savefig(f'{stock_symbol}_forecast.png', dpi=300)

# Show the plot
plt.show()</code></pre></div><img src="https://cdn-images-1.medium.com/max/1800/1*t2NAznkRiQEmF7hDFc2JxQ.png"><p style="text-align: center">TSLA Stock Price with Forecast on Test Data and a Future&nbsp;Period</p><h2>Conclusion</h2><p>Stock market forecasting with LSTM is a powerful approach that leverages deep learning to uncover hidden patterns in time series data.</p><p>By understanding the nuances of LSTM and considering key factors like data quality, model evaluation, and overfitting, investors can harness the power of this technology to gain an edge in the market.</p><p>However, like any tool, LSTM should be used cautiously and responsibly, keeping in mind the limitations and uncertainties inherent in financial markets.</p>

A Comprehensive Guide to Stock Market Forecasting with LSTM and Python

Stock Market Forecasting with LSTM

<h1>Fine-Tuning and Transfer Learning Explained</h1><p>Build Better Models Faster Using Knowledge from Existing Networks</p><img src="https://github.com/Brianhulela/ebook_object_detection/blob/master/chapters/CNN_bounding_box_detect/cnn_architecture.drawio.png?raw=true"><p>Training deep learning models from scratch requires large amounts of data, computing power, and time. Transfer learning and fine-tuning offer a more efficient approach by allowing you to build on the knowledge captured by existing models trained on large datasets.</p><p>This article breaks down what transfer learning and fine-tuning are, when to use them, and how to apply them effectively.</p><h2>What is Transfer Learning?</h2><p>Transfer learning is the practice of taking a model that has already been trained on a large and general dataset, and adapting it to a different but related task. The idea is that the model has already learned useful features that don’t need to be relearned from scratch.</p><p>For example, a model trained on millions of general images can recognize edges, textures, and shapes that are also useful for identifying specific categories like medical scans, food items, or vehicle types.</p><h2>When is Transfer Learning Useful?</h2><p>Transfer learning is most helpful when:</p><ul><li><p>You have a small dataset or limited access to labeled data.</p></li><li><p>Your task is related to a well-established domain with existing models.</p></li><li><p>You want to reduce the cost and time of training.</p></li></ul><p>It is commonly used in image <a target="_blank" rel="noopener noreferrer nofollow" class="link" href="https://hulela.co.za/learn/rU5hAJuIJkfAanGTspUT/N31Fp0bfBxv92NdKlpp3?type=publishedchapter">classification</a>, <a target="_blank" rel="noopener noreferrer nofollow" class="link" href="https://hulela.co.za/learn/rU5hAJuIJkfAanGTspUT/EdidCGkFJIJLkz9JpQhK?type=publishedchapter">object detection</a>, text classification, sentiment analysis, and other tasks where large pre-trained models exist.</p><h2>What is Fine-Tuning?</h2><p>Fine-tuning is the process of adjusting a pre-trained model so that it performs better on a specific task. This is usually done after applying transfer learning.</p><p>There are two main approaches:</p><h3>1. Feature Extraction</h3><p>With <a target="_blank" rel="noopener noreferrer nofollow" class="link" href="https://hulela.co.za/learn/rU5hAJuIJkfAanGTspUT/OCiRGYXlA16BEuQUjSfj?type=publishedchapter">feature extraction</a> you keep the entire pre-trained model unchanged and only train a new classification layer on top of it. The model acts as a fixed feature extractor.</p><h3>2. Fine-Tuning</h3><p>You unfreeze some or all layers of the pre-trained model and continue training it on your dataset. This allows the model to adapt its internal representations to the new task more precisely.</p><p>Fine-tuning tends to give better results, especially if the new task is significantly different from the original one.</p><h2>How to Approach Fine-Tuning</h2><p>A typical workflow looks like this:</p><ol><li><p><strong>Start with a pre-trained model</strong> trained on a large dataset.</p></li><li><p><strong>Replace the final output layer</strong> to match the number of classes in your new task.</p></li><li><p><strong>Freeze the pre-trained layers</strong> and train only the new output layer.</p></li><li><p><strong>Optionally unfreeze selected layers</strong> and fine-tune the model on the new data, typically using a smaller learning rate.</p></li></ol><p>This process allows you to gradually adapt the model while preserving the valuable features it learned during its initial training.</p><h2>Tips for Effective Transfer Learning</h2><ul><li><p>Use <a target="_blank" rel="noopener noreferrer nofollow" class="link" href="https://hulela.co.za/blog/n4BQpYEx2krZ74URQcFe">data augmentation</a> when working with small datasets to avoid overfitting.</p></li><li><p>Always start with training just the new layers before unfreezing the rest of the model.</p></li><li><p>Fine-tune with a lower learning rate to avoid destroying the pre-trained weights.</p></li><li><p>Monitor validation performance closely, especially when unfreezing more layers.</p></li></ul><p>Transfer learning and fine-tuning are essential tools for building deep learning models efficiently. They let you leverage powerful models trained on massive datasets and adapt them to solve your own problems, even when your data is limited.</p><p>For a detailed walk-through of how you can fine-tune a YOLO11 model for object detection, check out this article: <a target="_blank" rel="noopener noreferrer nofollow" class="link" href="https://hulela.co.za/learn/rU5hAJuIJkfAanGTspUT/ikvBmuF2FKWN04v3hnii?type=publishedchapter"><strong>Fine-tuning a YOLO11 Object Detection Model for Kidney Stones Detection</strong></a></p>

Build Better Models Faster Using Knowledge from Existing Networks

Fine-Tuning and Transfer Learning Explained

<h1><strong>An Overview of Image Data Augmentation in Deep Learning</strong></h1><p>Solving the Problem of Limited Data with Image Augmentation</p><img src="https://github.com/Brianhulela/ebook_object_detection/blob/master/chapters/data_augmentation/Augmented_Images_Grid.png?raw=true"><p style="text-align: center">Various Image Augmentation Techniques on a Kangaroo Image from <a target="_blank" rel="noopener noreferrer nofollow" class="link" href="https://www.kaggle.com/datasets/hugozanini1/kangaroodataset">kangaroo-dataset on Kaggle</a></p><p>In machine learning, particularly in computer vision, having a large and diverse dataset is crucial for training accurate models. However, obtaining such datasets can be expensive, time-consuming, or impractical, especially when labeled data is scarce.</p><p>In these cases, data augmentation becomes a valuable tool. By applying transformations to existing images, augmentation artificially increases the size and diversity of the dataset, helping the model generalize better. It introduces variations that are common in real-world scenarios, such as changes in orientation, lighting, and scale.</p><p>Data augmentation is particularly important when working with limited data. It helps prevent overfitting, a common issue where a model memorizes training data instead of learning generalizable patterns. With augmentation, the model is exposed to diverse examples, making it more robust and adaptable to unseen data.</p><h2><strong>What is Image Augmentation?</strong></h2><p>Image augmentation is a technique used to expand a dataset without needing to collect new images. This is done by applying random transformations to existing images, simulating real-world variations. These variations might include:</p><ul><li><p>Changes in orientation (e.g., flipping, rotating)</p></li><li><p>Adjustments in brightness and contrast</p></li><li><p>Scaling and cropping to simulate different object sizes</p></li></ul><p>Below is a summary of some augmentation techniques we applied and how they transform the images:</p><table style="min-width: 50px"><colgroup><col style="min-width: 25px"><col style="min-width: 25px"></colgroup><tbody><tr><th colspan="1" rowspan="1"><p><strong>Augmentation Technique</strong></p></th><th colspan="1" rowspan="1"><p><strong>Transformation Applied</strong></p></th></tr><tr><td colspan="1" rowspan="1"><p><strong>Grayscale (Black &amp; White)</strong></p></td><td colspan="1" rowspan="1"><p>Converts the image to grayscale, simulating a lack of color information.</p></td></tr><tr><td colspan="1" rowspan="1"><p><strong>Horizontal &amp; Vertical Flip</strong></p></td><td colspan="1" rowspan="1"><p>Flips the image horizontally or vertically to simulate different orientations of the same object.</p></td></tr><tr><td colspan="1" rowspan="1"><p><strong>Random Rotation</strong></p></td><td colspan="1" rowspan="1"><p>Rotates the image by a random angle to simulate objects appearing at various angles.</p></td></tr><tr><td colspan="1" rowspan="1"><p><strong>Random Translation</strong></p></td><td colspan="1" rowspan="1"><p>Shifts the image along the x and y axes, simulating slight movements or translations of objects.</p></td></tr><tr><td colspan="1" rowspan="1"><p><strong>Random Shearing</strong></p></td><td colspan="1" rowspan="1"><p>Applies a shear transformation, tilting the image at random angles to simulate distortion or changes in perspective.</p></td></tr><tr><td colspan="1" rowspan="1"><p><strong>Random Brightness Adjustment</strong></p></td><td colspan="1" rowspan="1"><p>Adjusts the brightness of the image, simulating different lighting conditions.</p></td></tr><tr><td colspan="1" rowspan="1"><p><strong>Random Contrast Adjustment</strong></p></td><td colspan="1" rowspan="1"><p>Alters the contrast of the image, creating variations in image clarity or intensity.</p></td></tr><tr><td colspan="1" rowspan="1"><p><strong>RGB Shift</strong></p></td><td colspan="1" rowspan="1"><p>Shifts the color channels (Red, Green, Blue) to simulate color variations and sensor differences.</p></td></tr><tr><td colspan="1" rowspan="1"><p><strong>Channel Shuffle</strong></p></td><td colspan="1" rowspan="1"><p>Shuffles the RGB channels to create new color combinations, enhancing model robustness.</p></td></tr><tr><td colspan="1" rowspan="1"><p><strong>Noise &amp; Gaussian Blur</strong></p></td><td colspan="1" rowspan="1"><p>Adds random noise and applies a blur effect, simulating noisy environments or motion blur.</p></td></tr><tr><td colspan="1" rowspan="1"><p><strong>Cutout (Coarse Dropout)</strong></p></td><td colspan="1" rowspan="1"><p>Randomly masks out portions of the image, mimicking occlusions or parts of objects being missing.</p></td></tr><tr><td colspan="1" rowspan="1"><p><strong>CLAHE (Histogram Equalization)</strong></p></td><td colspan="1" rowspan="1"><p>Improves the image contrast using adaptive histogram equalization to enhance features.</p></td></tr></tbody></table><h2>Disadvantages of Image Augmentation</h2><p>However, over-relying on data augmentation can have its drawbacks. Excessive augmentation may introduce unrealistic variations, leading to models that struggle with real-world data.</p><p>Moreover, if not carefully applied, augmentation can amplify biases in the original dataset, reinforcing and perpetuating existing disparities.</p><ul><li><p><strong>Unrealistic data variations</strong>: Over-augmentation can lead to data that doesn’t reflect real-world conditions, impairing model performance.</p></li><li><p><strong>Amplification of bias</strong>: If the original dataset contains biases, augmentation can exacerbate them, reinforcing skewed predictions.</p></li><li><p><strong>Excessive noise</strong>: Too much noise in the augmented data can confuse the model, hindering its ability to learn key patterns.</p></li><li><p><strong>Increased training time</strong>: Larger augmented datasets result in longer training times and higher computational costs.</p></li></ul><h2>Python Visualization</h2><blockquote><p>Access the code in this guide on this <a target="_blank" rel="noopener noreferrer nofollow" class="link" href="https://github.com/Brianhulela/ebook_object_detection/tree/master/chapters/data_augmentation">GitHub Repository</a>.</p></blockquote><h3>Setting Up the Python Environment</h3><p>Before diving into the code, ensure you have the necessary libraries installed:</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python">%pip install albumentations opencv-python pillow matplotlib Pillow</code></pre></div><p>Next, let's import the required libraries. <code>Albumentations</code> is an open-source library for image augmentation, and we'll use <code>PIL</code> for image handling, <code>NumPy</code> for array manipulation, and <code>Matplotlib</code> for visualization.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python">from PIL import Image
import numpy as np
import matplotlib.pyplot as plt
import albumentations as A
from albumentations import Compose, Rotate, ShiftScaleRotate, Affine, RandomBrightnessContrast, RGBShift, ChannelShuffle

plt.style.use('dark_background')</code></pre></div><h3>Visualizing the Original Image</h3><p>First, we need to load the original image that we'll be augmenting. Let's define a simple function to display the image:</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python">def show(image, title="Augmented Image"):
    plt.imshow(image)
    plt.title(title)
    plt.axis("off")
    plt.show()

# Load image using PIL and convert to RGB
image = np.array(Image.open("sample_image.jpg").convert("RGB"))

# Display original
show(image, "Original Image")</code></pre></div><img src="https://github.com/Brianhulela/ebook_object_detection/blob/master/chapters/data_augmentation/Original%20Image.png?raw=true"><h3>Grayscale (Black &amp; White) Conversion</h3><p>One of the simplest augmentations is converting an image to grayscale, which is especially useful for tasks where color information is not critical. This can help the model focus more on shapes and structures rather than colors.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python"># Define the transformation to convert to grayscale (black &amp; white)
gray_augment = A.Compose([
    A.ToGray(p=1.0)  # Convert the image to grayscale with 100% probability
])

# Apply the grayscale transformation
gray_image = gray_augment(image=image)["image"]

# Show the black and white image
show(gray_image, "Black &amp; White (Grayscale)")</code></pre></div><img src="https://github.com/Brianhulela/ebook_object_detection/blob/master/chapters/data_augmentation/Black%20&amp;%20White%20(Grayscale).png?raw=true"><h3>Horizontal and Vertical Flips</h3><p>Flipping an image horizontally or vertically can simulate different orientations, making it an essential augmentation technique in many scenarios. This is particularly useful for images of objects that may appear in different orientations.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python">transform = A.Compose([
    A.HorizontalFlip(p=1.0),
    A.VerticalFlip(p=1.0)
])

augmented = transform(image=image)["image"]
show(augmented, "Flipped Horizontally and Vertically")</code></pre></div><img src="https://github.com/Brianhulela/ebook_object_detection/blob/master/chapters/data_augmentation/Flipped%20Horizontally%20and%20Vertically.png?raw=true"><h3>Random Rotation</h3><p>Random rotation is a popular augmentation that allows the model to learn to recognize objects regardless of their orientation. You can apply a random rotation within a specific range of angles, like this:</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python"># Apply a random rotation
rotation_augment = Compose([
    Rotate(limit=(-45, 45), p=1.0)  # Rotate by a random angle between -45 to 45 degrees
])

rotated_image = rotation_augment(image=image)["image"]
show(rotated_image, "Random Rotation")</code></pre></div><img src="https://github.com/Brianhulela/ebook_object_detection/blob/master/chapters/data_augmentation/Random%20Rotation.png?raw=true"><h3>Random Translation (Shifting)</h3><p>Translation refers to shifting an image along the x or y axis. This technique helps simulate scenarios where objects might be partially cut off or located at different positions within the image.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python"># Apply random translation (shifting)
shift_augment = Compose([
    ShiftScaleRotate(shift_limit=0.3, scale_limit=0, rotate_limit=0, p=1.0)  # Translation only
])

shifted_image = shift_augment(image=image)["image"]
show(shifted_image, "Random Translation")</code></pre></div><img src="https://github.com/Brianhulela/ebook_object_detection/blob/master/chapters/data_augmentation/Random%20Translation.png?raw=true"><h3>Random Shearing</h3><p>Shearing is a transformation that distorts the image along one axis. This augmentation simulates the effect of viewing an object from an angle or from a perspective that is different from the original view.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python"># Apply random shearing
shear_augment = Compose([
    Affine(shear=10, p=1.0)  # Apply shear with a factor of 10 degrees
])

sheared_image = shear_augment(image=image)["image"]
show(sheared_image, "Random Shearing")</code></pre></div><img src="https://github.com/Brianhulela/ebook_object_detection/blob/master/chapters/data_augmentation/Random%20Shearing.png?raw=true"><h3>Brightness and Contrast Adjustments</h3><p>In real-world conditions, the lighting may vary, and images may appear either too bright or too dark. Random brightness and contrast adjustments help the model learn to handle such variations.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python"># Apply random brightness adjustment
brightness_augment = Compose([
    RandomBrightnessContrast(brightness_limit=0.3, p=1.0)  # Random brightness adjustment
])

brightness_image = brightness_augment(image=image)["image"]
show(brightness_image, "Random Brightness Adjustment")</code></pre></div><img src="https://github.com/Brianhulela/ebook_object_detection/blob/master/chapters/data_augmentation/Random%20Brightness%20Adjustment.png?raw=true"><p>Similarly, for contrast adjustment:</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python"># Apply random contrast adjustment
contrast_augment = Compose([
    RandomBrightnessContrast(contrast_limit=0.3, p=1.0)  # Random contrast adjustment
])

contrast_image = contrast_augment(image=image)["image"]
show(contrast_image, "Random Contrast Adjustment")</code></pre></div><img src="https://github.com/Brianhulela/ebook_object_detection/blob/master/chapters/data_augmentation/Random%20Contrast%20Adjustment.png?raw=true"><h3>RGB Shift</h3><p>Shifting the RGB channels helps the model learn to deal with color variations. By applying random shifts to the Red, Green, and Blue channels, you make the model invariant to slight color shifts.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python"># Apply RGB shift
rgb_shift_augment = Compose([
    RGBShift(r_shift_limit=20, g_shift_limit=20, b_shift_limit=20, p=1.0)  # Shift each channel by a random amount
])

rgb_shifted_image = rgb_shift_augment(image=image)["image"]
show(rgb_shifted_image, "Random RGB Shift")</code></pre></div><img src="https://github.com/Brianhulela/ebook_object_detection/blob/master/chapters/data_augmentation/Random%20RGB%20Shift.png?raw=true"><h3>Channel Shuffle</h3><p>Shuffling the color channels (Red, Green, and Blue) is another augmentation technique that can help the model generalize better. By randomizing the order of the color channels, you simulate the effect of different sensor outputs or variations in color representations.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python"># Apply Channel Shuffle
channel_shuffle_augment = Compose([
    ChannelShuffle(p=1.0)  # Shuffle the RGB channels
])

channel_shuffled_image = channel_shuffle_augment(image=image)["image"]
show(channel_shuffled_image, "Channel Shuffle")</code></pre></div><img src="https://github.com/Brianhulela/ebook_object_detection/blob/master/chapters/data_augmentation/Channel%20Shuffle.png?raw=true"><h3>Noise and Gaussian Blur</h3><p>Adding noise and applying a Gaussian blur are useful for simulating real-world noise and blurring effects that can occur in images. These transformations help the model focus on relevant features while ignoring noise.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python">transform = A.Compose([
    A.GaussNoise(var_limit=(10.0, 50.0), p=1.0),
    A.GaussianBlur(blur_limit=(3, 7), p=1.0)
])

augmented = transform(image=image)["image"]
show(augmented, "Noise &amp; Gaussian Blur")</code></pre></div><img src="https://github.com/Brianhulela/ebook_object_detection/blob/master/chapters/data_augmentation/Noise%20&amp;%20Gaussian%20Blur.png?raw=true"><h3>Cutout (Coarse Dropout)</h3><p>Cutout is a form of data augmentation where rectangular sections of an image are randomly dropped out. This helps the model focus on the remaining parts of the image and improves robustness.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python">transform = A.Compose([
    A.CoarseDropout(max_holes=8, max_height=32, max_width=32,
                    fill_value=0, p=1.0)
])

augmented = transform(image=image)["image"]
show(augmented, "Cutout (Coarse Dropout)")</code></pre></div><img src="https://github.com/Brianhulela/ebook_object_detection/blob/master/chapters/data_augmentation/Cutout%20(Coarse%20Dropout).png?raw=true"><h3>CLAHE (Histogram Equalization)</h3><p>Contrast Limited Adaptive Histogram Equalization (CLAHE) is a technique used to enhance the contrast of an image. It divides the image into small tiles and applies histogram equalization to each tile.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python">transform = A.Compose([
    A.CLAHE(clip_limit=4.0, tile_grid_size=(8, 8), p=1.0)
])

augmented = transform(image=image)["image"]
show(augmented, "CLAHE (Histogram Equalization)")</code></pre></div><img src="https://github.com/Brianhulela/ebook_object_detection/blob/master/chapters/data_augmentation/CLAHE%20(Histogram%20Equalization).png?raw=true"><h2>Conclusion</h2><p>These are just a few of the many image augmentation techniques that can be used to diversify training datasets and improve model generalization. When using these augmentations, remember to apply them thoughtfully to ensure they make sense for your specific task.</p>

Solving the Problem of Limited Data with Image Augmentation

An Overview of Image Data Augmentation in Deep Learning

<h1>Non-Maximum Suppression for Object Detection</h1><p>A Practical Python Guide to Reducing Overlapping Bounding Boxes</p><img src="https://github.com/Brianhulela/ebook_object_detection/blob/master/chapters/non_maximal_suppression/befor_after_nms.drawio.png?raw=true"><p style="text-align: center">Before And After Non Maximum Suppression</p><p>In <a target="_blank" rel="noopener noreferrer nofollow" class="link" href="https://hulela.co.za/learn/rU5hAJuIJkfAanGTspUT/EdidCGkFJIJLkz9JpQhK?type=publishedchapter">object detection</a> tasks, models often return multiple bounding boxes around a single object. These overlapping predictions can lead to ambiguity in the final output.</p><p>Non-Maximum Suppression (NMS) is a critical post-processing step used to filter these predictions, ensuring that only the most relevant bounding boxes are retained.</p><p>In this comprehensive guide, we will examine the problem NMS is designed to solve, explore the algorithm in detail, and walk through a step-by-step implementation using Python.</p><p>By visualizing bounding boxes before and after applying NMS, you will gain a practical understanding of its impact and how it improves the quality of object detection outputs.</p><h2><strong>Why Do We Need Non-Maximum Suppression?</strong></h2><p>Object detection models such as <a target="_blank" rel="noopener noreferrer nofollow" class="link" href="https://docs.ultralytics.com/tasks/detect/">YOLO</a>, <a target="_blank" rel="noopener noreferrer nofollow" class="link" href="https://developers.arcgis.com/python/latest/guide/how-ssd-works/">SSD</a>, and <a target="_blank" rel="noopener noreferrer nofollow" class="link" href="https://arxiv.org/abs/1506.01497">Faster R-CNN</a> work by predicting multiple bounding boxes with associated confidence scores. When a model detects an object, it often produces several overlapping boxes, each with a slightly different position and score.</p><p>This redundancy is expected, it provides robustness, but we need a way to eliminate unnecessary predictions.</p><p>NMS ensures that only the highest-quality predictions remain, removing overlapping boxes that likely refer to the same object. This is essential for clarity, performance, and downstream applications such as object tracking, classification, or visualization.</p><h2><strong>The Problem: Multiple Overlapping Predictions</strong></h2><p>To better understand the issue, consider a detector that identifies a single object but produces multiple bounding boxes for it:</p><ul><li><p>Each box has a confidence score indicating the model’s certainty.</p></li><li><p>The boxes often overlap significantly, especially when the object is well-centered in the image.</p></li><li><p>Without post-processing, all of these predictions may be kept, cluttering the result.</p></li></ul><p>This is where Non-Maximum Suppression becomes essential.</p><h2><strong>What is Non-Maximum Suppression (NMS)?</strong></h2><p>Non-Maximum Suppression is a filtering algorithm that reduces redundant bounding boxes in object detection. Its purpose is to retain only the most confident detections while suppressing others that have a significant overlap with them.</p><p><strong>The NMS Algorithm (Step-by-Step):</strong></p><ol><li><p>Sort all predicted bounding boxes by their confidence scores in descending order.</p></li><li><p>Select the bounding box with the highest confidence score.</p></li><li><p>Compute the Intersection over Union (IoU) between this box and all other boxes.</p></li><li><p>Remove boxes that have an IoU greater than a predefined threshold (e.g., 0.5).</p></li><li><p>Repeat the process with the remaining boxes.</p></li></ol><p>By following this approach, the algorithm prioritizes the most accurate detections while suppressing redundant or overlapping ones.</p><h2><strong>Implementing NMS from Scratch in Python</strong></h2><p>Now that we’ve covered the theory behind Non-Maximum Suppression, let’s move into implementation. In this section, we will write Python code to implement NMS, visualize bounding boxes before and after applying it, and develop an intuitive understanding of how it works.</p><h3>1. Import Required Libraries</h3><p>We will start by importing the necessary libraries for image processing and visualization. We will also apply a dark theme to the plots to enhance visual clarity.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python">import cv2
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as patches
plt.style.use('dark_background')</code></pre></div><h3>2. Load and Display the Sample Image</h3><p>Next, we will load an image and display it using Matplotlib. This image will serve as our base, where we will draw multiple overlapping bounding boxes.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python">image = cv2.imread('sample_image.jpg')
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
height, width, _ = image.shape

plt.figure(figsize=(10, 8))
plt.imshow(image)
plt.title('Sample Image', color='white')  # white title for dark background
plt.axis('off')
plt.show()</code></pre></div><img src="https://github.com/Brianhulela/ebook_object_detection/blob/master/chapters/non_maximal_suppression/sample_image.jpg?raw=true"><p style="text-align: center">Image of an Apple from <a target="_blank" rel="noopener noreferrer nofollow" class="link" href="https://www.kaggle.com/datasets/mbkinaci/fruit-images-for-object-detection">Fruit Images for Object Detection</a></p><h3>3. Define Sample Bounding Boxes (with Confidence Scores)</h3><p>We now define multiple bounding boxes around the object in the image. These boxes are represented by five values: <code>[x_min, y_min, x_max, y_max, confidence_score]</code>. These bounding boxes simulate predictions from an object detection model.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python">boxes = np.array([
    [227, 62, 723, 500, 0.95],  # Ground truth/highest score
    [220, 60, 715, 495, 0.9],
    [230, 65, 725, 510, 0.85],
    [240, 70, 730, 515, 0.75],
    [300, 100, 600, 480, 0.6],  # Smaller box
    [100, 50, 600, 400, 0.5]    # Slightly shifted box
])</code></pre></div><h3>4. Visualize Bounding Boxes Before Applying NMS</h3><p>We will use the following function to draw all the predicted boxes on the image. This allows us to observe how much the boxes overlap before applying any filtering.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python">def draw_boxes_on_image(img, boxes, title=''):
    img_copy = img.copy()
    fig, ax = plt.subplots(1, figsize=(10, 8))
    ax.imshow(img_copy)
    ax.set_title(title)
    
    for box in boxes:
        x1, y1, x2, y2, score = box
        rect = patches.Rectangle(
            (x1, y1), x2 - x1, y2 - y1,
            linewidth=2, edgecolor=(0, 0, 1), facecolor='none'
        )
        ax.add_patch(rect)
        ax.text(x1, y1 - 10, f'{score:.2f}', color='white',
                bbox=dict(facecolor='blue', edgecolor='none', pad=1))
    
    ax.axis('off')
    plt.savefig(f'{title}.png', bbox_inches='tight')
    plt.show()</code></pre></div><p>Now, we visualize the bounding boxes before applying Non-Maximum Suppression:</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python">draw_boxes_on_image(image, boxes, title='Predicted Boxes (Before NMS)')</code></pre></div><img src="https://github.com/Brianhulela/ebook_object_detection/blob/master/chapters/non_maximal_suppression/Predicted%20Boxes%20(Before%20NMS).png?raw=true"><p style="text-align: center">Predicted Bounding Boxes Before NMS</p><h3>5. Define IoU (Intersection over Union)</h3><p>The Intersection over Union (IoU) metric is fundamental in NMS. It measures the overlap between two bounding boxes. If the overlap exceeds a certain threshold, one of the boxes will be suppressed.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python">def iou(box1, box2):
    x1 = max(box1[0], box2[0])
    y1 = max(box1[1], box2[1])
    x2 = min(box1[2], box2[2])
    y2 = min(box1[3], box2[3])

    inter_area = max(0, x2 - x1) * max(0, y2 - y1)
    box1_area = (box1[2] - box1[0]) * (box1[3] - box1[1])
    box2_area = (box2[2] - box2[0]) * (box2[3] - box2[1])

    union_area = box1_area + box2_area - inter_area
    return inter_area / union_area if union_area &gt; 0 else 0</code></pre></div><h3>6. Implementing the NMS Algorithm</h3><p>Now, we will implement the Non-Maximum Suppression algorithm. This function takes the list of boxes and applies the suppression based on the IoU threshold.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python">def non_max_suppression(boxes, iou_threshold=0.3):
    if len(boxes) == 0:
        return []

    boxes = boxes[boxes[:, 4].argsort()[::-1]]  # Sort boxes by confidence
    selected_boxes = []

    while len(boxes) &gt; 0:
        chosen_box = boxes[0]
        selected_boxes.append(chosen_box)

        remaining_boxes = []
        for box in boxes[1:]:
            if iou(chosen_box, box) &lt; iou_threshold:
                remaining_boxes.append(box)
        boxes = np.array(remaining_boxes)

    return np.array(selected_boxes)</code></pre></div><p>This algorithm works by sorting the boxes based on their confidence score. The highest-scoring box is selected, and any boxes that have a high overlap (IoU) with it are removed. This process repeats until no boxes remain.</p><h3>7. Apply NMS and Visualize the Final Result</h3><p>Finally, we apply the NMS function and visualize the bounding boxes that remain after suppression.</p><div class="code-block-wrapper"><div class="code-language">Python</div><pre data-language="python"><code class="language-python">nms_boxes = non_max_suppression(boxes, iou_threshold=0.3)
draw_boxes_on_image(image, nms_boxes, title='Boxes After NMS')</code></pre></div><p>The resulting image will show only the most relevant bounding boxes, filtering out any redundant boxes that have high overlap with others. This is exactly how modern object detectors ensure that the predictions are clean and non-redundant.</p><img src="https://github.com/Brianhulela/ebook_object_detection/blob/master/chapters/non_maximal_suppression/Predicted%20Boxes%20(After%20NMS).png?raw=true"><p style="text-align: center">Predicted Bounding Boxes After NMS</p><h2><strong>Understanding the Outcome</strong></h2><p>After applying NMS, we observe that:</p><ul><li><p>Only the bounding box with the highest confidence score remains for each cluster of overlapping boxes.</p></li><li><p>The result is a cleaner and more reliable set of detections.</p></li></ul><p>This filtering process is essential in real-world scenarios where object detectors may return hundreds of overlapping predictions.</p><blockquote><p>Learn more about <a target="_blank" rel="noopener noreferrer nofollow" class="link" href="https://hulela.co.za/learn/rU5hAJuIJkfAanGTspUT/ikvBmuF2FKWN04v3hnii?type=publishedchapter">Object Detection with YOLO.</a></p></blockquote><h2><strong>Conclusion</strong></h2><p>Non-Maximum Suppression is a fundamental concept in object detection. Although the idea is simple, its role is crucial for reducing noise in predictions and improving model accuracy.</p><p>By implementing it manually and visualizing the outcome, we gain a deeper appreciation of how object detectors work under the hood.</p><p>Understanding NMS equips you with the tools to customize detection outputs, debug model predictions, and experiment with alternative post-processing techniques.</p><blockquote><p>All the code for this guide can be accessed on this <a target="_blank" rel="noopener noreferrer nofollow" class="link" href="https://github.com/Brianhulela/ebook_object_detection/tree/master/chapters/non_maximal_suppression">GitHub Repository</a>.</p></blockquote>

Read More