Reza Jahadi

This project implements parallel matrix-vector multiplication on the GPU using CUDA with row-wise decomposition. Each thread computes one row's dot product, leveraging GPU parallelism to significantly accelerate computation.

Key Contributions:
• Designed a CUDA kernel with varying threads_per_block configurations (32 to 640).
• Measured performance (speedup vs CPU) for each setup.

Result:
As shown in the chart, maximum speedup (~2.9×) was achieved with 64 threads per block. Performance gradually decreased beyond that due to GPU overhead and reduced efficiency. At 640 threads per block, speedup dropped close to 1×, indicating minimal benefit over CPU execution.

This project presents a detailed machine learning analysis of the classic Iris dataset. The study involves t-SNE-based data visualization, training Support Vector Machine (SVM) models with different configurations, and implementing a neural network for multi-class classification.

Key Components:
• t-SNE Visualization: 2D projection of high-dimensional data to identify clustering patterns among flower species.
• Support Vector Machines: Both linear and polynomial SVMs are trained and compared. Best results achieved using non-linear kernel.
• Neural Network: Two hidden layers with 60 neurons each, ReLU activation, and Softmax output; trained over 30 epochs.

Experimental Setup:
• Data split: 70% training / 30% test
• Libraries: Scikit-learn, Matplotlib, Seaborn, Keras
• Optimization strategies include tuning the regularization parameter C and loss functions

As illustrated, we can clearly observe distinct clusters. In the visualization, data points with similar characteristics naturally form clusters. Iris-versicolor and Iris-virginica appear closely grouped, indicating high similarity between them, while Iris-setosa is distinctly separated from the other two. This reflects differences in their feature distributions. The t-SNE algorithm effectively projects high-dimensional data into a 2D space, preserving the intrinsic clustering structure of the original dataset.

Performance:

• Linear SVM Accuracy: 96%
• Non-linear SVM Accuracy: 95.81%
• Neural Network Accuracy: 97.77%
• ROC AUC Score: 1.00 for all models, indicating perfect class separability

Conclusion:
The project shows how hyperparameter tuning and model architecture choices can impact classification accuracy. With proper setup, simple models can achieve near-perfect performance on well-structured datasets like Iris.

This project demonstrates the deployment of a Convolutional Neural Network (CNN) on the Kria KV260 edge computing platform using Vitis AI. The entire deployment is orchestrated by the run_all.sh script, which automates the required steps on the host machine.

Key Technologies:
• Vitis AI – Xilinx's framework for deploying ML models on FPGAs
• FPGA Acceleration – Harnessing customizable, low-latency inference on hardware
• Kria KV260 – Zynq UltraScale+ MPSoC board optimized for edge AI applications

Inference Performance Comparison:
A performance benchmark was conducted between a traditional host CPU and the Kria KV260 board. Results show a dramatic improvement in inference speed:

• Host (Intel Core i7, 4th Gen): 23.8 FPS on 10,000 images
• Kria KV260:
  • 1 Thread: 3,972.87 FPS
  • 2 Threads: 6,698.55 FPS
  • 3 Threads: 7,341.93 FPS

Conclusion:
The project highlights the efficiency of deploying AI models on FPGA platforms for real-time inference. The Kria KV260 achieves up to 300× speedup over CPU inference, demonstrating the viability of FPGA-based solutions for edge ML tasks.

This project implements CNN inference on the MNIST dataset using C and MPI (Message Passing Interface) for distributed execution across multiple CPUs.

We designed and compared two parallel inference approaches:

• Data Parallelism (mnist_data.c): Each MPI process runs the full CNN model and processes a different portion of the input data independently. This method is efficient and scales well with minimal communication overhead.
• Pipeline Parallelism (mnist.c): CNN layers are distributed across MPI processes, forming a computation pipeline. Each processor handles one or more layers and passes intermediate results to the next, reducing idle time and overlapping computation stages.

While the data parallel method tends to offer better performance due to lower inter-process communication, the pipelined approach demonstrates a novel execution pattern that can effectively utilize CPUs in sequence. Despite the communication overhead, pipeline parallelism achieves comparable performance under specific configurations.

