DEV Community: OLUWAYEMI FISAYO NATHANIEL

How We Predicted Drug Quantities in Healthcare Using Machine Learning — And Why It Matters

OLUWAYEMI FISAYO NATHANIEL — Wed, 18 Jun 2025 21:05:58 +0000

In healthcare systems, small inefficiencies lead to big problems. One such inefficiency we faced recently involved how drug quantities were being requested, approved, and dispensed across pharmacies and Health Maintenance Organizations (HMOs).

Sometimes patients received too much medication. Other times, too little. This inconsistency created financial waste, delayed treatments, and friction between stakeholders. So, we asked a simple question:

Can we predict how much of a drug should be dispensed — before anyone manually reviews the request?

With the power of ML.NET and historical fulfillment data, we built a predictive engine that made this possible. Here’s how we did it — and why it’s transforming our operations.

🚑 The Business Problem
In many healthtech environments, prescription fulfillment goes something like this:

A patient is prescribed medication.
The health care organization/company submits the request to a partner pharmacy.
The pharmacy dispenses based on the prescription — often guessing or relying on past habits.
health care organization/company manually review some cases, often overriding the quantity.

This process introduces:

Delays in care due to manual reviews
Over-dispensation, which increases operational costs
Under-dispensation, which leads to poor patient outcomes
Data inconsistencies, making it hard to track trends or audit decisions

We needed a solution that brought data-driven consistency into the process — fast, scalable, and reliable.

🧠 Our ML-Based Solution
We used ML.NET to build a machine learning model that predicts the quantity of drugs to be dispensed, based on historical prescription data.

Instead of guessing or manually overriding, the system now gives a smart prediction — instantly — based on similar past transactions.

Our model was trained on thousands of past records that included:

The drug’s dosage
Frequency and duration
Drug strength
The specific name of the drug
Its dosage form (tablet, injection, syrup, etc.)

These fields gave us a rich foundation for pattern recognition. The only field we did not provide the model during prediction was the quantity — that’s what we asked it to predict.

🧠 Our ML-Based Journey
🔹 Starting with AutoML
I initially explored this problem using ML.NET AutoML, which simplified the process of selecting the best algorithm and hyperparameters. With minimal code, I was able to train models on historical data and evaluate their performance quickly.

This approach gave me early insights into:

What features contributed most to prediction accuracy
How regression models responded to healthcare-specific data
The baseline performance I could expect

AutoML was incredibly helpful for prototyping and learning, but I eventually needed more control and flexibility — especially around how features were transformed and how the model integrated with our system.

🔹 Moving to the ML.NET API
To take full control, I transitioned to using the ML.NET API manually. This allowed me to:

Choose and configure the exact model
Define custom pipelines for feature engineering
Handle data preprocessing, model training, and evaluation step-by-step
Save and load the model easily for use in our production API

🔹 Why Poisson Regression?
I selected LbfgsPoissonRegression, a regression algorithm well-suited for count prediction problems — such as predicting quantities (whole numbers) rather than continuous values.

Poisson regression worked particularly well because:

The target (Quantity) is always a positive count
It handles skewed distributions in data better than standard linear regression
It’s optimized for scenarios where the output is based on frequency/intensity — a perfect fit for healthcare dispensing

📊 The Dataset
We trained our model on thousands of historical records containing:

Dose
Frequency
Strength
Duration
DrugName
DosageForm
And the Quantity dispensed (our label)

To prepare the data:

We removed incomplete or duplicate records
Standardized fields like dosage and drug names
One-hot encoded categorical variables (e.g., drug name, dosage form)
Split data into training and testing sets
The Quantity column was not used during prediction — it was the value we wanted the model to learn and forecast.

⚙️ The Engine Behind the Prediction
While the internal implementation involved advanced machine learning (we used a Poisson Regression model — great for count-based predictions), we intentionally designed the system to be:

Fast: Trains on new data in seconds
Portable: Can run inside any .NET service
Accessible: Exposed via a simple web API

Two API endpoints were created:

GET /api/drugquantityprediction/train — trains the model on updated fulfillment data
POST /api/drugquantityprediction/predict — accepts drug details and returns the predicted quantity

