NeuroPsych Trading Assistant: A Neuromorphic Multi-Agent System with Brain-Computer Interface for Computational Psychiatry in Financial Markets
Description:
The NeuroPsych Trading Assistant represents a groundbreaking convergence of neuromorphic computing, computational psychiatry, robotics, and electronic systems design to address the critical mental health crisis among retail traders. This project develops a comprehensive ecosystem that monitors, predicts, and intervenes in real-time to prevent emotion-driven trading losses and mental health deterioration.
My system employs cutting-edge neuromorphic hardware design, EEG-based brain-computer interfaces, computer vision, multi-agent AI coordination, and robotic companions to create the world's first comprehensive mental health support system for high-stress financial decision-making.
Learn More (Coming Soon)
View (Coming Soon)
Internship Semester (UG Final Semester) Project
Problem Statement:
Aerial vehicles struggle with real-time, low-latency object detection due to small object sizes, computational constraints, and dynamic environments. This project addresses the gap by deploying an edge-optimized YOLOv7 model to enable accurate, real-time detection on drones without cloud dependency.
Summary:
Developed a real-time aerial object detection system using YOLOv7, trained on a custom dataset with NVIDIA Jetson AGX Xavier. Deployed on the "Tunga" aerial vehicle (NVIDIA Jetson Nano + Pixhawk) to enable edge-computing for dynamic environments. Achieved 89% mAP, 22 FPS inference speed, and 95% real-world detection accuracy, optimizing resource usage by 40% compared to baseline models. Demonstrated scalability for aerial surveillance and disaster response applications.
Learn More
Time-Frequency Analysis of Neural Signals Using Complex Morlet Wavelets
Problem Statement:
EEG signal analysis faces challenges in balancing temporal and spectral resolution while mitigating edge artifacts. This project addressed these limitations by implementing complex Morlet wavelets to enable high-precision time-frequency decomposition and comparing it with traditional filter-Hilbert methods for robust neural oscillation characterization.
Summary:
This project leveraged complex Morlet wavelet convolution to analyze EEG data, extracting time-frequency power and phase dynamics from single and multi-trial neural signals. Key tasks included comparing wavelet convolution with filter-Hilbert methods (achieving 25% higher spectral precision), quantifying edge artifacts in transient signals, and visualizing multi-channel spectral activity. Results revealed robust inter-trial phase coherence (ITPC > 0.4) in high-frequency bands and identified boundary artifacts in non-stationary data. The study demonstrated wavelet convolution’s superiority in resolving frequency-specific neural oscillations, offering insights for improved EEG signal processing in cognitive and clinical neuroscience applications.
Learn More
View
Phase Synchronization Analysis using EEG Data
This project involves the analysis of phase synchronization between EEG signals from different channels. Using Matlab, we compute and visualize the phase synchronization using techniques like Morlet wavelet transform, ISPC, and PLI. The project includes loading EEG data, setting up connectivity parameters, computing analytic signals, and visualizing phase angles in various plots. Additionally, we compare voltage and Laplacian data to evaluate the impact of these different preprocessing methods on phase synchronization metrics.
Learn More
View
Neural Signal Spectral Analysis
This project involves generating sine waves and analyzing their spectral properties using FFT. It includes adding noise to the signals and examining its impact on frequency reconstruction. The power spectrum of real neural data is computed and compared using different averaging methods. Additionally, a manual implementation of the Fourier Transform is created to validate the FFT results. The project also explores zero-padding to improve frequency resolution and applies frequency-domain filtering to remove 50 Hz line noise.
Learn More
View
Simulating EEG Data in MATLAB
This project involves simulating EEG data at the dipole level using MATLAB. The simulation includes generating pure sine wave signals, adding noise, and creating non-oscillatory and non-stationary signals in dipoles. The EEG data is then projected onto scalp electrodes to visualize and analyze the resulting signals. The project aims to understand the relationship between dipole-level signals and scalp-level EEG responses.
Learn More
View
Comparative Analysis of Pathfinding Algorithms (A* ,BFS & DFS)
Problem Statement:
Existing pathfinding algorithms vary in efficiency and optimality for maze navigation. This project compares DFS, BFS, and A* to determine their effectiveness in minimizing path length, search time, and heuristic impact on performance.
Summary:
This project implements and evaluates DFS, BFS, and A* algorithms in maze navigation using PyAmaze to visualize pathfinding and measure efficiency. Results show BFS guarantees the shortest path, while A* (with Manhattan heuristic) reduces search time by 25–40% compared to DFS. The Manhattan heuristic outperformed Euclidean in 70% of test cases, achieving shorter search paths. Metrics include path length (BFS/A: 100% optimal vs. DFS: 60% longer paths) and search efficiency (A explored 35% fewer nodes than BFS). The study highlights trade-offs between completeness, speed, and heuristic choice for real-world navigation systems.
Learn More
View
Autonomous Lane Changing Control System (Lateral Dynamics Simulation)
Problem Statement:
Traditional autonomous lane-changing systems struggle to balance dynamic constraints and real-time adaptability. This project addresses the challenge of designing a computationally efficient control framework using MPC to ensure safe, smooth lateral maneuvers while tracking time-varying trajectories under hardware limitations.
Summary:
This MATLAB project designs a Model Predictive Control (MPC) system for autonomous vehicles to execute precise lane-changing maneuvers. The MPC algorithm dynamically optimizes steering inputs over a receding horizon to track a reference trajectory, balancing computational efficiency and control accuracy. The simulation framework includes trajectory generation, state-space modeling, and iterative quadratic optimization (quadprog) to resolve constraints. Results demonstrate >95% trajectory tracking accuracy, steering angles within ±0.35 rad limits, and stable lateral deviation (less than 0.15m) under varying conditions. Visualization of states (yaw rate, position) and inputs validates the controller’s robustness for real-time applications, with adaptive horizon tuning reducing solve times by 20%. The project highlights MPC’s capability to handle nonlinear vehicle dynamics while ensuring safety-critical performance.
Learn More
View
Simulating Water Tank Dynamics
This project simulates the dynamics of water volume changes in three interconnected tanks with different reference volumes and control parameters. The simulation employs proportional control to adjust the volume of each tank. The volume changes over time are visualized using animated plots to provide a clear understanding of how each tank's volume evolves and responds to different control inputs.
Learn More
View
PID Control Simulation for Falling Cube
This project involves simulating a PID-controlled train on an inclined rail trying to catch a falling cube. The simulation calculates the train's displacement, velocity, acceleration, and PID controller's error metrics (horizontal error, rate of change of error, and integral of error) over time. An animation is generated to visualize the train and cube movements, and performance metrics are plotted to assess the PID controller's effectiveness.
Learn More
View
COVID-19 Spread Simulation and Visualization
This project simulates the spread of COVID-19 using Python libraries such as Matplotlib and NumPy. The simulation models the infection rate (R0), recovery time, and fatality rate to visualize the progression of the pandemic. The simulation displays the spread of the virus over time, with infected, recovered, and deceased individuals represented on a polar plot. The animation dynamically updates the status of the population, providing a clear depiction of how the virus spreads and the outcomes over time.
Learn More
View
Speed Estimation and Vehicle Tracking System
Problem Statement:
Traditional traffic monitoring systems lack accuracy in real-time speed estimation and struggle with occlusions in dense traffic. This project addresses these gaps by automating vehicle detection, tracking, and speed calculation using YOLOv8 and computer vision to enable efficient, scalable traffic analysis.
Summary:
This project leverages YOLOv8's state-of-the-art object detection to identify and track vehicles in real-time video streams. A custom tracking algorithm assigns persistent IDs to vehicles, enabling precise speed calculation as they cross two predefined lines. The system achieved 85%+ detection accuracy, tracked 100+ vehicles simultaneously, and computed speeds with less than 10% error relative to ground truth. Results were visualized using OpenCV, displaying bounding boxes, dynamic speed labels (in km/h), and traffic metrics (e.g., 45 vehicles moving downward vs. 32 upward). Designed for scalable traffic analysis, this solution demonstrates robust performance in real-world scenarios, offering insights for urban planning and congestion management.
Learn More
View
Real-Time Depth Estimation with MiDaS
Problem Statement:
Traditional depth sensing relies on specialized hardware (e.g., LiDAR, stereo cameras), which is costly and computationally intensive. This project addresses this gap by implementing a real-time, GPU-accelerated monocular depth estimation system using lightweight MiDaS models to democratize 3D perception from standard 2D webcams.
Summary:
This project implements a real-time monocular depth estimation system using PyTorch and MiDaS models (DPT_Large, DPT_Hybrid, MiDaS_small) to infer 3D structure from 2D webcam input. Leveraging GPU acceleration (NVIDIA RTX 3060), it processes 20–30 FPS with optimized latency, balancing accuracy and speed: DPT_Large achieved ±5% relative depth error but slower inference (~15 FPS), while MiDaS_small prioritized speed (~30 FPS) for real-time applications. The pipeline integrates OpenCV for live video capture, PyTorch for model inference, and color-mapped depth visualization, demonstrating a hardware-efficient alternative to traditional depth sensors like LiDAR.
Learn More
View
Lip Read To Text
Problem Statement:
Existing visual speech recognition systems struggle to accurately transcribe spoken words from lip movements due to variable lighting, speaker differences, and lack of temporal alignment. This project addresses these challenges by developing a deep learning model (3D CNN + Bidirectional LSTM) to automate silent speech interpretation with robust spatiotemporal feature extraction and CTC-based alignment-free training.
Summary:
This project develops a LipNet-based lip reading model using TensorFlow/Keras, integrating 3D CNNs and Bidirectional LSTMs to analyze spatiotemporal lip movements. The system achieves 18% word error rate (WER) on test data, trained with CTC loss for alignment-free text prediction. Preprocessing includes frame normalization and lip ROI extraction, while evaluation shows 83% accuracy on short phrases. Future enhancements target larger datasets and transformer-based architectures for improved robustness.
Learn More
View
2D Image To 3D Point Cloud
This project involves using a depth estimation model from the Hugging Face Transformers library to predict depth from a 2D image. The depth map is then used to create a point cloud, which is processed and refined to reconstruct a 3D mesh. The project employs Open3D for point cloud and 3D mesh processing and visualization.
Learn More
View
Point Net Classification
This project involves creating a 3D shape classification system using TensorFlow and the PointNet architecture. The ModelNet10 dataset is used, consisting of 3D object files in the .off format. The project includes data preprocessing, model building, training, evaluation, and visualization of the classification results.
Learn More
View
Real Time Hand Gesture Recognition For Cursor Control
Problem Statement:
Traditional input devices limit mobility and accessibility. This project addresses this by designing a vision-based system to control cursor movements and clicks through hand gestures, eliminating physical hardware dependency.
Summary:
Developed a real-time hand gesture recognition system using MediaPipe and PyAutoGUI to enable touchless cursor control. The solution processes webcam input to detect 21 hand landmarks, achieving 95% gesture accuracy, maps finger movements to screen coordinates with less than 50ms latency, and triggers mouse clicks via pinch detection (index-thumb distance <20px). Tested at 30 FPS, it offers intuitive, low-latency hands-free navigation for enhanced accessibility.
Learn More
View
Real Time Pushup Counter (Front And Side View)
The project involves two main scripts, one for counting push-ups from a front view and another for evaluating form from a side view. Both scripts use Mediapipe and OpenCV libraries to process video feeds from a webcam. The front view script calculates angles between key joints to count push-ups, while the side view script assesses form and provides feedback.
Learn More
View
Real Time Bicep Curl Counter
The project involves using the Mediapipe library for pose estimation to analyze video feed from a webcam. By extracting key landmarks from the user's arm, the system calculates the angle at the elbow to detect the curl movement. The code then counts the number of curls and displays this information along with the stage of the exercise on the video feed.
Learn More
View
Real Time Hand Gesture Recognition For Volume Control
This project utilizes a webcam to capture real-time hand movements and processes the video feed to detect hand landmarks. By measuring the distance between the tip of the thumb and the index finger, the system determines whether to increase or decrease the system volume. The hand gestures are tracked using Mediapipe, and the volume control is managed through PyAutoGUI.
Learn More
View
Real Time Body Pose Estimation
This project involves building a React application to perform real-time human pose estimation using the PoseNet model from TensorFlow.js. The application captures video from a webcam, processes each frame to detect human poses, and visualizes the detected keypoints and skeleton on a canvas overlay.
Learn More
View
Real Time Body Segmentation Estimation
This project demonstrates real-time body segmentation using TensorFlow's BodyPix model within a React application. The application captures live video from a webcam, applies body part segmentation, and displays the segmented body parts on a canvas overlay. The code sets up the webcam and canvas, loads the BodyPix model, and processes video frames to draw masks of detected body parts.
Learn More
View
Real Time Hand Pose Estimation
This project involves creating a React application that integrates TensorFlow.js to perform real-time hand pose detection using a webcam. The application captures video input from the webcam, processes the frames to detect hand landmarks, and renders these landmarks on a canvas. The handpose model from TensorFlow.js is used for detecting hand landmarks, and cuTm drawing utilities are employed to visualize the detected hand poses with distinct colors and sizes.
Learn More
View
Real Time 3D Face Mapping (436 Data Point)
This project involves creating a React application that utilizes TensorFlow.js to perform real-time face mesh detection. The application captures video from a webcam and overlays a mesh on detected facial features. Two face mesh models from TensorFlow.js are compared: the older @tensorflow-models/facemesh and the newer @tensorflow-models/face-landmarks-detection. The app dynamically updates the face mesh on the canvas as the video feed changes.
Learn More
View
Rock-Paper-Scissors Hand Gesture Classifier with FasterViT
Problem Statement:
Traditional CNN-based gesture classifiers struggle with balancing speed and accuracy for real-time applications. This project addresses this gap by implementing FasterViT, a vision transformer optimized for computational efficiency, to achieve sub-20ms inference times with >98% accuracy in dynamic hand gesture recognition.
Summary:
This project leverages the FasterViT architecture to build a real-time hand gesture classifier for rock-paper-scissors games. The dataset was enhanced using advanced preprocessing (random resizing, cropping, normalization) and augmentation techniques to improve model generalization. The fine-tuned FasterViT model achieved 98.2% validation accuracy in just 5 training epochs, optimized via GPU acceleration and adaptive learning rates. The deployed model demonstrates rapid inference times (less than 15ms/image) on an RTX 3060 GPU, enabling seamless real-time predictions. Practical integration was validated by overlaying predictions on test images, showcasing robust performance across diverse lighting and gesture variations.
Learn More
View
Happy Or Sad Image Classifier
This project involves preprocessing image data, creating a CNN model, training it on the data, and evaluating its performance. The model is designed to classify images into two categories. After training, the model's performance is assessed, and it is saved for future use.
Learn More
View
ESRGAN (Super Resolution)
This project involves running the ESRGAN model to enhance the resolution of images. ESRGAN is a state-of-the-art method in the field of image super-resolution, utilizing a deep learning-based approach to produce high-quality, high-resolution images from low-resolution inputs. The implementation is done using Python and PyTorch, with the model architecture and weights loaded from pre-trained models.
Learn More
View
Edge Detection
The project involves loading an image, resizing it, converting it to grayscale, applying Gaussian blur, and finally using the Canny edge detection algorithm to identify edges. The results are visualized using Matplotlib, showing the original, resized, grayscale, blurred, and edge-detected images.
Learn More
View
Optimized Ludo with Q-Learning
Problem Statement:
Traditional rule-based Ludo AI lacks adaptability to dynamic game states and opponent strategies. This project addresses the need for an autonomous agent that learns optimal moves through trial and error, using Q-learning to balance short-term rewards and long-term winning strategies.
Summary:
This project implements a Q-learning-based AI agent to master the strategic board game Ludo. By defining a state-action space and iteratively updating a Q-table using rewards, the agent learns optimal moves through exploration (epsilon-greedy policy) and exploitation. The AI was trained over 10,000 simulated games using Python and Ludopy, achieving an 85% win rate against rule-based opponents and a 40% reduction in average move decision time. Key innovations include dynamic reward tuning for safe piece advancement and blocking adversaries. The modular design, powered by NumPy for efficient Q-table updates, enabled the agent to adapt to complex board states, demonstrating a 92% success rate in avoiding captures. Results validate reinforcement learning’s potential for dynamic strategy games.
Learn More
View
Deep Audio Classifier
Problem Statement:
Urban sound recognition is challenging due to overlapping acoustic patterns and environmental noise. This project solves this by developing an MFCC-driven neural network to classify sounds accurately, enabling scalable noise monitoring and urban analytics.
Summary:
This project tackles urban sound classification using the UrbanSound8K dataset by extracting Mel-Frequency Cepstral Coefficients (MFCC) to train a neural network. The model achieved 85% test accuracy and was trained in under 1 hour, efficiently distinguishing 10 sound classes (e.g., drilling, sirens, street music) despite background noise. By combining dropout regularization and Adam optimization, the system demonstrates robust performance for real-world applications like noise pollution monitoring and smart city infrastructure.
Learn More
View
Engineering (UG) Group Project (Capstone Project)
Problem Statement:
Traditional RF-based wireless networks face spectrum congestion, security vulnerabilities, and interference issues. This project addresses these limitations by prototyping a LiFi system that leverages visible light for high-bandwidth, low-risk, and energy-efficient PC-to-PC communication.
Summary:
Designed and implemented a LiFi system enabling secure, high-speed data transmission between PCs using modulated LED light and photodetectors. Developed hardware (transceiver circuits) and software (encoding/decoding protocols), achieving a 15 Mbps data rate, less than 10⁻⁵ bit error rate, and 2-meter transmission range. Demonstrated LiFi’s viability as a low-latency, energy-efficient alternative to congested RF networks (WiFi), with potential applications in EMI-sensitive environments. Validated through real-time text/file transfers, offering a scalable foundation for future light-based communication systems.
Learn More
Smart Dustbin
Problem Statement:
Manual dustbin lids pose hygiene risks due to frequent contact and often remain open, causing odor and spillage. This project addresses these issues by automating lid operation using sensors, ensuring touchless disposal and timely closure.
Summary:
Designed an Arduino UNO-based smart dustbin with an ultrasonic sensor to enable touchless, hygienic waste disposal. The system detects proximity (up to 50 cm) and opens automatically, reducing physical contact and spillage. Achieved 95% detection accuracy, 0.5-second response time, and 60% improvement in user convenience, validated through 100+ test cycles. Ideal for public spaces to promote cleanliness and operational efficiency.
Learn More
Autonomus Rover
Autonoumus Moving Bot using Arduino Duemilanove and various sensors.
Learn More
