Personal

This is my info—I’m sharing it here to dazzle you with the hard work, late nights, and a questionable amount of debugging I've done over the years. Once you're thoroughly impressed (or at least mildly curious), feel free to scroll down for all the details.

I’m Faizah,an AI enthusiast, problem-solver, caffeine-fueled coder, and a proud owner of way too many Ongoing side projects.

An Explainable AI (XAI)-powered tool that not only analyzes medical scans but also spills the beans on why it thinks something’s wrong. It even gives doctors a nudge through their portal—because AI can’t just diagnose, it has to overachieve with transparency and sass.

[To see how its done click here](https://github.com/faizahkureshi232/DoctorLRP)

Doctor LRP is an advanced Explainable AI (XAI) tool designed to assist healthcare professionals in understanding and verifying diagnostic predictions. The system leverages Layer-wise Relevance Propagation (LRP) to provide detailed explanations for its predictions, ensuring transparency and trust in AI-assisted healthcare.

Key Features:

1.  **Prediction with Explanation**: After making a prediction, Doctor LRP employs LRP to highlight which regions of the medical scan contributed most to the prognosis.

2.  **Object Detection**: The system incorporates object detection to identify and outline (using bounding boxes) the precise location of abnormalities, providing a clear "what and where" for detected issues.

3.  **Datasets and Testing**: Doctor LRP was rigorously tested on two datasets:

    *   **Brain Tumor Dataset**: To identify and explain brain tumor regions.

    *   **Bone Fracture Dataset**: To detect and localize fractures in bone scans.

4.  **Accuracy**: Achieved an impressive 93% accuracy across both datasets, demonstrating its reliability and effectiveness.

This tool not only empowers doctors with actionable insights but also bridges the gap between AI predictions and human decision-making by ensuring the reasoning behind every diagnosis is transparent and interpretable.



This project is a super cool, scaled-down version of Ray-Ban smart glasses—minus the actual glasses (because who needs those, right?). While it might be hard to believe I pulled this off, I had a little help from my talented friend. But hey, I was the one directing the show.  So yes, this project has my vision (pun intended) written all over it!

[**To see how its done click here!**](https://github.com/faizahkureshi232/imagetospeech)

This project is designed to empower visually impaired individuals by providing real-time audio narration of their surroundings using augmented reality and AI technologies. The system seamlessly combines image processing and speech synthesis for an accessible and intuitive experience.

**Key Features**:

1.  **Real-time Audio Narration**:

    *   Utilized **Google Text-to-Speech** to convert visual inputs from augmented reality glasses into clear and concise audio outputs with **95% accuracy**.

    *   Enabled visually impaired users to receive immediate and accurate descriptions of their environment, improving mobility and independence.

2.  **Enhanced Image Captioning**:

    *   Employed **InceptionV3** to extract features from images for high-quality processing.

    *   Integrated these features with an **LSTM model** enhanced by **GloVe embeddings**, achieving a **92% accuracy** in generating captions.

    *   Improved caption generation accuracy by **30%**, ensuring precise and contextually relevant descriptions for real-world scenarios.

3.  **Impact and Accessibility**:

    *   Delivered a robust solution for visually impaired users, bridging the gap between visual and auditory information.

    *   Enhanced accessibility by combining cutting-edge AI with practical usability in real-world environments.

This project demonstrates the potential of AI to address real-world challenges, providing visually impaired individuals with an innovative tool for enhanced interaction and independence.



Speech-enabled Image Narration for the Visually Impaired

DoctorLRP

Imagine giving elevators a sixth sense—this system does just that. Using real-time sensors and ML, it predicts when maintenance is due before things go south. It’s smarter than your average maintenance guy and works 24/7 without a coffee break.Safety, efficiency, and no awkward breakdowns—what’s not to love?

[**To see how its done click here!**](https://github.com/faizahkureshi232/Predictive_maintenance)

This project focuses on enhancing elevator reliability and safety through a smart predictive maintenance system. By integrating sensors and machine learning, the system ensures timely maintenance, preventing unexpected breakdowns and reducing downtime.

**Key Features**:

1.  **Data Collection and Integration**:

    *   Real-time data collection using sensors such as accelerometers, IR, DHT (temperature and humidity), and sound sensors.

    *   Monitored key elevator components, including environmental conditions, steel rope wear, and brake speed, to gather actionable insights.

2.  **Predictive Model Development**:

    *   Built a predictive maintenance model using the Random Forest algorithm, achieving a 95% accuracy rate for service date forecasts.

    *   Leveraged sensor data to identify early warning signs of component wear and predict maintenance needs.

3.  **System Integration**:

    *   Developed a Flask server connected to an Arduino for seamless data transmission and processing.

    *   Built a real-time frontend application to display component health, environmental conditions, and predicted maintenance schedules.

4.  **Impact and Results**:

    *   Reduced elevator downtime by 30% through proactive maintenance scheduling.

    *   Enhanced safety by identifying and addressing maintenance needs before failures occurred.

    *   Improved operational efficiency and service reliability in elevator systems.

This project demonstrates the potential of combining IoT sensors, machine learning, and web technologies to revolutionize maintenance strategies in industrial and commercial systems.



Imagine a security system so smart, it spots trouble before your nosy neighbor does. With real-time alerts, location tracking, and even a friendly Telegram message to authorities, this project is the ultimate tattletale for crime. Plus, it works just as well at night—because criminals don’t respect bedtime!

[To see how its done click here!](https://github.com/faizahkureshi232/violence-detection)

Alertify is a cutting-edge surveillance system designed to detect and report violent activities in real time, ensuring faster responses and enhanced public safety. It combines advanced machine learning, computer vision, and cloud analytics to create a reliable and efficient solution for monitoring high-risk areas.

**Key Features**:

1.  **Violence Detection**:

    *   Achieved **95% accuracy** in detecting violent incidents, using a fine-tuned **MobileNetV2** model with a custom self-learning rate algorithm.

    *   Automatically alerts authorities via Telegram, providing critical details such as crime location, time, and images for immediate action.

2.  **Enhanced Nighttime Detection**:

    *   Integrated **Deep Sort tracking** to improve object tracking and optimize nighttime detection using computer vision techniques.

    *   Achieved a **30% boost** in low-light accuracy, ensuring reliable performance regardless of lighting conditions.

3.  **Cloud Expertise and Data Processing**:

    *   Leveraged **AWS Data Analytics** and **Big Data tools** during an internship to streamline real-time data processing.

    *   Enhanced system responsiveness by efficiently handling large-scale surveillance data.

4.  **Efficiency Improvements**:

    *   Increased model efficiency by **25%** through optimized algorithmic design, ensuring quick and accurate incident detection.

Alertify doesn’t just keep an eye out—it ensures authorities are always in the loop, whether it’s day or night. With its advanced features and smart integrations, this system is the silent guardian every community needs.


Violence Detection

Predictive Maintenance for Elevators

Projects

Ever wondered how AI chatbots, autocomplete, and text generators seem to "understand" and respond like humans? The magic lies in Large Language Models (LLMs), the unsung heroes behind this linguistic wizardry. They're not psychic, but their ability to mimic human conversation, translate languages, or even write poetry can make them feel like they’ve got a direct line to your brain.

Let’s unravel the mystery of LLMs, understand how they work, and explore why they’re so good at pretending to be Shakespeare—or you after three cups of coffee.

## **What Are LLMs?**

In plain terms, LLMs are deep learning models trained on a massive amount of text data. They predict the next word in a sequence based on the words that came before it. Sounds simple? Well, imagine predicting the next word in a complex sentence like, "Quantum physics is..."—it's not just about common phrases but understanding context, meaning, and nuance.

### **A Quick Rundown of Their Abilities:**

1.  **Text Generation**: Writing essays, poems, or code.

2.  **Translation**: Turning "Hola" into "Hello."

3.  **Summarization**: Condensing a 10-page paper into a paragraph.

4.  **Question Answering**: Responding to "Why is the sky blue?"

5.  **Sentiment Analysis**: Decoding whether a review is glowing or scathing.

## **The Building Blocks of LLMs**

Think of an LLM as a very curious toddler learning from every book, conversation, or tweet it encounters. Here’s how it learns and operates:

### **1. Training on Massive Data**

LLMs are trained on terabytes of text—everything from Wikipedia and books to Reddit posts (yes, even your random comments). They learn:

*   **Grammar and Syntax**: The rules of language.

*   **Context**: What words mean in different situations.

*   **World Knowledge**: Facts and patterns about the real world.

Imagine a model reading every book in existence—it won’t "remember" them but will grasp general patterns and concepts.

### **2. Tokenization**

To an LLM, language is broken down into chunks called "tokens." A token can be a word, part of a word, or even a character. For example:

*   Sentence: "I love AI."

*   Tokens: \["I", "love", "AI", "."]

This tokenization helps the model process text numerically.

### **3. Transformer Architecture**

At the heart of an LLM lies the **transformer**, a neural network that revolutionized NLP. Here’s why it’s awesome:

*   **Attention Mechanism**: It focuses on the most relevant parts of the input text. If you say, "I went to Paris, and it was beautiful," the model knows "it" refers to Paris.

*   **Context Awareness**: It doesn’t just look at nearby words but considers the whole sentence, paragraph, or even document.

This is what makes models like GPT-4 or BERT so powerful—they understand context like a seasoned editor.

## **How Do LLMs Generate Text?**

Generating text is where the real magic happens. Here’s the process:

1.  **Input**: You give the model a prompt, e.g., "Write a poem about AI."

2.  **Encoding**: The model tokenizes your input and processes it through its transformer layers.

3.  **Prediction**: It calculates probabilities for all possible next tokens. For "AI is," it might predict:

    *   50%: "amazing"

    *   30%: "the future"

    *   20%: "overhyped"

4.  **Output**: It picks the token with the highest probability (or adds randomness for creativity) and repeats the process until it completes your request.

## **Why Are LLMs So Good?**

### **1. Scale**

LLMs like GPT-4 have billions of parameters—think of parameters as tiny switches that adjust to fine-tune the model’s understanding. More parameters = better comprehension (but also more processing power).

### **2. Transfer Learning**

Instead of training from scratch, LLMs are pre-trained on vast amounts of general data and fine-tuned for specific tasks. For example:

*   Pre-training: Learning general language rules.

*   Fine-tuning: Adapting to legal, medical, or technical jargon.

### **3. Self-Attention**

The transformer’s attention mechanism means it doesn’t just process inputs sequentially but focuses on the most relevant parts, making responses coherent and nuanced.

## **Inner Workings: Under the Hood**

Let’s geek out for a second:

### **1. Layers and Neurons**

An LLM consists of multiple layers of neurons. Each layer extracts higher-level features from the input. For example:

*   Lower layers understand basic grammar.

*   Middle layers grasp sentence structure.

*   Higher layers get the broader context.

### **2. Probabilistic Nature**

LLMs don’t "know" answers—they guess based on probabilities. If you ask, "Who wrote Hamlet?" it doesn’t retrieve a stored fact but predicts "Shakespeare" because that’s the most statistically likely answer.

## **Limitations of LLMs**

Even though they seem super smart, LLMs have their quirks:

1.  **Context Limits**: They can only process so much text at once (e.g., 4,000 tokens in some models).

2.  **Training Bias**: They reflect the biases in their training data.

3.  **Overconfidence**: LLMs will sometimes confidently give you incorrect answers—like a friend who insists 2+2=5.

## **Applications of LLMs**

Here’s where LLMs shine:

*   **Model Building and Training**: Writing and debugging code for machine learning pipelines.

*   **Customer Support**: Powering chatbots that respond like humans.

*   **Content Creation**: Generating blog posts, product descriptions, or even scripts.

*   **Healthcare**: Assisting doctors by analyzing medical records or suggesting diagnoses.

## **The Future of LLMs**

The potential for LLMs is enormous:

*   **More Efficiency**: Reducing resource consumption while scaling performance.

*   **Better Fine-Tuning**: Customizing models for specific industries.

*   **Multimodal Models**: Combining text, images, and videos for richer outputs.

As LLMs evolve, they’ll move beyond text to power everything from virtual reality assistants to real-time translators.

## **Final Thoughts**

Large Language Models are the ultimate multitaskers of AI, capable of everything from generating poetry to aiding scientific research. While they aren’t perfect, their rapid advancements are a testament to the power of combining vast data with cutting-edge technology.

So next time you chat with an AI or get a surprisingly accurate autocomplete suggestion, remember—you’re witnessing the power of LLMs in action. And who knows? Maybe one day, they’ll be writing blogs like this on their own. Oh wait, they already are!


LLMs Unboxed: How AI Talks Like Us (and Sometimes Better!)

Docker isn’t just a buzzword your tech-savvy colleague throws around; it’s a game-changer for anyone working in AI/ML. It’s like having a magic box that keeps your dependencies, tools, and environment conflicts under control. Let’s dive into what Docker is, why it’s awesome, and how to use it for training models without pulling your hair out.

## **What is Docker and Why Should You Care?**

Docker is like a Tupperware container for your code—it packages everything you need (code, libraries, dependencies, etc.) into a neat little box called a container. Whether you’re running your model on your laptop or a cloud GPU instance, Docker ensures it behaves the same way everywhere. No more “but it works on my machine!” excuses.

**Why use Docker for model training?**

*   **Consistency**: Same environment everywhere—be it your dev laptop, staging server, or production cloud instance.

*   **Portability**: Your model can travel anywhere like a tech-savvy backpacker.

*   **Isolation**: Keeps dependencies from fighting like siblings in the backseat.

*   **Scalability**: Easily scale your model training to larger, beefier machines.

## **Getting Started: The Basics**

### **1. Install Docker**

First, you’ll need to install Docker. Head over to [Docker's official site](https://www.docker.com) and grab the version for your OS. It’s like downloading Spotify, but for containers instead of playlists.

### **2. Understand Images and Containers**

*   **Images**: Think of these as recipes. They define everything your application needs.

*   **Containers**: These are the meals you cook from the recipe—an image running on your machine.

### **3. Write a Dockerfile**

A `Dockerfile` is like your secret recipe. Here’s an example tailored for ML model training:

```
# Use an official Python base image
FROM python:3.9-slim
```

```
# Install system-level dependencies
RUN apt-get update && apt-get install -y git wget
```

```
# Install Python libraries
RUN pip install numpy pandas tensorflow keras scikit-learn
```

```
# Set the working directory
WORKDIR /app
```

```
# Copy your project files into the container
COPY . .
```

```
# Run the training script
CMD ["python", "train.py"]
```

**What’s happening here?**

1.  We start with a base image (Python 3.9).

2.  Install system and Python dependencies.

3.  Set a working directory.

4.  Copy your code into the container.

5.  Define the command to run your training script.

## **Model Training in Docker**

### **1. Build the Docker Image**

Run this command to build your image:

```
docker build -t my-model-training .
```

### **2. Run a Container**

Launch a container from your image:

```
docker run --rm -v $(pwd):/app my-model-training
```

*   The `-v` flag mounts your current directory into the container so you can save output models.

### **3. GPU Acceleration (for Deep Learning Models)**

Training models on CPUs is like running a marathon in flip-flops. If you’ve got a GPU, use it! Make sure to install [NVIDIA Docker](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html) and modify your `Dockerfile` to include GPU drivers.

Run the container with GPU support:

```
docker run --gpus all --rm -v $(pwd):/app my-model-training
```

## **Advanced Tricks: Docker Like a Pro**

### **1. Multi-Stage Builds**

Keep your images lean and mean with multi-stage builds:

# First stage: Build environment

FROM python:3.9 as builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Second stage: Slim runtime

```
# First stage: Build environment
FROM python:3.9 as builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Second stage: Slim runtime
FROM python:3.9-slim
WORKDIR /app
COPY --from=builder /app .
CMD ["python", "train.py"]
```

### **2. Docker Compose for Complex Workflows**

If you’re running multiple services (e.g., training + database + logging), use Docker Compose to orchestrate them. Example `docker-compose.yml`:

```
version: '3.8'
services:
  model_training:
    build: .
    volumes:
      - .:/app
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              capabilities: [gpu]
```

Run everything with one command:

```
docker-compose up
```

## **Common Pitfalls (and How to Avoid Them)**

1.  **Big Images**: Your Docker images don’t need to weigh more than your laptop. Use slim base images and avoid unnecessary packages.

2.  **Dependency Hell**: Use pinned versions for libraries to avoid mismatches.

3.  **File Sync Issues**: Mount volumes (`-v`) carefully, especially when dealing with model outputs.

4.  **Debugging Woes**: Use `docker exec -it <container_id> bash` to jump inside a running container for debugging.

## **My Experience: Model Building in Docker**

When I first started using Docker for model training, I expected magic but ended up staring at errors for hours. After some trial and error (and several cups of coffee), it became my best friend. I’ve trained complex ML models, used Docker to scale on cloud GPUs, and even collaborated with teammates seamlessly—Docker made it all possible.

The best part? Once I set up my Docker environment, I never had to hear, “It doesn’t work on my machine” again.

## **Conclusion: Why Docker is a Must-Have**

Docker simplifies everything—dependency management, environment consistency, scaling, and collaboration. It’s not just a tool; it’s a lifestyle. Whether you’re building a tiny linear regression model or training a transformer on GPUs, Docker has got your back.

So, grab your favorite caffeinated beverage, write that `Dockerfile`, and let the containers do the heavy lifting. Your models—and your sanity—will thank you!


Docker Diaries: Training Models Without Losing Your Sanity

### [**Paper Link**](https://ieeexplore.ieee.org/abstract/document/10426217?casa_token=Ggz_mt3wwhEAAAAA:Av1ZxKoju2YHRt5zzf25a1xLRVKSVqxcXg2vkUs2bhbsGo-m-pzUdPvS9BL3-12uFgbkLL4WWdDjwYs)

The paper explores a secure and efficient method for cloud storage that uses a multi-authority approach to manage access control. Here’s the breakdown:

### **Why is This Important?**

Cloud storage is convenient, but it’s riddled with security and privacy concerns, especially when data access depends on centralized authorities. Traditional methods often fail when it comes to revoking access or managing user-specific encryption keys efficiently. This paper tackles these challenges with a smarter, decentralized system.

### **What’s the Big Idea?**

The core idea is to use **multi-authority CPABE (Ciphertext Policy Attribute-Based Encryption)**, where:

1.  **Multiple Authorities Share Control**: No single entity has full control. Instead, various attribute authorities manage specific attributes and keys.

2.  **Threshold Secret Sharing**: A clever (t;n) mechanism ensures that keys are generated securely and require collaboration among multiple authorities.

3.  **Dynamic and Secure Access**: Users and attributes can be dynamically added or revoked without breaking the system or needing complete re-encryption.

### **How Does It Work?**

*   Data owners define access policies and encrypt their data accordingly.

*   Attributes (e.g., user roles or permissions) are distributed across multiple authorities.

*   The system uses a combination of efficient encryption, decryption, and revocation methods to make access fast and secure.

### **Why is It Better?**

*   **No Single Point of Failure**: The decentralized design avoids bottlenecks and increases reliability.

*   **Efficiency**: Encryption and decryption times are significantly reduced compared to older methods like FH-CPABE.

*   **Scalability**: Works well with large-scale systems by balancing tasks among multiple authorities.

### **The Results**

Through simulations, the proposed system outperformed traditional approaches in:

1.  **Time Efficiency**: Encryption and decryption times increased only slightly, even with more attributes or larger files.

2.  **Storage Optimization**: Consumed less storage space for attributes and files.

3.  **Security**: Improved attribute revocation and dynamic membership handling without compromising data safety.

### **Why Should You Care?**

This method is a practical solution for organizations looking to manage data securely in distributed cloud systems. It ensures data privacy, handles revocations smoothly, and avoids the inefficiencies of centralized models. If cloud storage is a puzzle, this approach feels like solving it with all the right pieces in place.


Multiauthority Cloud Storage with Secure and Efficient Attribute-Based Access Control

Posts

### [**Paper Link**](https://dl.acm.org/doi/10.1145/3639233.3639343)

### **The Problem**

In the fast-paced world of financial journalism, platforms like Bloomberg Terminal are flooded with articles every day. While factual news is critical for market decisions, editorial and opinion pieces often add noise. Identifying and separating editorial content is essential to improve the user experience and ensure precise financial analysis.



### **Our Solution**

To tackle this, we developed an NLP-based framework to classify financial news articles into two categories: Regular (factual) and Non-Regular (opinion, editorial). Our approach leverages advanced machine learning and deep learning techniques to handle linguistic nuances and overcome the challenges of imbalanced datasets.



### **Our Approach**

1.  **Data Collection and Preparation**:

    *   We worked with data from 95 prominent news sources, focusing primarily on articles from 2018–2019.

    *   Categories like op-eds, editorials, and opinions were merged into a single "Non-Regular" class, addressing the dataset's inherent imbalance.

    *   Preprocessing included cleaning text, removing irrelevant elements, and extracting key linguistic features.

2.  **Feature Engineering**:

    *   We extracted attributes like sentiment scores (VADER), grammatical structures (POS tags), and text patterns to enrich the dataset.

    *   Entity recognition and feature correlation analysis revealed unique differences between Regular and Non-Regular articles.

3.  **Model Development**:

    *   Starting from Logistic Regression as a baseline, we trained models like Decision Trees, LightGBM, and deep learning architectures such as BiLSTMs, BERT, and XLNet.

    *   For BERT and XLNet, we tested different configurations and sequence lengths (64–512 words) to optimize performance.

4.  **Evaluation and Validation**:

    *   Metrics like Macro F1 Score and Matthews Correlation Coefficient ensured fair evaluation despite class imbalances.

    *   Zero-shot testing with data from a Canadian news source validated the models’ ability to generalize across unseen datasets.



### **Key Achievements**

1.  **Performance**:

    *   XLNet and BERT emerged as the top performers, with Macro F1 Scores of 0.930 and 0.932, respectively.

    *   Even Logistic Regression with TF-IDF performed competitively, offering a resource-efficient alternative for lower computational setups.

2.  **Generalization**:

    *   The models successfully classified articles from unseen sources, proving their adaptability to new datasets with lexical and topical differences.

3.  **Insights**:

    *   Regular articles leaned heavily on facts, reflected by higher mentions of numbers and proper nouns.

    *   Non-Regular articles showed greater use of descriptive elements like adjectives and adverbs, highlighting their opinionated nature.



### **Why This Matters**

Our work bridges the gap between content curation and financial analysis, making it easier for professionals to focus on actionable insights. Beyond finance, this framework can pave the way for detecting media bias, misinformation, and sentiment trends across industries.



### **What’s Next?**

1.  **Multi-Class Classification**:
    We aim to refine classification further by distinguishing subcategories like op-eds, editorials, and guest pieces.

2.  **Paragraph-Level Analysis**:
    By diving deeper, we want to differentiate factual and opinionated content within individual articles.

3.  **Sentiment and Topic Analysis**:
    Exploring emotional tones and trending topics in financial news will add an additional layer of insight.

4.  **Fake News Detection**:
    Using similar methodologies, we plan to expand into identifying misinformation and political bias in media.



This work demonstrates the power of NLP and AI in addressing real-world challenges in journalism, improving precision, and ensuring the integrity of financial news consumption.



I’m Faizah,an AI enthusiast, problem-solver, caffeine-fueled coder, and a proud owner of way too many Ongoing side projects.

DoctorLRP

Predictive Maintenance for Elevators

Speech-enabled Image Narration for the Visually Impaired

Docker Diaries: Training Models Without Losing Your Sanity

Empowering Precision in Financial News: A Revolution in Editorial Classification through Cutting-Edge Natural Language Processing

LLMs Unboxed: How AI Talks Like Us (and Sometimes Better!)

Got an interesting project? Tell me more...💬

Home

I’m Faizah,an AI enthusiast, problem-solver, caffeine-fueled coder, and a proud owner of way too many Ongoing side projects.

DoctorLRP

Predictive Maintenance for Elevators

Speech-enabled Image Narration for the Visually Impaired

Docker Diaries: Training Models Without Losing Your Sanity

Empowering Precision in Financial News: A Revolution in Editorial Classification through Cutting-Edge Natural Language Processing

LLMs Unboxed: How AI Talks Like Us (and Sometimes Better!)

Got an interesting project? Tell me more...💬