LightningChart PythonSONAR Object Detection Python Application

TutorialPython project of a SONAR object detection application for identifying obstacles in navigation.

Written by a human | Updated on April 24th, 2025

SONAR Object Detection

Sonar (Sound Navigation and Ranging) is a technique used to detect objects underwater by transmitting sound pulses and analyzing the reflected echoes. This technology is crucial for submarines, which rely on sonar to navigate, detect obstacles, and recognize potential threats like underwater mines. The primary challenge is distinguishing between natural objects like rocks and man-made objects like mines, which is where machine learning (ML) comes into play.

What is Sonar and How Does It Work?

Sonar systems emit sound pulses and listen for echoes that bounce back from objects. The time delay between sending the pulse and receiving the echo allows the sonar to calculate the distance to the object, while the strength and characteristics of the echo can help determine the object’s nature. This is essential in underwater navigation, where visibility is limited.

How is Sonar Used in Navigation?

Sonar plays a critical role in submarine navigation, obstacle recognition, mapping the seabed, and identifying threats. The system uses sound waves to detect and locate objects, leveraging principles like the Doppler effect to ascertain the relative speed and movement of objects.

Signal Processing in Sonar Systems

Signal processing involves filtering and analyzing sonar signals to enhance object detection. Techniques such as time-frequency analysis help in distinguishing between different types of echoes, which can then be classified using machine learning models.

Pattern Recognition and Machine Learning

ML models, particularly neural networks, have significantly improved the accuracy of sonar systems in recognizing and classifying underwater objects. These models analyze patterns in the sonar data to differentiate between rocks and mines with high precision.

LightningChart Python

LightningChart is a high-performance data visualization library in Python. It is capable of rendering complex charts and visualizations with minimal latency, making it ideal for real-time sonar data visualization.

Features and Chart Types to be used in the Project

For this project, we utilize several features of LightningChart:

Heatmap Grid Series: For visualizing 2D slices of seismic data.
ChartXY: For creating 2D charts.
SpiderChart: For visualizing data in a radial form as dissected by named axes.
Bar Charts: To determine the most significant factors affecting machine failures.

Performance Characteristics

LightningChart is known for its performance, capable of rendering millions of data points and handling large datasets. This makes it ideal for sonar data, which often involves complex and extensive datasets.

Setting Up Python Environment

To get started, ensure you have Python installed. Here you can see how to install the following libraries:

NumPy: Used for numerical operations and handling arrays.
Pandas: Provides data structures and data analysis tools.
LightningChart: For creating high-performance data visualizations.
XGBoost, LightGBM, CatBoost: For advanced machine learning algorithms.
Scikit-learn: For implementing machine learning models.

Install these libraries using pip:

pip install lightningchart==0.7.2.1
pip install numpy pandas sklearn xgboost lightgbm catboost

Set up your development environment

Set up your development environment by creating a virtual environment and installing the necessary libraries. This ensures that your project dependencies are isolated and manageable.

python3 -m venv venv
source venv/bin/activate  # On Windows use `venv\Scripts\activate`
pip install -r requirements.txt

Using Visual Studio Code (VSCode) for development

Visual Studio Code (VSCode) is a popular code editor that offers a rich set of features to enhance your development workflow.

Loading and Processing Data

The sonar data, typically stored in CSV format, needs to be loaded into a Pandas DataFrame. The data preprocessing involves scaling numerical features and preparing them for model training.

import pandas as pd

file_path = 'sonar.csv'
data = pd.read_csv(file_path, header=None)

Handling and Preprocessing the Data

Handling and preprocessing the data involves:

Loading the sonar dataset.
Scaling the numerical features using StandardScaler.
Converting categorical labels into binary values for machine learning model compatibility.
Splitting the data into training and testing sets.

import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

# Load the sonar dataset
file_path = 'sonar.csv'
data = pd.read_csv(file_path, header=None)

# Prepare the features and target
X = data.drop(columns=[60])
y = data[60].apply(lambda x: 1 if x == 'M' else 0)  # Convert target to binary values

# Preprocess the data (scale numerical features)
selected_features = X.columns.tolist()
preprocessor = ColumnTransformer(
    transformers=[
        ('num', StandardScaler(), selected_features)
    ])

# Split the dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

Visualizing Data with LightningChart Python

LightningChart provides an efficient way to visualize large datasets in real-time, which is crucial for applications like sonar object recognition.

Correlation Heatmap of Sonar Features

This heatmap visualizes the correlation between different features in the sonar dataset. Positive correlations are highlighted in red, while negative correlations are shown in blue. This helps in identifying which features are closely related, which could be useful for feature selection and reducing dimensionality in machine learning models.

import pandas as pd
import lightningchart as lc

data = pd.read_csv('sonar.csv', header=None)
corr_matrix = data.drop(columns=[60]).corr()

