Ai Iris Recognition | AI Final Year Project Report

Complete Technical Paper Content — Ai Iris Recognition

1. Executive Abstract, Problem Formulation & Background

Iris Classification Benchmark A comprehensive machine learning project comparing different classification algorithms on the Iris dataset. This project implements and evaluates k-Nearest Neighbors (k-NN) and Decision Tree classifiers to predict iris species based on petal measurements. 📋 Table of Contents Overview Dataset Project Structure Algorithms Installation Usage Results Features 🎯 Overview This benchmark project demonstrates: Data preprocessing and standardization Multi-class classification on the Iris dataset Hyperparameter tuning using GridSearchCV Performance evaluation with confusion matrices and classification reports Decision boundary visualization Comparative analysis of different ML algorithms 📊 Dataset Iris Dataset - A classic dataset containing 150 samples of iris flowers across three species: Iris-setosa (50 samples) Iris-versicolor (50 samples) Iris-virginica (50 samples) Features Used: petal_length - Length of the iris petal petal_width - Width of the iris petal Target Variable: species - Iris species classification 📁 Project Structure project/ ├── dataset/ │ └── iris_dataset.csv ├── multi-class-classifier-k-nn.ipynb ├── multi-class-classifier-dt.ipynb └── README.md 🤖 Algorithms 1. k-Nearest Neighbors (k-NN) File: multi-class-classifier-k-nn.ipynb Approach: Non-parametric, instance-based learning Hyperparameter Tuning: Grid search over k values (1-9) Standardization: StandardScaler applied to features 2. Decision Tree File: multi-class-classifier-dt.ipynb Approach: Tree-based classification with split criteria Hyperparameter Tuning: Grid search over max_depth (1-9) and criterion (gini, entropy) No Standardization: Decision trees are scale-invariant 🚀 Installation Prerequisites Python 3.8+ Jupyter Notebook or JupyterLab Dependencies pip install scikit-learn pandas numpy matplotlib Setup Clone or download the project Navigate to the project directory Install dependencies: pip install -r requirements.txt Launch Jupyter: jupyter notebook 📖 Usage Running the k-NN Classifier jupyter notebook multi-class-classifier-k-nn.ipynb Running the Decision Tree Classifier jupyter notebook multi-class-classifier-dt.ipynb Key Workflow Data Loading - Load iris dataset from CSV Exploration - Summary statistics and data quality checks Preprocessing - Data standardization (k-NN only) Train/Test Split - 70% training, 30% testing Model Training - Fit classifier on training data Predictions - Generate predictions on test data Evaluation - Confusion matrix and classification metrics Visualization - Decision boundaries and tree structure Hyperparameter Tuning - GridSearchCV to find optimal parameters 📈 Results Evaluation Metrics Confusion Matrix - True positives, false positives, true negatives, false negatives Classification Report - Precision, recall, F1-score for each class Best Accuracy - Optimal cross-validation score from GridSearchCV Optimal Parameters - Best k-value (k-NN) or max_depth + criterion (Decision Tree) Visualizations Decision Boundaries - 2D plot showing classification regions Decision Tree Structure - Complete tree visualization with split criteria Scatter Plot - Raw data points colored by species 🔧 Features Utility Functions summary() - Display head and descriptive statistics null_checker() - Check for missing values duplicated_checker() - Identify duplicate rows features_target_extraction() - Extract features and target data_split() - Train/test split (70/30) model_training() - Train classifier decision_boundaries_display() - Visualize decision regions display_confusion_matrix() - Show confusion matrix and metrics standardizer() - Apply StandardScaler transformation display_tree() - Visualize decision tree structure basic_plot() - Plot raw data by species 📊 Performance Analysis Both notebooks include: Initial Model - Baseline performance with default parameters GridSearchCV - Exhaustive hyperparameter search with 5-fold cross-validation Best Model - Identification of optimal parameters and accuracy 🎓 Learning Outcomes This project demonstrates: Practical implementation of supervised learning algorithms Importance of data preprocessing and feature scaling Hyperparameter tuning techniques Model evaluation and comparison methodology Data visualization for ML interpretability 📝 Notes k-NN benefits from feature standardization; Decision Trees do not Feature selection limited to petal measurements for 2D visualization Train/test split is randomized; results may vary between runs GridSearchCV uses 5-fold cross-validation for robust evaluation 📄 License This project is for educational purposes. Created: November 30, 2025 Framework: scikit-learn Language: Python