This allowed other internal tools — like HMO admin dashboards — to request predictions in real-time.

📊 Results and Business Impact
After integrating this solution into our fulfillment workflow, we saw immediate benefits:

✅ Reduced manual reviews by over 60%
✅ Improved pharmacy compliance — pharmacists now had a clear reference
✅ Increased trust from HMO partners due to transparent predictions
✅ Lower error rates in dispensation, improving patient outcomes
✅ Enabled data-backed auditing of past drug quantity decisions

💬 What Makes This Powerful?
No more guesswork: Instead of relying on memory or inconsistent pharmacy habits, we use historical data to guide decisions.

Smart scaling: The API is stateless and scalable, making it easy to roll out across new partners or platforms.

Localized intelligence: Because we train the model on our own fulfillment history, the predictions are uniquely tailored to our ecosystem.

Simplicity for users: Clinicians and pharmacy staff don’t need to understand machine learning — they just get a recommended quantity, right when they need it.

🔮 What’s Next?
This solution is just the beginning. Here's what we're working on next:

Deploying to Azure App Service for public API consumption
Building a feedback loop to retrain the model as new fulfillment patterns emerge
Adding confidence scoring to flag low-certainty predictions
Enabling multi-drug predictions for combo prescriptions

🤝 Final Thoughts
This project is proof that machine learning doesn’t have to be a buzzword. When applied thoughtfully, it can solve deeply practical problems — like how much medicine someone should receive — and unlock real efficiency for businesses.

It’s also a win for the healthcare ecosystem:

Patients get exactly what they need.
Pharmacies operate with clarity.
HMOs reduce waste and build trust.

If you're building for healthtech in Africa or exploring ML.NET for business problems, I’d love to connect.

Let’s build smarter, faster, and more reliable systems — together.

Mastering ML.net API: How I Leveraged It for High-Performance Model Training & Deployment

OLUWAYEMI FISAYO NATHANIEL — Mon, 17 Mar 2025 17:04:21 +0000

In my last post, I shared how AutoML outperformed my manually implemented ML.NET model in prediction accuracy. But instead of stopping there, I dug deeper.

What if you could achieve even better results while maintaining full control over your model?

That’s exactly what I did. Instead of relying solely on AutoML, I used its insights to train and optimize a high-performance model using ML.NET API and then deployed it as an API for real-world use.

Why ML.NET API Still Gives You an Edge Over AutoML
While AutoML is great for quickly generating models, the ML.NET API SDK gives you the ability to:
Customize feature engineering – Tailor data transformations for better predictions.
Manually fine-tune hyperparameters – Go beyond AutoML’s automatic adjustments for deeper optimization.
Select the right model evaluation metrics – Focus on performance measures that align with real business needs.
Deploy models as APIs for real-time predictions – Making ML solutions practical for enterprise applications.

I applied these principles while working on a healthcare ML solution for accurate drug quantity dispensation for HMOs. Instead of letting AutoML handle everything, I used its insights to strategically fine-tune my ML.NET API implementation—and the difference was huge.

From Model Training to Deployment: The Real-World Impact.
Rather than stopping at model optimization, I exposed the ML.NET model as an API to integrate it into a larger system. This enabled:
Real-time predictive analytics – Ensuring optimal drug dispensation for patients.
Scalability and flexibility – The ML model can be updated and improved without disrupting the system.
Enterprise-ready AI – A structured ML deployment pipeline that integrates seamlessly with healthcare applications.

Key Takeaways for ML Engineers & Developers
AutoML is a great starting point, but understanding ML.NET API lets you optimize beyond its defaults.
Fine-tuning ML models manually gives you control over performance, accuracy, and scalability.
Deploying ML models as APIs makes AI practical and production-ready for enterprise applications.

As I continue my ML.NET journey, I’m excited about how machine learning can drive innovation across industries. If you're passionate about ML.NET, AI in production, or deploying scalable ML models, let’s connect!
Follow for more insights on ML.NET, AI, and .NET development.

Why Did AutoML Beat My ML.NET Model? The Answer Surprised Me!"

