DEV Community: Safiullah

"5 Things I Wish I Knew Before Starting My AI Engineering Internship"

Safiullah — Tue, 11 Aug 2026 05:34:06 +0000

Seven weeks into an AI Engineering internship (alongside the IBM Data Science Professional Certificate), I've picked up a few things I genuinely wish someone had told me on day one. None of these are deep technical lessons — they're more about mindset and habits, the kind of stuff that doesn't show up in a syllabus.

If you're about to start something similar, here's what I'd tell past-me.

1. Accuracy going up doesn't always mean the model is getting better

I learned this the hard way while fine-tuning a sentiment analysis model — accuracy kept climbing each epoch, but validation loss was quietly getting worse the whole time. It was overfitting, and I almost missed it because I was only watching one number. Now I check training loss and validation loss together, every time.

2. The "boring" model is sometimes the right one

I expected Random Forest to beat Linear Regression on a house price prediction task. It didn't — Linear Regression won by a solid margin. With a small dataset, the simpler model generalized better. I've stopped assuming complexity equals performance.

3. Transfer learning feels like cheating, in a good way

Building a Cat vs Dog classifier by only training the final layer of a pretrained ResNet18 — instead of a whole network from scratch — felt like skipping steps I was supposed to do the hard way. It's not cheating, it's just how the field actually works. I wish I'd trusted that sooner instead of assuming "real" learning meant building everything from zero.

4. Data cleanup is most of the actual work

Somewhere around week 4 or 5 I realized most of my time wasn't spent tuning models — it was spent understanding, cleaning, and preparing data. That's not the part that gets talked about, but it's the part that actually determines whether anything downstream works.

5. Writing about what you're learning, in public, changes how you learn it

I started documenting these weeks partly for accountability. What I didn't expect was that explaining a concept well enough to write about it forces a level of understanding that just doing the exercise doesn't. If you're on the fence about writing publicly, it's worth it even if nobody reads it.

Final thought

None of this is groundbreaking advice, and honestly most of it I only understood after getting it wrong first. If you're just starting an AI internship, a certificate, or learning ML on your own — you'll probably relearn a few of these yourself, and that's fine. It sticks better that way.

If you've got your own "wish I knew" moment from learning AI/ML, drop it in the comments — genuinely curious what other people's version of this list looks like.

"I Accidentally Overfit My First Fine-Tuned Model — Here's What the Numbers Told Me"

Safiullah — Tue, 11 Aug 2026 04:28:37 +0000

A few weeks ago, while working through the NLP section of my AI Engineering internship, I built a Movie Review Sentiment Analyzer. First I tried a ready-made Hugging Face pipeline — it worked almost too well, near-perfect confidence on every test review. Then I fine-tuned my own DistilBERT model on a small subset of the IMDB dataset, and that's where things got interesting.

Not because it failed — it actually reached 86.2% accuracy. But looking closer at the training numbers, I noticed something that's apparently a very common mistake: overfitting, happening in real time, in my own results. Here's what that looked like and what it taught me.

Part 1: The easy win

I started with Hugging Face's pipeline("sentiment-analysis"), which loads a model already fine-tuned for this exact task. I tested it on 3 sample reviews, and it nailed all three with near-perfect confidence — 0.9999 on a clearly positive review, 0.9998 on a clearly negative one, and 0.9891 even on a mixed, lukewarm review. This made sense: the model had already been trained specifically for sentiment analysis on far more data than I was about to use.

Part 2: Fine-tuning my own model

Next I fine-tuned distilbert-base-uncased myself, on a 2,000-review subset of the IMDB dataset (out of 25,000 available), for 3 epochs. Here's what the training looked like:

Epoch	Training Loss	Validation Loss	Accuracy
1	0.3295	0.4152	84.6%
2	0.2186	0.4945	86.0%
3	0.0539	0.5796	86.2%

At first glance this looks fine — accuracy kept climbing, 84.6% → 86.0% → 86.2%. But look at the other two columns. Training loss dropped hard (0.33 → 0.22 → 0.05), while validation loss climbed every single epoch (0.42 → 0.49 → 0.58).

Part 3: What that actually means

This is a textbook overfitting pattern. The model was getting better and better at the training data — memorizing it, essentially — while getting slightly worse at generalizing to data it hadn't seen. Accuracy still crept up because 2,000 examples aren't much for a model the size of DistilBERT, so it could still improve overall even while starting to overfit underneath.

The likely cause: too little data for too many epochs. With only 2,000 training examples instead of the full 25,000, the model ran out of new patterns to learn within just a couple epochs, and by epoch 3 it was mostly just memorizing.

Part 4: Why this mattered to me

Before this, "overfitting" was a term I understood in theory — training accuracy high, test accuracy low, textbook definition. Seeing it show up in my own loss curves was different. It's one thing to be told a lower training loss doesn't always mean a better model. It's another to watch it happen in your own numbers and realize the model that looked "best" on paper (epoch 3, highest accuracy) was actually the one most at risk of not generalizing well.

