DEV Community: Manognya Lokesh Reddy

Bias and Fairness in AI Models: Why Responsible AI Matters

Manognya Lokesh Reddy — Tue, 28 Oct 2025 01:55:34 +0000

Hi Dev Community! 👋

I’m Manognya Lokesh Reddy, an AI researcher and engineer currently pursuing my Master’s in Artificial Intelligence at the University of Michigan-Dearborn.

Through my academic and professional journey, I’ve realized that AI isn’t just about accuracy — it’s about fairness, accountability, and trust. In this blog, I’ll summarize the key insights from my research paper:
“Bias and Fairness in AI Models”, published in the International Journal of Innovative Science and Research Technology (IJISRT, 2024).

🧠 The Core Idea

AI systems are being used in everything — from job recruitment and banking to healthcare and criminal justice. But what happens when the data these models learn from is biased?

An algorithm trained on biased data will almost always produce biased predictions, even if it was never “taught” to discriminate.

The goal of my research was to:

Identify sources of bias in AI models

Explore methods to measure and mitigate bias

Propose strategies for building fairer, transparent models

⚙️ Understanding AI Bias

Bias can creep into AI systems in many ways:

Data Bias

When the training data doesn’t represent all groups equally.
Example: A facial recognition dataset containing mostly lighter-skinned faces will perform poorly for darker-skinned individuals.

Algorithmic Bias

When the model amplifies existing inequalities.
Example: A hiring model that favors certain colleges because historical data shows past hires came from there.

Evaluation Bias

When the test data or performance metrics themselves are skewed.
Example: Evaluating model accuracy without considering subgroup accuracy (e.g., gender, ethnicity).

📏 Measuring Fairness

There are several metrics researchers use to quantify fairness in AI systems:

Demographic Parity: Equal outcomes for all groups

Equalized Odds: Equal error rates across groups

Disparate Impact Ratio: Ratio of favorable outcomes between protected vs. unprotected groups

By combining these, developers can identify where bias exists and how severe it is.

🧩 Techniques to Reduce Bias

My research explored multiple strategies for bias mitigation:

Preprocessing Techniques – Balancing datasets using resampling, reweighting, or synthetic data generation.

In-Processing Methods – Adding fairness constraints directly in model training (e.g., adversarial debiasing).

Post-Processing Methods – Adjusting model predictions after training to achieve fairness.

Each method has trade-offs — for instance, fairness constraints can reduce model accuracy slightly, but the ethical gains are far more valuable.

🌍 Why It Matters

AI isn’t just a technical tool — it influences people’s lives.
From credit approvals to medical diagnoses, an unfair algorithm can have real-world consequences.

By incorporating fairness and transparency into our pipelines, we can build AI systems that are:
✅ More inclusive
✅ More accountable
✅ More trustworthy

🧠 Key Takeaways

AI bias originates mostly from human bias in data.

Fairness must be treated as a core performance metric, not an afterthought.

Building responsible AI requires collaboration between engineers, ethicists, and domain experts.

Transparency builds trust — explainability tools like LIME, SHAP, and model cards can help communicate model behavior.

🧬 Predicting Cancer Cells with Machine Learning: My Internship Project

Manognya Lokesh Reddy — Mon, 11 Aug 2025 16:11:27 +0000

Hey Devs! 👋

I’m Manognya Lokesh Reddy, currently pursuing my Master’s in Artificial Intelligence. During my internship at Prinston Smart Engineer, I built a Cancer Cell Prediction model that achieved 92–95% accuracy and helped reduce false positives by 15%.

In this blog, I’ll walk through the problem, approach, and lessons I learned from applying ML to medical diagnosis.

⚕️ The Problem
Cancer diagnosis often involves analyzing biopsy and cell sample data to identify malignant (cancerous) vs. benign cells.
Manual analysis is time-consuming and prone to errors, especially when the cell features are subtle.

Our goal was to:

Use machine learning to classify cells with high accuracy

Reduce false positives to avoid unnecessary stress and medical procedures

Make the model interpretable for doctors

🛠️ Tech Stack
Python

Pandas + NumPy – for data handling

Scikit-learn – for ML modeling

Matplotlib + Seaborn – for visualizations

Jupyter Notebook – for experimentation