chart = lc.ChartXY(title='Correlation Heatmap of Sonar Features')
series = chart.add_heatmap_grid_series(
    columns=len(corr_matrix),
    rows=len(corr_matrix)
)
series.hide_wireframe()
series.invalidate_intensity_values(corr_matrix.values.tolist())
series.set_palette_colors([
    {"value": -1.0, "color": lc.Color(0, 0, 255)},
    {"value": 0.0, "color": lc.Color(255, 255, 255)},
    {"value": 1.0, "color": lc.Color(255, 0, 0)}
])
chart.open()

Sonar-object-detection-heatmap-sonar-features

Density and Scatter Plots of Sonar Features

The density and scatter plots illustrate the distribution and relationships between pairs of sonar features, specifically for identifying mines (orange) versus rocks (blue). These visualizations are crucial for understanding how well features separate the two classes and for assessing the data’s variability.

import numpy as np
import pandas as pd
import lightningchart as lc

data = pd.read_csv('sonar.csv', header=None)
X = data.drop(columns=[60])
y = data[60]

dashboard = lc.Dashboard(rows=4, columns=4)

for i, col in enumerate(X.columns[:4]):
    chart = dashboard.ChartXY(row_index=i, column_index=i)
    series_r = chart.add_area_series()
    series_m = chart.add_area_series()

    series_r.add(np.linspace(min(X[col]), max(X[col]), 100), np.random.rand(100))
    series_m.add(np.linspace(min(X[col]), max(X[col]), 100), np.random.rand(100))

    chart.set_title(f'Density of Feature {col}')
    
dashboard.open()

Spider Chart for Mean Feature Values

The spider chart compares the mean feature values for rocks and mines across all features. The overlapping areas indicate features that may not contribute much to distinguishing between the two classes, while areas with clear separation may indicate useful features for classification.

import pandas as pd
import lightningchart as lc

data = pd.read_csv('sonar.csv', header=None)
X = data.drop(columns=[60])
y = data[60]

mean_rocks = X[y == 'R'].mean()
mean_mines = X[y == 'M'].mean()

chart = lc.SpiderChart(title='Mean Feature Values for Rocks and Mines')

for i in range(60):
    chart.add_axis(str(i))

series_rocks = chart.add_series().set_name('Rocks')
series_mines = chart.add_series().set_name('Mines')

series_rocks.add_points([{'axis': str(i), 'value': mean_rocks[i]} for i in range(60)])
series_mines.add_points([{'axis': str(i), 'value': mean_mines[i]} for i in range(60)])

chart.open()

ROC Curves for Different Models

ROC (Receiver Operating Characteristic) curves for different models visualize the trade-off between true positive rates and false positive rates across various thresholds. Higher AUC (Area Under the Curve) values indicate better performance. These charts help compare the effectiveness of models in distinguishing between rocks and mines.

import pandas as pd
import lightningchart as lc
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_curve, auc

data = pd.read_csv('sonar.csv', header=None)
X = data.drop(columns=[60])
y = data[60].apply(lambda x: 1 if x == 'M' else 0)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

model = LogisticRegression()
model.fit(X_train, y_train)
y_scores = model.predict_proba(X_test)[:, 1]

fpr, tpr, _ = roc_curve(y_test, y_scores)
roc_auc = auc(fpr, tpr)

chart = lc.ChartXY(title='Logistic Regression ROC Curve')
series = chart.add_line_series().add(fpr.tolist(), tpr.tolist()).set_name('ROC Curve')
chart.open()

Feature Importance Bar Charts

These bar charts rank the importance of features based on how much they contribute to the model’s predictions. Understanding feature importance helps in refining models by focusing on the most informative features, which can lead to better performance and reduced overfitting.

import pandas as pd
import lightningchart as lc
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

data = pd.read_csv('sonar.csv', header=None)
X = data.drop(columns=[60])
y = data[60].apply(lambda x: 1 if x == 'M' else 0)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

model = RandomForestClassifier()
model.fit(X_train, y_train)
importances = model.feature_importances_

chart = lc.BarChart(title='Random Forest Feature Importances')
chart.set_data([{'category': str(i), 'value': imp} for i, imp in enumerate(importances)])
chart.open()

Model Accuracy Over Iterations

These charts track the accuracy of different models on training and testing sets over multiple iterations. This visualization helps in assessing the model’s learning progress and identifying potential overfitting if the training accuracy significantly outpaces the testing accuracy.

import pandas as pd
import lightningchart as lc
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

data = pd.read_csv('sonar.csv', header=None)
X = data.drop(columns=[60])
y = data[60].apply(lambda x: 1 if x == 'M' else 0)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = LogisticRegression(max_iter=250)
model.fit(X_train, y_train)

train_accuracy = model.score(X_train, y_train)
test_accuracy = model.score(X_test, y_test)

