DEV Community: Hassan Ahmed

Fine-Tuning DeepSeek-R1 for Medical QA Using LoRA + Chain-of-Thought

Hassan Ahmed — Thu, 17 Jul 2025 11:15:38 +0000

Just published a step-by-step guide on how I fine-tuned DeepSeek-R1 to handle medical question answering using LoRA and chain-of-thought prompting.

✅ Lightweight fine-tuning with Unsloth
✅ Clinical reasoning dataset
✅ Before vs. after results that actually show improvement

Read the full post here:
👉 https://medium.com/@hassanahmed.dev1/fine-tuning-deepseek-r1-for-medical-question-answering-using-lora-d5f74e747e98

Feel free to check out the GitHub repo too!

machinelearning #llm #genai #ai #deeplearning #medtech #huggingface #transformers

Natural Language to SQL: University Student Data Query App with LLMs

Hassan Ahmed — Sat, 12 Jul 2025 06:52:48 +0000

I recently built a small project that lets you query a university student database using natural language instead of SQL.

What it Does

You can type queries like:
Show all students in Data Science

The app uses a large language model (LLaMA 3 via Groq) to convert your plain-English query into SQL, runs it on a local SQLite database, and shows the results in a simple web UI built with Streamlit.

Why Build This?

I wanted to explore how language models can make databases more accessible for people without SQL knowledge. This also gave me hands-on experience integrating LLMs with backend databases and building a full-stack app.

Tech Stack

Python
Streamlit for the UI
LangChain for prompt management
Groq API for fast LLaMA 3 inference
SQLite for the database

How It Works

User enters a natural language query in the UI
LangChain structures a prompt for the LLM
Groq’s LLaMA 3 model generates SQL from the query
SQLite executes the SQL query
Results display in the web interface

Check It Out

You can find the full source code here:
https://github.com/Hassan123j/Natural-Language-to-SQL-University-Student-Data-Query-App

Feedback and contributions are welcome!

I Built a CNN to Detect Skin Cancer from Images (Beginner ML Project)

Hassan Ahmed — Tue, 01 Jul 2025 12:33:00 +0000

I Built a CNN to Detect Skin Cancer from Images (Beginner ML Project)

Hey everyone 👋

Just wanted to share a machine learning project I recently built as part of my learning journey. It's a basic skin cancer detection model using a Convolutional Neural Network (CNN). The model classifies skin lesion images as benign or malignant, and I tested it locally with a Streamlit app.

Why I Picked This Project

I’m still learning machine learning, and I wanted to try something practical something where I could take an idea, build a model, and test it with real images. Skin cancer is a serious health issue, and early detection helps a lot, so I thought this would be a good starting point for a classification task.

⚠️ Disclaimer: This is an educational project only not for real medical use.

Tools I Used

Python
TensorFlow + Keras
Streamlit
Pillow / NumPy
Jupyter Notebook

What the Model Does

Loads a skin lesion image
Preprocesses it (resize, normalize)
Predicts if the image is benign or malignant
Shows the result in a local Streamlit interface

CNN Architecture (Simplified)

model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(224, 224, 3)),
    MaxPooling2D((2, 2)),
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),
    Conv2D(128, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),
    Flatten(),
    Dense(128, activation='relu'),
    Dense(1, activation='sigmoid')
])

Trained with binary cross-entropy since it's a binary classification task.

Prediction Function (Streamlit)

def predict_skin_cancer(image_path, model):
    img = image.load_img(image_path, target_size=(224, 224))
    img_array = image.img_to_array(img) / 255.0
    img_array = np.expand_dims(img_array, axis=0)

    prediction = model.predict(img_array)
    return "Malignant" if prediction > 0.5 else "Benign"

How It Looks

The Streamlit interface is basic — upload an image, and it shows the prediction.

What I Learned

How CNNs work for image classification
Preprocessing is super important
Saving and loading trained models
How to create quick tools with Streamlit for testing models

Future Improvements

Better dataset (mine was small)
Try transfer learning (e.g. MobileNet or EfficientNet)
Add Grad-CAM for model explainability
Deploy the app online (Streamlit Cloud or Hugging Face Spaces)

🔗 GitHub Repo

Full code is here if you want to check it out or test it locally:
👉 https://github.com/Hassan123j/Skin-cancer-detection-using-CNN

If you're learning ML like me, feel free to reach out, ask questions, or give feedback. I'd love to hear from others doing similar stuff!

Building a CKD Risk Predictor with Streamlit and Gradient Boosting

Hassan Ahmed — Tue, 24 Jun 2025 14:32:00 +0000

As a student exploring machine learning, I decided to build a project that predicts the risk of Chronic Kidney Disease (CKD) based on patient data. I wanted to create something simple but practical, so I combined a Gradient Boosting model with a Streamlit app to make it interactive and easy to test.

This post is a walkthrough of how I built the project, the tools I used, and how you can run it on your machine.

What the App Does

The app takes some basic clinical inputs, like blood pressure, serum creatinine, and hemoglobin, and predicts whether the patient might be at risk for CKD. It's built using a Gradient Boosting Classifier model and uses Streamlit to create a simple web interface.