🧪 Workflow Breakdown

📊 Data Preparation Loaded a publicly available Breast Cancer Wisconsin dataset

Checked for missing values and handled them appropriately

Standardized features for better model performance

🔍 Exploratory Data Analysis Visualized distributions of features like cell size, texture, and clump thickness

Used correlation heatmaps to identify important predictors

🧠 Model Selection Tested Logistic Regression, Random Forest, and SVM

Tuned hyperparameters using GridSearchCV

Chose the best model based on accuracy, recall, and F1-score

📈 Evaluation Achieved 92–95% accuracy on the test set

Reduced false positives by 15%

Presented feature importance graphs to make results explainable for medical teams

📊 Results
✅ High accuracy & balanced recall/precision

⚡ Reduced misdiagnosis risk

🩺 Model outputs interpretable for non-technical users

💡 What I Learned
In healthcare, false positives and false negatives carry very different risks—you must optimize carefully

Model explainability matters just as much as accuracy

Collaborating with medical professionals gives context that purely technical work lacks

🌍 Real-World Potential
Could be deployed in diagnostic labs to support decision-making

Useful in rural healthcare centers where expert pathologists aren’t available

Could be extended to detect other diseases with similar datasets

📃 Automating Insurance Document Processing with OCR and NLP

Manognya Lokesh Reddy — Tue, 05 Aug 2025 19:55:57 +0000

Hey Dev Community! 👋

I’m Manognya Lokesh Reddy, an AI grad student and ML engineer. In this post, I’ll share a project I worked on during my Co-op at Donyati India Pvt Ltd, where we built an intelligent system to digitize and extract information from handwritten insurance documents using OCR, NLP, and Computer Vision.

🧩 The Problem
In the insurance domain, processing scanned or handwritten documents is a manual, time-consuming task. It often involves:

Human data entry (error-prone and expensive)

Difficulty in reading handwritten or low-quality text

No structured digital storage for later retrieval

So we built a document processing system that:

Uses OCR to read handwritten text

Applies NLP to structure the extracted data

Delivers clean, searchable digital records

⚙️ Tech Stack
Python

Tesseract OCR + OpenCV – for text extraction

NLTK / spaCy – for text preprocessing and structuring

Custom pipelines – for automation and error handling

Flask – to prototype internal APIs

🏗️ What We Built
🔍 Step 1: Image Preprocessing
Used OpenCV for:

Denoising

Thresholding

Skew correction

Enhanced image clarity for better OCR results

🔡 Step 2: OCR Extraction
Used Tesseract to extract both printed and handwritten content

Achieved up to 97% accuracy with tuned configurations and training on custom handwriting samples

🧠 Step 3: NLP Pipeline
Cleaned text with:

Lowercasing

Removing stopwords

Entity recognition

Parsed key fields like:

Policyholder name

Claim amount

Date of accident

Medical report status

🔄 Step 4: Structuring & Output
Exported extracted fields into:

JSON for APIs

CSV for dashboard ingestion

Built a lightweight dashboard for visualization (internal use)

📊 Results
📌 97% OCR accuracy for handwritten documents

⏱️ Reduced document processing time by 30%

📁 Enabled structured, searchable storage for thousands of forms

📉 Minimized manual errors and improved regulatory compliance

💡 What I Learned
OCR needs custom preprocessing to be truly accurate—raw images won’t cut it

Handwriting OCR is still challenging, but small tweaks in image prep + model configs go a long way

NLP helps bring structure to chaotic data—without it, you're just digitizing noise

This kind of automation can save millions in ops costs in large enterprises

🌍 Applications Beyond Insurance
Legal document scanning

Bank KYC automation

Hospital record digitization

HR form processing in enterprises

🚀 What’s Next?
Adding language translation to support multilingual document digitization

Integrating signature verification for fraud prevention

Exploring LLM-powered extraction with LangChain + GPT for deeper semantic parsing

🧬 Skin Disease Detection with CNNs: Building an AI Tool for Early Diagnosis

Manognya Lokesh Reddy — Thu, 17 Jul 2025 23:06:27 +0000

👨‍⚕️ The Problem
Skin diseases are among the most common medical issues—but diagnosing them accurately requires expert knowledge and can be error-prone in early stages. In under-resourced settings, delays in treatment can lead to severe complications.