This technique is particularly valuable because it:

• Maximizes processor utilization through overlapped execution
• Introduces pipelined execution to reduce layer-wise bottlenecks
• Adapts to both model and data parallelism, depending on resource availability

The project highlights how distributed parallelism strategies can accelerate deep learning inference on CPU clusters—even for relatively small models like those trained on MNIST.

Result:
Although the pipeline method experiences some latency due to inter-process communication, our evaluations show that it performs closely to the data parallel method in practice.

Following figure shows the execution time (vertical axis) vs the number of nodes (horizontal axis) for the two methods. Also, you can see the speedup for the pipeline method compared to the data parallel method.

This project demonstrates a complete pipeline for training, quantizing, and testing an AlexNet model on the CIFAR-10 dataset using PyTorch. It includes all stages from data preprocessing and model design to post-training quantization and deployment-ready model export.

Project Pipeline:
• Built a custom AlexNet architecture adapted for CIFAR-10's 10-class image classification task
• Implemented a full training loop with PyTorch, using SGD optimizer and CrossEntropyLoss
• Evaluated model performance using accuracy and ROC AUC metrics on 10,000 test images
• Applied post-training quantization using the Vitis AI pytorch_nndct toolkit
• Exported the quantized model to .xmodel, .onnx, and .jit.pt formats for hardware deployment

Technical Highlights:
• Framework: PyTorch, Torchvision
• Quantization: Vitis AI (pytorch_nndct), 8-bit integer quantization
• Dataset: CIFAR-10, resized and normalized for AlexNet input compatibility
• Deployment Support: Xilinx DPU-compatible model exports with <100ms inference latency

Results:
• Achieved 86.6% classification accuracy on the CIFAR-10 test set
• Successfully converted the trained model to quantized deployment formats without modifying architecture or retraining
• All quantized models preserved class separability (ROC AUC = 1.00)
• Pipeline is fully automated for training, calibration, testing, and export

Designed and developed a C++ engine for performing arithmetic operations on extremely large integers (up to 200 digits), bypassing the limitations of built-in data types. This system accurately handles signed integer calculations using string-based algorithms, making it ideal for cryptographic, mathematical, or embedded applications where precision is critical.

Key Features:
• Supports Arbitrary Precision: Handles integers far beyond the range of `int` or `long` types
• Comprehensive Arithmetic Support: Addition, subtraction, multiplication, division, exponentiation, and square root
• Signed Number Handling: Full support for negative values and proper sign-aware computation
• Robust Input Validation: Ensures numeric integrity before processing

Technical Implementation:
• Language: Standard C++ (no external libraries)
• Algorithm Design: Manual digit-wise arithmetic logic using strings
• UI: Text-based interactive console menu
• Max Input Size: 200-digit integers

Highlights:
• Accurately performs operations on numbers larger than 10¹⁹⁹
• Square root implementation using digit-wise estimation
• Includes internal utility functions for zero trimming, absolute comparison, and order tracking
• All operations work on user-entered values with minimal delay

This is a desktop face recognition system designed to identify and verify passengers using a combination of facial recognition and passport data. The application allows airport staff or security personnel to quickly match a passenger's live webcam image with their stored passport photo, helping to automate and secure the identity verification process.

Technical Overview:
The system employs a hybrid deep learning and traditional image processing pipeline:

• Face Detection: Performed using Haar Cascade classifiers
• Face Verification: Uses facial embeddings extracted via a fine-tuned VGG-based model
• Similarity Measurement: Cosine similarity and Euclidean distance for identity confidence
• Model Fine-Tuning: LBPH (Local Binary Patterns Histogram) recognizer for incremental learning

How It Works:
1. User inputs passenger's passport number through PyQt5 GUI
2. System retrieves passenger details and displays them
3. Live webcam feed captures passenger image
4. Face detection and embedding extraction performed
5. Comparison with stored passport photo for verification
6. Support for adding new faces and model fine-tuning

Technologies Used:
• Python, PyQt5, OpenCV
• TensorFlow, VGGNet (for embeddings)
• Haar Cascade, LBPH Face Recognizer
• SQLite for passenger database