chart = lc.ChartXY(title='Logistic Regression Accuracy')
chart.add_line_series().add([1, 2, 3, 4, 5], [train_accuracy] * 5).set_name('Training Accuracy')
chart.add_line_series().add([1, 2, 3, 4, 5], [test_accuracy] * 5).set_name('Testing Accuracy')
chart.open()

Precision-Recall Curves

Precision-recall curves are particularly useful when dealing with imbalanced datasets. They show the trade-off between precision and recall for different threshold values. High AUC values in these curves indicate that the model maintains a good balance between precision and recall, which is crucial for tasks like mine detection.

import pandas as pd
import lightningchart as lc
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import precision_recall_curve, auc

data = pd.read_csv('sonar.csv', header=None)
X = data.drop(columns=[60])
y = data[60].apply(lambda x: 1 if x == 'M' else 0)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

model = LogisticRegression()
model.fit(X_train, y_train)
y_scores = model.predict_proba(X_test)[:, 1]

precision, recall, _ = precision_recall_curve(y_test, y_scores)
pr_auc = auc(recall, precision)

chart = lc.ChartXY(title='Logistic Regression Precision-Recall Curve')
chart.add_line_series().add(recall.tolist(), precision.tolist()).set_name('Precision-Recall Curve')
chart.open()

Real-Time Sonar Data Predictions

The line chart shows the real-time sonar raw data values over time, which are sent into the machine learning model for classification. The bar chart shows the cumulative number of predictions made by the model for “Rock” and “Mine.”

import numpy as np
import lightningchart as lc
import time

def generate_sonar_data():
    return np.round(np.sin(np.linspace(0, 2 * np.pi, 60)) + np.random.normal(0, 0.2, 60), 3)

dashboard = lc.Dashboard(rows=2, columns=1)

chart = dashboard.ChartXY(title='Real-Time Sonar Data Predictions')
series = chart.add_line_series(data_pattern='ProgressiveX')
chart.get_default_x_axis().set_scroll_strategy(strategy='progressive')

bar_chart = dashboard.BarChart(title='Cumulative Predictions')
bar_chart.set_data([{'category': 'Rock', 'value': 0}, {'category': 'Mine', 'value': 0}])

dashboard.open(live

LightningChart Python Benefits

High Performance and Scalability

LightningChart is designed to handle large datasets and complex visualizations efficiently, ensuring that even real-time data can be processed and displayed without lag. This is particularly important for sonar applications where timely decisions are critical.

Wide Range of Visualization Options

From heatmaps and spider charts to precision-recall curves and real-time line charts, LightningChart provides an extensive set of chart types. This versatility allows users to explore data from multiple perspectives, facilitating better understanding and decision-making.

Customizability

LightningChart offers extensive customization options, enabling users to tailor visualizations to their specific needs. This includes the ability to adjust color schemes, axis intervals, and chart titles, which helps in creating clear and insightful representations of the data.

Interactivity and Live Data Support

The ability to create live interactive dashboards is a standout feature of LightningChart. This is particularly beneficial for monitoring real-time sonar data, where ongoing analysis and updates are crucial.

Ease of Integration with Machine Learning Workflows

LightningChart can be seamlessly integrated with Python’s machine learning libraries, such as scikit-learn. This allows for a smooth workflow where data preprocessing, model training, and visualization are all connected, leading to more efficient and effective analysis.

Professional Quality Visuals

LightningChart’s high-quality rendering ensures that the visualizations are not only informative but also aesthetically pleasing. This is valuable when presenting findings to stakeholders or when documentation requires clear and professional-looking charts.

Conclusion

In this SONAR object detection project, we have demonstrated the process of predicting submarine sonar object recognition using Python. By leveraging machine learning models and the powerful data visualization capabilities of LightningChart, we were able to gain deep insights into the sonar dataset. Through various visualizations like correlation heatmaps, ROC curves, feature importance charts, and real-time data predictions, we explored the relationships between different features, assessed model performance, and ultimately improved the accuracy of object classification between rocks and mines.

Get started with LightningChart Python

Soroush Sohrabian

Software Developer

Continue learning with LightningChart

Best Apache ECharts Alternative in 2026: When Canvas Hits Its Ceiling

Apache ECharts is an excellent charting library that's the honest starting point, and it's worth saying clearly. Free under the Apache 2.0 license, actively maintained by one of the most active open-source communities in data visualization, with 60,000+ GitHub stars...

Best D3.js Alternatives in 2026: Less Code, More Performance, Same Power

D3.js is the most starred data visualization library in existence 109,000+ GitHub stars and for justifiable reasons. It provides the building blocks to construct any visualization imaginable: data binding, SVG path generation, scale functions, geographic projections,...

Best ApexCharts Alternatives in 2026: Scale Beyond SVG, Add Real 3D

ApexCharts earned its position through a set of genuine strengths executed consistently well: MIT license, the best default visual aesthetics among free JavaScript chart libraries, official and actively maintained React, Vue, and Angular component wrappers, clean...