Forem: hemupadhyay26

Docker Desktop on Windows EC2 Virtualization not supported Requires Nested Virtualization (AWS)

hemupadhyay26 — Sun, 22 Feb 2026 13:35:53 +0000

I was recently working on setting up Docker Desktop on a Windows EC2 instance provided by a client and ran into a virtualization issue that took some time to identify.

Context

Docker Desktop on Windows depends on a virtualization backend (WSL2 or Hyper-V), so hardware virtualization support is a mandatory requirement.

Issue

While enabling the required features, I kept hitting errors indicating that virtualization was not supported on the instance — even though the OS and configuration steps were correct.

Root Cause

On AWS, running Docker Desktop inside a Windows EC2 instance requires nested virtualization, since you’re effectively trying to run a virtualization layer inside a VM.

This is not supported on all instance families.

After digging through the AWS documentation, I found that nested virtualization is currently supported only on:

The issue was resolved after switching the instance to one of the supported families.

Takeaway

If you’re planning to run Docker Desktop on a Windows EC2 instance, check nested virtualization support first — otherwise WSL2/Hyper-V will fail regardless of correct OS-level setup.

This detail is easy to miss because it’s buried quite deep in the documentation, so sharing it here to save someone else the troubleshooting time.

Reference

How Docker Uses the Kernel to Isolate Containers 🐳⚙️

hemupadhyay26 — Fri, 15 Aug 2025 19:50:43 +0000

It’s been over a year since I started working with Docker — building images, running containers, using Docker Compose, mapping ports, and doing all the regular containerization tasks.

But recently, I decided to go deeper.

Not just how to use Docker, but how Docker really works with the kernel.
And honestly, it’s fascinating.

The Kernel: The Real Magic Behind the Scenes

The kernel is the heart of any operating system. It manages processes, memory, networking, and communication — the core plumbing that everything else relies on.

Over the past two decades, the kernel has evolved into a highly optimized, smooth-running foundation for modern computing. And Docker simply taps into that magic using a set of powerful kernel features.

Key Kernel Features Docker Uses

1. `chroot`

chroot changes the apparent root directory for a process, locking it into its own filesystem view. This gives processes a scoped, isolated environment.

2. Namespaces

Namespaces isolate system resources — process IDs, network interfaces, mount points, and more — so each container feels like its own little world.

3. cgroups (Control Groups)

Control Groups limit and allocate CPU, memory, and I/O to containers, ensuring they don’t consume more than their fair share of resources.

Why This Matters

So far, I’ve explored these three features — but Docker uses much more behind the scenes to provide isolation, efficiency, and portability.

Once you understand these fundamentals, it’s much easier to dive into advanced container topics, troubleshoot complex issues, or even appreciate the elegance of how containers achieve their “virtual machine feel” without the heavy overhead.

Must-Watch References 🎥

If you want to understand Docker at a much deeper level, I can’t recommend these enough.
They’re not just good — they’re the kind of content you can binge-watch like your favorite Netflix series.

1️⃣ https://www.youtube.com/watch?v=sK5i-N34im8&t=2795s
2️⃣ https://www.youtube.com/watch?v=8fi7uSYlOdc

After watching these, you’ll gain so much clarity — and from there, you can explore any part of Docker’s internals with confidence.

Fine-Tuning Large Language Models (LLMs): A Complete Step-by-Step Guide

hemupadhyay26 — Sun, 03 Aug 2025 08:38:53 +0000

Fine-tuning a Large Language Model (LLM) lets you adapt an existing AI model to your needs — whether that’s injecting domain knowledge, adjusting tone, or optimizing for specific tasks.

It’s more efficient than training from scratch and can dramatically improve performance for niche use cases.

In this guide, we’ll cover the complete fine-tuning process, from defining goals to deployment.

We’ll also highlight why dataset creation is the most crucial step and how using a larger LLM for filtering can make your smaller model much smarter.

1. Understand Fine-Tuning & Choose the Right Method

Before starting, define your goal:

Do you need a general-purpose assistant or a task-specific expert?
Should the model focus on tone, accuracy, or covering rare edge cases?

Fine-tuning methods:

LoRA (Low-Rank Adaptation) – Updates small trainable matrices; fast and cost-efficient.
QLoRA – LoRA + 4-bit quantization; great for large models on modest hardware.
Full Fine-Tuning (FFT) – Updates all weights; powerful but resource-heavy and risks catastrophic forgetting.
PEFT – Parameter-efficient approaches (including LoRA) that update only a subset of parameters.

💡 Beginner tip: Start with a small instruct model like Llama 3.1 (8B) for faster and cheaper fine-tuning.

2. Prepare a High-Quality Dataset — The Most Crucial Step

Your dataset decides exactly how your model thinks, behaves, and what it knows.

A well-curated dataset will outperform a large, noisy one.

Using a larger LLM to filter and clean your training data can greatly boost results.

Best practices:

Structure as QA pairs or chat-style data.
Generate synthetic data from PDFs, videos, or existing logs.
Filter for accuracy, style, and relevance using a strong LLM.
Remove unnecessary context if it reduces clarity.
Split into training, validation, and test sets.

3. Set Up Your Training Environment

You’ll need:

GPU access (e.g., RunPod with 25GB VRAM)
Copy your dataset to the training environment.

4. Data Loading & Formatting

Load dataset (e.g., with load_dataset from Hugging Face).
Apply chat templates (system, user, assistant roles).
Tokenize text into tokens using the model’s tokenizer.
Batch data based on GPU memory.

5. Fine-Tuning the Model

Steps:

Load base model (e.g., Llama 3.1 8B).
Quantize (QLoRA → 4-bit) for memory savings.
Enable gradient checkpointing.
Define LoRA config:

rank – adapter matrix size.
lora_alpha – scaling factor (often > rank).
lora_dropout – regularization.
target_modules – layers to adapt.
1. Use SFTTrainer with tuned hyperparameters:
num_train_epochs – start low (1–3), increase later.
learning_rate – lower values for precision.
save_steps – checkpoint frequency.
1. Train and monitor:
Loss ≈ 0.55 is healthy.
Token accuracy > 0.9 is ideal.

6. Evaluation & Iteration

Manual: Chat with the model to check style, accuracy, and knowledge.
Automated: Use tools like lm-evaluation-harness or SuperAnnotate.

If results aren’t great:

Improve data quality.
Adjust LoRA parameters.
Train for more epochs.

7. Save & Deploy

Save LoRA adapter files (~100MB).
Deploy locally (e.g., with Ollama) or push to Hugging Face Hub.
For inference:

FastLanguageModel.for_inference(model, max_new_tokens=256)

or:

ollama run <model_name>

8. Advanced Tips

Increase LoRA rank & alpha (e.g., rank 256, alpha 512) for richer updates.
Train for more epochs if data is clean (watch for overfitting).
Always use stronger models for filtering smaller LLM training data.

📚 Resources & Further Reading

🎥 Fine-Tuning Walkthrough (YouTube)
📄 Unsloth Docs – Quantization & Efficient Tuning
📝 IBM: RAG vs Fine-Tuning

💡 Key Takeaway:
Fine-tuning success isn’t just about running a script — it’s data quality + smart parameter choices + iterative refinement.
Your model is only as good as the data you feed it.