If I did this again, I'd either train on the full 25,000-review dataset, stop after epoch 1 or 2, or add early stopping based on validation loss instead of just watching accuracy climb.

Takeaway

The pretrained pipeline outperformed my fine-tuned model, and that's fine — it was trained on far more data for this exact task. But the real value of this project wasn't the accuracy number. It was catching overfitting as it happened, in my own loss curves, instead of just reading about it as a concept.

If you're learning ML too, I'd genuinely recommend printing out your validation loss alongside training loss every epoch — it's a small habit that turns an abstract warning ("watch out for overfitting") into something you can actually see.

That's it for this one. Back to Week 7 (deployment) next — will post an update once the capstone starts.

7 Weeks Into My AI Engineering Internship (While Doing IBM's Data Science Certificate) — Here's What I've Actually Learned

Safiullah — Tue, 11 Aug 2026 04:06:40 +0000

Hey everyone. I'm a CS student at FAST-NUCES in Karachi, and for the past 7 weeks I've been doing two things in parallel: the IBM Data Science Professional Certificate and an 8-week AI Engineering Internship that goes from Python fundamentals all the way to LLMs and deployment.

I wanted to write this partly to keep myself accountable, and partly because when I was starting out, reading other people's honest "here's what I actually struggled with" posts helped me a lot more than polished tutorials did.

So here's a real recap of the last 7 weeks — what I covered, what clicked, and what didn't.

Week 1 — Python for AI & Data Handling
Refreshed Python and got hands-on with NumPy, Pandas, and Matplotlib by building a Student Performance Analyzer on a class dataset. The interesting part wasn't the coding — it was seeing what the numbers actually said: pass rate came out to 93.3%, but the spread in Math scores was wide, clustering heavily at both the low (40s) and high (90s) ends rather than in the middle. Small reminder that "average" can hide a lot.

Week 2 — Machine Learning Fundamentals
Built a House Price Prediction model comparing Linear Regression, Decision Tree, and Random Forest on 200 records. Linear Regression actually won, with an R² of 0.9116 versus 0.86 and 0.85 for the tree-based models. That surprised me a bit going in — I expected Random Forest to dominate — but with only 200 rows, the more complex models didn't have enough data to show their usual advantage. Good early lesson that the "fancier" model isn't automatically the better one.

Week 3 — Deep Learning Basics
First real neural network, built in PyTorch for MNIST digit recognition. A simple 2-hidden-layer feedforward network hit 96.62% test accuracy after just 5 epochs, with training loss dropping from 0.38 to 0.09. Backpropagation finally clicked here — not the math itself, but watching the loss curve flatten out epoch by epoch made the "the model is learning" idea feel real instead of abstract.

Week 4 — Computer Vision
Moved to OpenCV and PyTorch for a Cat vs Dog classifier using transfer learning on a pretrained ResNet18 — only training the final layer instead of the whole network from scratch. This is where transfer learning really clicked for me: reusing a model already trained on 1.2 million images and just adapting the last layer felt like a shortcut that shouldn't work as well as it does.

Week 5 — Natural Language Processing
Built a Movie Review Sentiment Analyzer two ways: a ready-made Hugging Face pipeline (99%+ confidence out of the box), and my own fine-tuned DistilBERT on a 2,000-review IMDB subset, which reached 86.2% accuracy. The more useful result was actually a mistake — training loss kept dropping each epoch (0.33 → 0.05) while validation loss went up (0.42 → 0.58). Textbook overfitting, and the first time I actually saw it happen in my own numbers instead of just reading about it.

Week 6 — LLMs & Prompt Engineering
Explored how LLMs work under the hood and spent time experimenting with prompt design — small changes in phrasing or structure often changed the output more than I expected. Also got introduced to RAG (Retrieval-Augmented Generation) by building a Document Q&A Assistant, which combines a retrieval step (finding relevant chunks of a document) with generation (the LLM answering based on those chunks) instead of relying purely on what the model already "knows."

Week 7 — AI Engineering & Deployment (current)
Currently working with FastAPI and ChromaDB to build a Knowledge Base Chatbot API — essentially taking the RAG concept from last week and turning it into something that runs as an actual service instead of a notebook. This has been a different kind of learning curve: less about model accuracy, more about structuring an API properly, handling embeddings storage in a vector database, and thinking about how a real user (or another piece of software) would actually call this thing.

Wrapping up

That's the honest version of my last 7 weeks — some weeks went smoother than others, and the overfitting mistake in Week 5 probably taught me more than the weeks that went right. One more week to go before the capstone project, so I'll be posting an update once that's done.

If you're doing something similar — a certificate, an internship, or just learning ML/AI on your own — I'd genuinely like to hear how it's going for you. Feel free to drop a comment.