I’m still learning, so it’s not a production-level tool, but it works for the purpose of learning and experimenting with how ML models can be used in real-world applications.

Tech Stack

I kept things simple:

Python
scikit-learn for machine learning
pandas and NumPy for data handling
Streamlit for the web app
joblib for saving and loading models

How It Works

Model: I trained a Gradient Boosting Classifier on a dataset of clinical records
Data: The dataset (kidney_disease.csv) includes patient info like blood pressure, creatinine levels, and other factors
Preprocessing: I handled missing data, scaled the features, and encoded categorical variables
App: The Streamlit app takes input from the user, runs it through the model, and shows a prediction

Running It Locally

If you want to try it yourself, here’s how you can run it locally:

Clone the repository:

   git clone https://github.com/Hassan123j/Chronic-Kidney-Disease-CKD-Predictor-App.git
   cd Chronic-Kidney-Disease-CKD-Predictor-App

Set up a virtual environment:

   python -m venv venv
   source venv/bin/activate      # On Windows: venv\Scripts\activate

Install the dependencies:

   pip install -r requirements.txt

Run the app:

   streamlit run app.py

If the model files (model_gbc.pkl and scaler.pkl) are missing, you can regenerate them by running the Jupyter notebook CKD Model.ipynb.

Project Structure

Here’s how the project is organized:

.
├── app.py               # Streamlit app
├── CKD Model.ipynb      # Model training notebook
├── kidney_disease.csv   # Dataset
├── requirements.txt     # Python dependencies
└── models/
    ├── model_gbc.pkl    # Trained model
    └── scaler.pkl       # Feature scaler

Next Steps

As a learner, I’m planning to improve this project in a few ways:

Add explainability to the model with SHAP or LIME
Deploy it online, maybe using Streamlit Cloud
Improve the UI to make it more user-friendly
Explore other ways to handle missing data and scale the model for better accuracy

GitHub Repo

You can find the full code and instructions here:
GitHub - Chronic Kidney Disease Predictor

Final Thoughts

This was a fun project that helped me practice both machine learning and web development. I learned a lot about how to handle datasets, train models, and build a simple interactive app. It’s definitely not perfect, but it was a good starting point, and I plan to continue improving it as I learn more.

If you have any feedback or suggestions, feel free to reach out. Also, if you’re working on similar projects, I’d love to hear about them!

Built a Legal PDF Question-Answering Tool with AI (RAG + Streamlit)

Hassan Ahmed — Mon, 23 Jun 2025 04:14:48 +0000

Hey everyone,

I put together a small project that lets you upload legal PDFs and ask questions about them. The AI gives you answers and explains how it got there, so it's not just spitting out random stuff.

If you've ever had to read through a long legal document and thought, “I wish someone could just explain this part,” this might help.

You can check out the demo here:
https://shorturl.at/tZoEu

What It Does

Upload a legal document (PDF)
Ask natural language questions
Get an AI-generated answer with reasoning
All responses are grounded in the actual content of the document

It’s using Retrieval-Augmented Generation (RAG) under the hood, which just means the AI reads your file before trying to answer your question.

Run It Locally

Requirements

Python 3.8 or higher
Ollama (for generating embeddings)
A Groq API key (for the language model)

Setup

Clone the repo:

git clone https://github.com/Hassan123j/AI-Reasoning-Chatbot.git
cd ai-legal-assistant

Create a virtual environment and install the dependencies:

python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install -r requirements.txt

If you don’t have the requirements.txt file, install manually:

pip install streamlit langchain-groq langchain-community \
langchain-text-splitters langchain-ollama langchain-core \
faiss-cpu python-dotenv

Ollama Setup

Install Ollama and pull the embedding model:

ollama pull all-minilm

Groq API Key

Put it in a .env file:

  GROQ_API_KEY="your_api_key_here"

Or export it in your terminal:

  export GROQ_API_KEY="your_api_key_here"

Add Your PDFs

Make a folder for your documents:

mkdir pdfs

Drop any legal PDFs you want to query into that folder.

Build the Vector Database

This step processes your PDFs into searchable chunks:

python vector_database.py

Launch the App

Start the Streamlit app:

streamlit run frontend.py

This will open up a local web interface. From there:

Upload your PDF
Type a question
Hit Ask

You’ll get an answer and a quick breakdown of how the AI found it.

File Overview

frontend.py: the Streamlit UI
rag_pipeline.py: where the AI logic happens
vector_database.py: breaks down PDFs and builds embeddings
pdfs/: your uploaded documents
vectorstore/: saved vector data for retrieval

Want to Customize It?

Everything is modular. You can:

Swap out the AI model
Change how PDFs are chunked
Tweak the prompt/response format

Just dive into the code and experiment.

Contributions Welcome

If you’ve got ideas, feedback, bug reports, or want to help improve the project:

Fork it
Open an issue
Submit a PR

Here’s the repo:
https://github.com/Hassan123j/AI-Reasoning-Chatbot