I aimed to build a Convolutional Neural Network (CNN) that could analyze images of skin lesions and classify diseases with high accuracy.

🛠️ Tools & Tech Stack
Python

TensorFlow + Keras – for building and training the CNN

OpenCV – for image preprocessing

Matplotlib / Seaborn – for visualizations

Jupyter Notebook – for experimentation

🧪 Workflow Breakdown

🗃️ Dataset Collection Combined data from multiple open-source datasets of skin diseases.

Performed label mapping to classify disease categories (e.g., eczema, psoriasis, vitiligo).

🖼️ Data Preprocessing Resized and normalized all images to a consistent size (e.g., 224x224).

Applied image augmentation (rotation, zoom, flip) to improve generalization.

Used OpenCV to enhance image clarity and contrast.

🧠 Model Architecture Built a custom CNN with multiple convolutional + max-pooling layers.

Used ReLU activation and Dropout to prevent overfitting.

Final layers used Softmax for multi-class classification.

📈 Training & Evaluation Achieved over 90% accuracy on test data.

Evaluated with confusion matrix and F1-score to check precision/recall balance.

Compared results with pretrained models (MobileNet, VGG16) for benchmarking.

📊 Results
📌 >90% classification accuracy on real-world images

🚑 Helped detect critical diseases earlier than baseline models

💡 Reduced false diagnoses by 15–20% with preprocessing and augmentation

💡 What I Learned
Clean, augmented data matters more than just a complex model.

Custom CNNs can compete well when fine-tuned for domain-specific data.

Healthcare AI must prioritize precision and recall, not just accuracy.

Visualization of errors (misclassified images) gave major insight into failure cases.

🌍 Real-World Potential
Telemedicine apps for early detection and triage

Rural healthcare where dermatologists are scarce

Integration into smartphones or kiosks for patient self-screening

🧬 Enhancing Historical Images with GANs: My AEGAN + SRGAN Project

Manognya Lokesh Reddy — Tue, 01 Jul 2025 16:28:25 +0000

Hey everyone! 👋

I’m Manognya Lokesh Reddy, currently pursuing my Master’s in Artificial Intelligence at the University of Michigan-Dearborn. In this post, I’ll take you behind the scenes of one of my most technically demanding and visually exciting projects: high-resolution image synthesis using GANs.

I built a system that takes low-resolution or black-and-white historical images and transforms them into sharp, colored, high-quality outputs using a combination of AEGAN (Auto-Embedding GAN) and SRGAN (Super-Resolution GAN).

🖼️ The Problem
Low-resolution or faded historical images limit both aesthetic appeal and analytical value. Traditional upscaling doesn’t preserve fine detail, and manual enhancement is time-consuming.

The goal? Use Generative Adversarial Networks (GANs) to:

Upscale image resolution

Colorize black-and-white photos

Retain edge quality and texture

Do it fast and accurately

⚙️ Tech Stack
Python

PyTorch – for building AEGAN and SRGAN models

Docker – for reproducible deployment

JWT (JSON Web Tokens) – for secure REST API endpoints

Mixed Precision Training – to optimize GPU usage

OpenCV – for image pre/post-processing

🧠 How It Works
🔗 AEGAN Architecture
Combines auto-encoders and GANs to embed image features in a compressed space

Stabilized training with gradient penalty and Wasserstein loss

Mixed precision training helped accelerate training by ~60% on GPU

🔎 SRGAN Module
Generates 4x super-resolved outputs

Preserves perceptual detail using VGG-based content loss

Fine-tuned using perceptual + adversarial losses for photorealism

🔐 Scalable API Access
Deployed model using a Docker container

Secured API with JWT authentication to restrict access and support production scalability

📊 Results
✅ 37% improvement in FID score (Frechet Inception Distance) over baseline GANs

⚡ 60% faster inference time with GPU optimization

🖼️ Output quality good enough for archival, artistic, and medical use cases

🧪 Deployment time reduced by 50% using Dockerized workflows

💡 What I Learned
GAN training is unstable—techniques like gradient penalty and mixed precision training are critical

Embedding-based architectures like AEGAN offer superior feature reconstruction

Docker and JWT are must-have tools for secure, scalable ML deployment