OLUWAYEMI FISAYO NATHANIEL — Mon, 24 Feb 2025 15:49:08 +0000

Last week, I shared my journey using ML.NET to build predictive models, highlighting some key challenges and learnings. (Missed it? Check it out https://www.linkedin.com/feed/update/urn:li:activity:7297761239970021376/).

But something interesting happened... 🤔

Despite using the same algorithm (L-BFGS Poisson Regression) in both ML.NET API and AutoML, the AutoML-generated model outperformed my manually implemented one—by a lot.

So, I dug into the AutoML-generated code to uncover what was really happening behind the scenes. Here’s what I found:

While working on a machine learning solution to optimize resource allocation, I implemented L-BFGS Poisson Regression using ML.NET. Initially, my manually implemented model didn’t achieve the expected prediction accuracy.

However, when I tested AutoML-generated models, I noticed a significant difference—better predictions, improved generalization, and optimized hyperparameters.

Curious about this disparity, I analyzed the AutoML-generated code and uncovered key differences in how model evaluation and optimization are handled behind the scenes.

Key Takeaways from My Analysis:

AutoML Does More Than You Think: Unlike the ML.NET API, AutoML optimizes hyperparameters, evaluates multiple models, and fine-tunes configurations, which significantly impacts prediction accuracy.

Flexibility vs. Automation: The ML.NET API gives full control over model selection, hyperparameter tuning, and data preprocessing, but AutoML automates these steps, making it easier to get high-performing models with minimal effort.

Experience Matters: While AutoML gives great results out of the box, understanding the ML.NET API helps you fine-tune models beyond AutoML’s defaults, unlocking even greater performance tailored to your dataset.

Final Thoughts

🔹 AutoML isn’t just a shortcut—it fills in the gaps that most developers wouldn’t optimize manually.

🔹 But knowing how AutoML works under the hood gives you an edge, letting you push ML.NET even further.

🔹 A hybrid approach—leveraging AutoML while refining with the ML.NET API—can deliver highly efficient, production-ready models.

What’s your experience with ML.NET and AutoML? Have you noticed similar differences in model performance? Let’s discuss!

Follow for more ML.NET insights as I continue exploring real-world machine learning applications!

MLNET #MachineLearning #AutoML #DotNet #ArtificialIntelligence #AI #DataScience #DeepLearning #BigData #NeuralNetworks #PredictiveAnalytics #ML #MLInProduction #SoftwareEngineering #TechInnovation #DataDriven #CloudComputing #Azure #DevOps #AIInnovation #AICommunity #FutureOfTech #CareerGrowth #OpenToOpportunities #TechnologyTrends

Leveraging ML.NET to Solve Real-World Problems

OLUWAYEMI FISAYO NATHANIEL — Fri, 21 Feb 2025 00:56:39 +0000

Over the past six weeks, I’ve been on a transformative learning journey with ML.NET, diving deep into how machine learning can be leveraged to solve real-world problems across various industries—all while staying within the powerful .NET ecosystem.

As a .NET engineer, I’ve always been driven by the challenge of solving complex problems with innovative solutions. ML.NET has not only enhanced my technical skill set but has also opened my eyes to the potential of machine learning in applications ranging from healthcare and finance to logistics and retail.

One of the most rewarding challenges I tackled was developing a solution in the healthcare space—focused on accurate drug quantity dispensation to HMOs for end users. The solution I built uses predictive models to ensure that drug quantities are dispensed accurately and efficiently, significantly improving operational processes.

Challenges & Learnings Along the Way
As part of the solution, I experimented with various ML algorithms in ML.NET, working through multiple challenges to achieve optimal accuracy in predicting drug quantities. A few notable challenges included:
Tuning Hyperparameters: Ensuring accurate predictions by adjusting models to get the best Root Mean Squared Error (RMSE) and R-squared (R²) values for different ranges of data sets.
Model Selection: Choosing between algorithms like Regression and Decision Trees, testing their performance on both small and large datasets, and ensuring generalization without overfitting.
Cross-validation: Implementing cross-validation to evaluate model performance across different subsets of data, ensuring robustness and minimizing bias.
A screenshot of the current healthcare solution I deployed shows real-time usage of the ML.NET model—further validating how ML.NET can truly drive impactful solutions.

This project was just the beginning. As I continue to experiment and learn, I’ll be sharing my hands-on experiences in ML.NET, including:
Best practices for working with ML.NET models
Real-world use cases across various industries
Solutions to common challenges like data preprocessing, model training, and evaluation metrics

🔔 Stay tuned! Every week, I’ll be sharing fresh insights, challenges, and success stories from my ML.NET exploration. Whether you're a recruiter, fellow engineer, or machine learning enthusiast, let’s connect and discuss how ML.NET is transforming industries!
Let’s build and innovate together!

MLNET #MachineLearning #DotNet #AI

DataScience #PredictiveAnalytics #HealthcareInnovation #SDCA #FastForestRegression #LbgfsPoissonRegression #CareerGrowth #OpenToOpportunities #ML #RMSE #RSquared #HyperparameterTuning #CrossValidation #DataScienceEngineering #MLInProduction

how to deploy smart contract to the blockchain using scripting

OLUWAYEMI FISAYO NATHANIEL — Tue, 05 Nov 2024 12:36:23 +0000

here are steps on how you can deploy your smart contracts using foundry with scripts
N.B : you must have foundry installed in your local machine

Run Anvil : command for running anvil is - "anvil"
Copy the localhost and paste in command below after --rpc-url

forge script script/DeployContract.s.sol --rpc-url http://127.0.0.1:8545 --broadcast --private-key {PRIVATE_KEY}

our script file will be something like this:

`// SPDX-License-Identifier: SEE LICENSE IN LICENSE
pragma solidity ^0.8.18;

import {Script} from "forge-std/Script.sol";
import {Counter} from "../src/Counter.sol";

contract DeployCounter is Script {
function run() external returns (Counter) {
vm.startBroadcast();
Counter counter = new Counter();
vm.stopBroadcast();
return counter;
}
}`

Your smart contract should now be deployed to the onchain link

Usage of onTap function in a listTile with Drawer

OLUWAYEMI FISAYO NATHANIEL — Thu, 03 Mar 2022 11:45:58 +0000

When making use of an onTap function in a ListTile widget in flutter: Use it this way:
Widget buildListTile(String text, IconData icon, Function() tapHandler) { return ListTile( leading: Icon( icon, size: 26, ), title: Text( text, style: const TextStyle(fontSize: 24, fontWeight: FontWeight.bold), ), onTap: tapHandler, ); }

and not this way:

Widget buildListTile(String text, IconData icon, Function tapHandler) { return ListTile( leading: Icon( icon, size: 26, ), title: Text( text, style: const TextStyle(fontSize: 24, fontWeight: FontWeight.bold), ), onTap: tapHandler, ); }

N.B : Look how i defined the function in both

the second way would run your code into errors while your code would be without errors in the first

Expanded Vs Flexible in Flutter

OLUWAYEMI FISAYO NATHANIEL — Fri, 25 Feb 2022 03:33:48 +0000

Both Creates a widget that controls how a child of a [Row], [Column], or [Flex] flexes.

If you come from a CSS background, this is related to flexbox

The only difference between Expanded and Flexible is Expanded is Flexible that doesnt have a fit property

Example

Flexible:
Flexible( flex: 3, fit: FlexFit.tight,)

Expanded:
`Expanded(
flex: 3
//fit: FlexFit.tight,)

The fit property in Expanded is commented.

Both use flex the property

Using Fold method in dart

OLUWAYEMI FISAYO NATHANIEL — Fri, 25 Feb 2022 03:24:21 +0000

The fold method in dart is used for:
Reducing a collection to a single value by iteratively combining each element of the collection with an existing value

Uses [initialValue] as the initial value, then iterates through the elements and updates the value with each element using the [combine] function, as if by:

var value = initialValue; for (E element in this) { value = combine(value, element); } return value;

The fold method in dart just acts like the reduce method in javascript

Another example of the fold method in dart :
double get totalNetSpend { return groupedTransactionData.fold(0.0, (sum, item) { return sum + (item['amount'] as double); }); }