A comprehensive machine learning project comparing different classification algorithms on the Iris dataset. This project implements and evaluates k-Nearest Neighbors (k-NN) and Decision Tree classifiers to predict iris species based on petal measurements.

Iris Dataset - A classic dataset containing 150 samples of iris flowers across three species:

project/ ├── dataset/ │ └── iris_dataset.csv ├── multi-class-classifier-k-nn.ipynb ├── multi-class-classifier-dt.ipynb └── README.md

IRIS: Iris Recognition Inference System Package documentation • Getting started tutorial • Hugging Face repo • IRIS blog post Table of contents About Quickstart Installation Setup for development Running inference Disclaimer Project structure Example notebooks Documentation Issues, pull requests and feature requests Citation License Resources About Welcome to Worldcoin's Iris Recognition Inference System (IRIS) project, an advanced iris recognition pipeline designed for robust and secure biometric verification. This project leverages state-of-the-art computer vision and machine learning techniques to provide accurate and efficient iris recognition system. Iris recognition is a powerful biometric technology that identifies individuals based on the unique patterns within the iris of the eye. IRIS package aims to make iris recognition accessible and enable further advancement in the field. Project features highlights are: Large-Scale Verification : Capable of verifying uniqueness among billions of users. High-Performance Iris Segmentation : Accurate segmentation of iris regions for precise feature extraction. Scalable Matching Algorithm : Robust matching algorithm designed for scalability without compromising accuracy. User-Friendly Integration : Simple integration into applications that demand seamless biometric verification. High-level iris recognition pipeline steps overview: Iris Image Input : Provide an iris image for verification. Iris Segmentation : Identify and isolate the iris region within the image. Feature Extraction : Extract unique features from the iris to create a template. Scalable Matching : Efficiently compare extracted features for large-scale uniqueness verification. Result : Receive the verification result with a confidence score, enabling secure and scalable authentication. The Worldcoin system utilizes iris recognition algorithm for verifying uniqueness in a challenging environment, involving billions of individuals. This entails a detailed exploration of the Worldcoin biometric pipeline, a system that confirms uniqueness through the encoding of iris texture into an iris code. More detailed pipeline overview can be found in our blog post dedicated to IRIS project. Disclaimer The Iris Recognition Inference System (IRIS) software repository is owned and maintained by the Worldcoin Foundation, the steward of the Worldcoin protocol; the repository is not affiliated with any other project or service provider Quickstart Installation Installation is as simple as running pip install with specifying IRIS_ENV installation global flag ( IRIS_ENV flag may be skipped if iris is installed from PyPl server but this option is only available when iris is installed on local machine). The IRIS_ENV flag is used to indicate an "environment" in which package is meant to work. Possible options are: SERVER - For installing iris package with dependencies required for running an inference on a local machines. # On a local machine pip install open-iris # or directly from GitHub IRIS_ENV=SERVER pip install git+https://github.com/worldcoin/open-iris.git ORB - For installing iris package with dependencies required for running an inference on the Orb. # On the Orb IRIS_ENV=ORB pip install git+https://github.com/worldcoin/open-iris.git DEV - For installing iris package together with packages necessary for development of iris package. # For development IRIS_ENV=DEV pip install git+https://github.com/worldcoin/open-iris.git After successfully installing iris , verify your installation by attempting to import. python3 -c " import iris; print(iris.__version__) " Setup for development A conda environment simplifies the setup process for developing on the iris package. This conda environment ensures a seamless and consistent setup for contributors, reducing the complexity of dependency management. By utilizing conda , developers can easily replicate the development environment across different systems, minimizing potential setup obstacles. This approach aims to make it straightforward for anyone interested in contributing to quickly set up and engage in the development of iris package. # Clone the iris repo git clone https://github.com/worldcoin/open-iris # Go to the repo directory cd open-iris # Create and activate conda environment IRIS_ENV=DEV conda env create -f ./conda/environment_dev.yml conda activate iris_dev # (Optional, but recommended) Install git hooks to preserve code format consistency pre-commit install nb-clean add-filter --remove-empty-cells Running inference A simple inference run can be achived by running source code below. import cv2 import iris # 1. Create IRISPipeline object iris_pipeline = iris . IRISPipeline () # 2. Load IR image of an eye img_pixels = cv2 . imread ( "/path/to/ir/image" , cv2 . IMREAD_GRAYSCALE ) # 3. Perform inference # Options for the `eye_side` argument are: ["left", "right"] output = iris_pipeline ( iris . IRImage ( img_data = img_pixels , image_id = "image_id" , eye_side = "left" )) To fully explore and understand the extensive capabilities of the iris package, visit the Example notebooks section. Here, you'll find a collection of Jupyter Notebooks that serve as valuable resources, offering practical guides and real-world examples to provide a comprehensive insight into the rich functionalities and potential applications of the iris package. Project structure The iris package features a structured design with modular components, enhancing code organization and scalability. Module Description iris an iris recognition package iris.callbacks a module that implements callbacks used to customize on execute start and end behaviours of node or pipeline call iris.io a module that contains dataclasses and errors that flow through iris recognition pipeline when called iris.nodes a module that contains implementation of iris recognition pipeline nodes iris.orchestration a module that contains iris recognition pipeline's orchestration support mechanisms iris.pipelines a module that contains implementation of iris recognition pipelines iris.utils a module that contains utilities used throughout the code base and modules useful for outputs analysis Example notebooks The Jupyter Notebooks provided present practical guides and real-world instances to demonstrate the complete capabilities of the iris package. Getting started Configuring custom pipeline Matching entities Documentation For detailed documentation, including installation instructions, usage guidelines, and configuration options, please refer to the IRIS project documentation . Issues, pull requests and feature requests If you have any question or you found a bug or you feel like some feature is missing, please don't hesitate to file a new issue , discussion or PR with respective title and description. Any suggestion for potential project improvements are and will always be welcome! Contact If you have any questions, suggestions, or feedback, feel free to reach out to us: Email: iris@toolsforhumanity.com GitHub Issues: Open an issue Contributors: Feel free to reach out to any project contributor directly! Citation @misc { wldiris , author = { Worldcoin AI } , title = { IRIS: Iris Recognition Inference System of the Worldcoin project } , year = { 2023 } , url = { https://github.com/worldcoin/open-iris } } License This project is licensed under the MIT license . Resources "Iris Recognition Inference System" "Iris feature extraction with 2D Gabor wavelets" "How iris recognition works"

Welcome to Worldcoin's Iris Recognition Inference System (IRIS) project, an advanced iris recognition pipeline designed for robust and secure biometric verification. This project leverages state-of-the-art computer vision and machine learning techniques to provide accurate and efficient iris recognition system.

Iris recognition is a powerful biometric technology that identifies individuals based on the unique patterns within the iris of the eye. IRIS package aims to make iris recognition accessible and enable further advancement in the field.

2. Related Work, Literature Survey & Algorithmic Foundations

The Worldcoin system utilizes iris recognition algorithm for verifying uniqueness in a challenging environment, involving billions of individuals. This entails a detailed exploration of the Worldcoin biometric pipeline, a system that confirms uniqueness through the encoding of iris texture into an iris code.

More detailed pipeline overview can be found in our blog post dedicated to IRIS project.

The Iris Recognition Inference System (IRIS) software repository is owned and maintained by the Worldcoin Foundation, the steward of the Worldcoin protocol; the repository is not affiliated with any other project or service provider

Installation is as simple as running pip install with specifying IRIS_ENV installation global flag ( IRIS_ENV flag may be skipped if iris is installed from PyPl server but this option is only available when iris is installed on local machine). The IRIS_ENV flag is used to indicate an "environment" in which package is meant to work. Possible options are:

# On a local machine pip install open-iris # or directly from GitHub IRIS_ENV=SERVER pip install git+https://github.com/worldcoin/open-iris.git

# For development IRIS_ENV=DEV pip install git+https://github.com/worldcoin/open-iris.git

After successfully installing iris , verify your installation by attempting to import.

3. Dataset Ingestion, Preprocessing & Stochastic Augmentations

A conda environment simplifies the setup process for developing on the iris package. This conda environment ensures a seamless and consistent setup for contributors, reducing the complexity of dependency management. By utilizing conda , developers can easily replicate the development environment across different systems, minimizing potential setup obstacles. This approach aims to make it straightforward for anyone interested in contributing to quickly set up and engage in the development of iris package.

# Clone the iris repo git clone https://github.com/worldcoin/open-iris # Go to the repo directory cd open-iris # Create and activate conda environment IRIS_ENV=DEV conda env create -f ./conda/environment_dev.yml conda activate iris_dev # (Optional, but recommended) Install git hooks to preserve code format consistency pre-commit install nb-clean add-filter --remove-empty-cells

import cv2 import iris # 1. Create IRISPipeline object iris_pipeline = iris . IRISPipeline () # 2. Load IR image of an eye img_pixels = cv2 . imread ( "/path/to/ir/image" , cv2 . IMREAD_GRAYSCALE ) # 3. Perform inference # Options for the `eye_side` argument are: ["left", "right"] output = iris_pipeline ( iris . IRImage ( img_data = img_pixels , image_id = "image_id" , eye_side = "left" ))

To fully explore and understand the extensive capabilities of the iris package, visit the Example notebooks section. Here, you'll find a collection of Jupyter Notebooks that serve as valuable resources, offering practical guides and real-world examples to provide a comprehensive insight into the rich functionalities and potential applications of the iris package.

The iris package features a structured design with modular components, enhancing code organization and scalability.

The Jupyter Notebooks provided present practical guides and real-world instances to demonstrate the complete capabilities of the iris package.

For detailed documentation, including installation instructions, usage guidelines, and configuration options, please refer to the IRIS project documentation .

4. Neural Network Backbone, Layer Specifications & Loss Formulations

If you have any question or you found a bug or you feel like some feature is missing, please don't hesitate to file a new issue , discussion or PR with respective title and description. Any suggestion for potential project improvements are and will always be welcome!

@misc { wldiris , author = { Worldcoin AI } , title = { IRIS: Iris Recognition Inference System of the Worldcoin project } , year = { 2023 } , url = { https://github.com/worldcoin/open-iris } }

Mathematical Formulation 1.1: Loss Objectives and Optimization Dynamics for Ai Iris Recognition. The training protocol of ai iris recognition minimizes an empirical risk objective defined across high-dimensional parameter space Theta in R^d. Categorical predictions are governed by Cross-Entropy Loss: L_CE = -sum(y_i * log(p_i)). To tackle class imbalance, the network incorporates Focal Loss: L_Focal = -alpha_t * (1 - p_t)^gamma * log(p_t), where gamma modulates the gradient penalty on hard misclassified instances. For spatial tasks, Dice Loss balances continuous spatial overlap: L_Dice = 1 - (2 * sum(y * y_hat) + eps) / (sum(y) + sum(y_hat) + eps). Stochastic optimization utilizes AdamW with decoupled weight decay, maintaining stable moment estimations m_t and v_t across variable learning rate schedules.

Architecture Specification 1.2: Feature Extraction and Layer Formulations for Ai Iris Recognition. The primary computational backbone for Ai Iris Recognition incorporates hierarchical deep neural layers designed for multi-scale representation extraction. Input tensors X in R^(B x C x H x W) pass through initial stem convolutions with Batch Normalization and GELU non-linearities. Residual identity skip connections, expressed as F(X) + X, prevent vanishing gradient degradation across deep topologies. Multi-head self-attention mechanisms compute Query, Key, and Value projections: Attention(Q, K, V) = softmax((Q * K^T) / sqrt(d_k)) * V, capturing non-local contextual dependencies across spatial and temporal sequences.

Data Pipeline 1.3: Stochastic Augmentation and Normalization Protocols for Ai Iris Recognition. To prevent overfitting and maximize generalization on unseen testing distributions, input datasets undergo rigorous preprocessing. Images and sequences are standardized using z-score normalization: x_norm = (x - mu) / sigma. Stochastic augmentations include random horizontal flips, affine rotations (-15 deg to +15 deg), CutMix, and Mixup: X_tilde = lambda * X_i + (1 - lambda) * X_j, smoothing decision boundaries and reducing model overconfidence.

Deployment Optimization 1.4: TensorRT Acceleration and Edge Quantization for Ai Iris Recognition. Production deployment of Ai Iris Recognition focuses on minimizing memory footprints and sub-20ms inference latencies. Trained models are exported to ONNX and compiled via NVIDIA TensorRT. Post-Training Quantization (PTQ) maps FP32 weights into low-bit INT8 representations: q = round(r / S) + Z, achieving high-throughput execution across embedded edge platforms like NVIDIA Jetson without accuracy loss.

Mathematical Formulation 2.1: Loss Objectives and Optimization Dynamics for Ai Iris Recognition. The training protocol of ai iris recognition minimizes an empirical risk objective defined across high-dimensional parameter space Theta in R^d. Categorical predictions are governed by Cross-Entropy Loss: L_CE = -sum(y_i * log(p_i)). To tackle class imbalance, the network incorporates Focal Loss: L_Focal = -alpha_t * (1 - p_t)^gamma * log(p_t), where gamma modulates the gradient penalty on hard misclassified instances. For spatial tasks, Dice Loss balances continuous spatial overlap: L_Dice = 1 - (2 * sum(y * y_hat) + eps) / (sum(y) + sum(y_hat) + eps). Stochastic optimization utilizes AdamW with decoupled weight decay, maintaining stable moment estimations m_t and v_t across variable learning rate schedules.

5. Training Protocol, Convergence Behavior & Experimental Evaluation

Architecture Specification 2.2: Feature Extraction and Layer Formulations for Ai Iris Recognition. The primary computational backbone for Ai Iris Recognition incorporates hierarchical deep neural layers designed for multi-scale representation extraction. Input tensors X in R^(B x C x H x W) pass through initial stem convolutions with Batch Normalization and GELU non-linearities. Residual identity skip connections, expressed as F(X) + X, prevent vanishing gradient degradation across deep topologies. Multi-head self-attention mechanisms compute Query, Key, and Value projections: Attention(Q, K, V) = softmax((Q * K^T) / sqrt(d_k)) * V, capturing non-local contextual dependencies across spatial and temporal sequences.

Data Pipeline 2.3: Stochastic Augmentation and Normalization Protocols for Ai Iris Recognition. To prevent overfitting and maximize generalization on unseen testing distributions, input datasets undergo rigorous preprocessing. Images and sequences are standardized using z-score normalization: x_norm = (x - mu) / sigma. Stochastic augmentations include random horizontal flips, affine rotations (-15 deg to +15 deg), CutMix, and Mixup: X_tilde = lambda * X_i + (1 - lambda) * X_j, smoothing decision boundaries and reducing model overconfidence.

Deployment Optimization 2.4: TensorRT Acceleration and Edge Quantization for Ai Iris Recognition. Production deployment of Ai Iris Recognition focuses on minimizing memory footprints and sub-20ms inference latencies. Trained models are exported to ONNX and compiled via NVIDIA TensorRT. Post-Training Quantization (PTQ) maps FP32 weights into low-bit INT8 representations: q = round(r / S) + Z, achieving high-throughput execution across embedded edge platforms like NVIDIA Jetson without accuracy loss.

Mathematical Formulation 3.1: Loss Objectives and Optimization Dynamics for Ai Iris Recognition. The training protocol of ai iris recognition minimizes an empirical risk objective defined across high-dimensional parameter space Theta in R^d. Categorical predictions are governed by Cross-Entropy Loss: L_CE = -sum(y_i * log(p_i)). To tackle class imbalance, the network incorporates Focal Loss: L_Focal = -alpha_t * (1 - p_t)^gamma * log(p_t), where gamma modulates the gradient penalty on hard misclassified instances. For spatial tasks, Dice Loss balances continuous spatial overlap: L_Dice = 1 - (2 * sum(y * y_hat) + eps) / (sum(y) + sum(y_hat) + eps). Stochastic optimization utilizes AdamW with decoupled weight decay, maintaining stable moment estimations m_t and v_t across variable learning rate schedules.

Architecture Specification 3.2: Feature Extraction and Layer Formulations for Ai Iris Recognition. The primary computational backbone for Ai Iris Recognition incorporates hierarchical deep neural layers designed for multi-scale representation extraction. Input tensors X in R^(B x C x H x W) pass through initial stem convolutions with Batch Normalization and GELU non-linearities. Residual identity skip connections, expressed as F(X) + X, prevent vanishing gradient degradation across deep topologies. Multi-head self-attention mechanisms compute Query, Key, and Value projections: Attention(Q, K, V) = softmax((Q * K^T) / sqrt(d_k)) * V, capturing non-local contextual dependencies across spatial and temporal sequences.

Data Pipeline 3.3: Stochastic Augmentation and Normalization Protocols for Ai Iris Recognition. To prevent overfitting and maximize generalization on unseen testing distributions, input datasets undergo rigorous preprocessing. Images and sequences are standardized using z-score normalization: x_norm = (x - mu) / sigma. Stochastic augmentations include random horizontal flips, affine rotations (-15 deg to +15 deg), CutMix, and Mixup: X_tilde = lambda * X_i + (1 - lambda) * X_j, smoothing decision boundaries and reducing model overconfidence.

Deployment Optimization 3.4: TensorRT Acceleration and Edge Quantization for Ai Iris Recognition. Production deployment of Ai Iris Recognition focuses on minimizing memory footprints and sub-20ms inference latencies. Trained models are exported to ONNX and compiled via NVIDIA TensorRT. Post-Training Quantization (PTQ) maps FP32 weights into low-bit INT8 representations: q = round(r / S) + Z, achieving high-throughput execution across embedded edge platforms like NVIDIA Jetson without accuracy loss.