Working with image data brings unique challenges (e.g., lighting variance, compression noise)

📸 Use Cases
Historical image restoration

Medical image enhancement

Satellite image upscaling

Artistic rendering for museums or documentaries

🦴 Detecting Bone Fractures with Deep Learning: A Healthcare AI Project

Manognya Lokesh Reddy — Mon, 23 Jun 2025 17:47:25 +0000

Hey Devs! 👋

I’m Manognya Lokesh Reddy, currently pursuing my Master’s in AI. In this post, I’ll walk you through one of my favorite projects—using deep learning to detect bone fractures in X-ray and MRI images. If you're curious about how AI is transforming healthcare, this one’s for you!

⚕️ The Problem
Doctors often rely on X-rays and MRIs to detect fractures, but:

Manual interpretation is time-consuming

Subtle fractures can be missed

Resource limitations exist in rural and under-equipped clinics

So, I set out to build an AI-based system that could automatically detect bone fractures and support radiologists in diagnosis.

🛠️ Tech Stack
Python

TensorFlow, Keras – for model building

OpenCV – for image processing

CNN (Convolutional Neural Networks) – for classification

SVM (Support Vector Machines) – as a traditional baseline comparison

🧪 How the Model Works

Data Collection & Preprocessing Collected and cleaned X-ray/MRI image datasets

Applied preprocessing:

Noise reduction

Contrast enhancement

Feature extraction

Model Building Built a CNN to classify images as fractured or not fractured

Tuned layers, filters, activation functions for optimal performance

Training & Validation Used stratified train-test splits

Compared results with SVM to validate deep learning benefits

📊 Results
Achieved 92–95% accuracy on unseen test data

Reduced false negatives significantly (critical in medical diagnosis)

Boosted early detection, aiding in personalized treatment planning

🧠 What I Learned
Medical AI requires precision—you can't afford high error rates

Collaborating with healthcare professionals helped me align the model with clinical needs

Even basic preprocessing can drastically improve model performance in medical imaging

🩺 Why It Matters
AI isn’t just about tech—it’s about impact. With models like these:

We can support doctors in early diagnosis

Reduce diagnostic delays in underserved areas

Help build scalable, accessible health solutions

🚀 Next Steps
Planning to deploy the model via a web-based interface

Exploring integration with hospital workflows

Want to expand to multi-disease detection using the same framework

📄 How I Built DocuDetective.AI: A Chatbot for Interactive PDF Analysis

Manognya Lokesh Reddy — Thu, 12 Jun 2025 16:26:55 +0000

Hi Dev Community! 👋

I’m Manognya Lokesh Reddy, and I love building practical AI tools that solve real-world problems. Today, I want to share a project that’s especially close to me—DocuDetective.AI, an AI-powered chatbot I built that lets users interact with PDF documents using natural language.

If you’ve ever struggled to find specific info in a 100+ page document, you’ll love this.

🤔 The Problem
PDF documents are everywhere—research papers, business contracts, legal reports—but they’re hard to search through, especially when:

You’re looking for specific information fast.

The document is in a language you don’t understand.

You want a summary instead of reading the whole thing.

DocuDetective.AI was built to solve all of this.

🧠 Project Goals
Allow users to upload PDF files.

Ask questions like “What is the main conclusion?” or “Translate this section.”

Support vernacular language translation.

Use AI to chat with the document in real-time.

🛠️ Tech Stack
Python

LangChain – for chaining LLMs with document loaders and memory

Chroma DB – for vector embeddings and document retrieval

OpenAI GPT models – for natural language understanding

Streamlit (optional) – for a user-friendly interface

⚙️ How It Works
Document Ingestion
→ User uploads a PDF.
→ The content is split into chunks and embedded using OpenAI’s embeddings.

Vector Storage
→ Chroma DB stores the document embeddings for fast retrieval.

Query Handling
→ User asks a question in any language.
→ The system retrieves the most relevant sections and passes them to the LLM.

Response Generation
→ OpenAI model responds with a natural, human-like answer.
→ Optional: Translates to the desired language if needed.

📊 Results & Impact
🧠 Improved accuracy by 40% in retrieving relevant answers.

💬 Increased user engagement by 35% through interactive Q&A instead of static search.

🌍 Helped bridge language gaps for users working with multilingual documents.

💡 What I Learned
Working with LLMs and vector databases makes AI-powered search feel magical—but it requires careful tuning.

Preprocessing and chunking documents is a balancing act. Too much or too little = bad results.

Users prefer conversation over command lines—good UX really matters.

📈 Building a Time Series Forecasting ML App During My Internship: A Real-World AI Experience

Manognya Lokesh Reddy — Sun, 08 Jun 2025 18:33:56 +0000

Hi everyone! 👋

I’m Manognya Lokesh Reddy, a Master’s student in Artificial Intelligence at the University of Michigan-Dearborn. In this post, I’ll be sharing one of the most rewarding experiences of my career so far—building a Time Series Forecasting application during my internship at Donyati India Pvt Ltd. This project helped me understand how AI works in real business settings, and I hope it gives you a glimpse into what it’s like applying ML beyond the classroom.

🧩 The Business Problem
Forecasting plays a critical role in business decisions—whether it's predicting sales, managing inventory, or optimizing resources. The goal of our project was to create an end-to-end Time Series Forecasting application that could accurately predict future trends for multinational clients, replacing outdated manual methods.

⚙️ Tech Stack & Tools
Here’s what I used to build the application:

Programming: Python

Libraries: Pandas, NumPy, Matplotlib, Keras (LSTM)

Modeling: Long Short-Term Memory (LSTM) Neural Networks

DevOps: Docker (for containerization), Git & GitHub

Deployment: AWS (for hosting the application)

🏗️ My Contributions
During my 1-year internship, I worked on:

🔄 End-to-End ML Pipeline
Created a complete ML pipeline—from data ingestion and preprocessing to model training and deployment.

Implemented automated pipelines that reduced manual data processing by 40%.

🧠 Model Optimization
Used LSTM networks to capture temporal dependencies in the dataset.

Tuned hyperparameters and performed feature engineering to improve accuracy.

Achieved a 15% improvement in prediction accuracy over previous models.

🐳 Containerization with Docker
Packaged the entire application into Docker containers to ensure reproducibility and portability.

Result: Deployment setup time was cut down by 50%.

📊 Impact Across Teams
The forecasting tool was deployed across 20+ teams, improving their operational efficiency by 25%.

📚 Key Learnings
Real-world data is messy and inconsistent. Cleaning and preprocessing are just as important as model building.

LSTM models are excellent for capturing time-based trends—but require careful tuning.

DevOps skills like Docker and cloud deployment are essential for taking ML models into production.

It’s not just about building a model—it’s about solving a real problem that saves time and adds value.

🚀 Final Thoughts
This project gave me hands-on experience with both the technical and practical aspects of machine learning in business. It taught me that good ML is not just about the algorithm—it’s about creating systems that are scalable, efficient, and useful.

If you’re a student or early-career professional, I encourage you to:

Work on real datasets

Think about deployment, not just accuracy

Build projects that solve actual business problems

🚀 Kicking Off My Dev Journey: Why I’m Starting This Blog

Manognya Lokesh Reddy — Thu, 05 Jun 2025 18:13:26 +0000

Hey Devs! 👋

I’m Manognya Lokesh Reddy, currently pursuing my Master’s in Artificial Intelligence at the University of Michigan-Dearborn. Over the past few years, I’ve explored the world of software engineering, machine learning, and research-driven development—and now, I’m excited to share what I’ve learned (and what I’m still learning!) through this blog.

🌱 Why I’m Starting This Blog
Like many developers, I often hit roadblocks, debug for hours, or stumble across hidden gems that make life easier. I’ve learned that writing things down not only helps me retain concepts better but also helps others who might be facing the same challenges.

This blog is my space to:

Share tutorials, project walkthroughs, and code snippets

Reflect on my AI/ML journey—the wins and the struggles

Write about tools and tech I’m excited about

Talk about student life, productivity, and career growth

🧠 What You Can Expect
Beginner-friendly AI/ML posts with real-world examples

Insights into side projects I’ve worked on—how I built them, what I learned

Honest thoughts on job hunting, tech interviews, and building a career as an international student

Occasional deep dives into papers, tech stacks, and experimental ideas I’m testing out