What You'll Build

I've spent the last few years running AI workslops for teams and students. One thing I learned: you can watch all the tutorials you want, but until you actually code a model and watch it fail, you won't really understand it. So I put together three concrete AI workslop examples that I've personally led. Each one is self-contained, uses free tools, and tackles a common real-world problem. No fluff — just step-by-step instructions and the gotchas I hit along the way.

Why Hands-On Projects Matter

When I first started learning machine learning, I fell into the trap of over-studying theory. I could explain backpropagation but couldn't build a classifier that actually worked on unseen data. That's why I now design every workslop around a deliverable: by the end of the session, you run a model and see results. The three examples below are my favorites because they cover vision, NLP, and recommender systems — the bread and butter of applied AI.

Non‑consensus insight: Most beginners rush to fine‑tune large models like GPT‑3. I recommend starting with small, custom models (like a shallow CNN) for image tasks. You learn debugging skills that transfer up, not down.

1. Image Classifier with TensorFlow

This workslop builds a dog vs. cat classifier using TensorFlow 2.x and Keras. It's a classic but still the best way to understand convolutional neural networks (CNNs).

What you'll need

  • Platform: Google Colab (free GPU if you enable it)
  • Dataset: Dogs vs. Cats from Kaggle (~25,000 images)
  • Libraries: TensorFlow, matplotlib

Step-by-step walkthrough

1. Load and preprocess data. Use tf.keras.preprocessing.image_dataset_from_directory to resize images to 150×150 and batch them. I normalise pixel values to [0,1].

2. Build a simple CNN. I start with 3 convolutional layers (32, 64, 128 filters), each followed by max‑pooling. Then flatten and a dense layer of 512 units with dropout (0.5). Output: 1 neuron with sigmoid.

3. Train for 10 epochs. Use Adam optimizer and binary crossentropy. On a free T4 GPU, each epoch takes ~2 minutes.

4. Evaluate. You'll likely get ~85‑88% validation accuracy. Not state‑of‑the‑art, but that's the point — you'll see overfitting and learn data augmentation. I always add random flipping and rotation, which pushes accuracy to ~92%.

Personal note: The first time I ran this, I forgot to shuffle the training data. My model predicted “cat” for everything because the first batch was all cats. That mistake taught me more than any tutorial.

2. Conversational Chatbot with Hugging Face

NLP workslops can be daunting, but using Hugging Face Transformers makes it accessible. This example builds a customer‑support chatbot using a distilled GPT‑2 model (DialoGPT-small) fine‑tuned on a custom FAQ dataset.

What you'll need

  • Platform: Colab or local with Python 3.8+
  • Model: microsoft/DialoGPT-small (free from Hugging Face hub)
  • Libraries: transformers, torch

Step-by-step

1. Prepare a small FAQ dataset. I created 50 question‑answer pairs in a JSON file (e.g., “What is your return policy?” → “You can return within 30 days”).

2. Tokenize and format. Use the DialoGPT tokenizer. Each training example is a conversation: [user message, bot response]. I add special tokens to separate turns.

3. Fine‑tune for 3 epochs. Use a small learning rate (5e‑5). On Colab's free GPU, this takes about 30 minutes.

4. Deploy a simple demo. Write a loop that takes user input, generates a response (with max_length=100 and temperature=0.7), and prints it. The result is a coherent bot that answers FAQs reasonably well.

Gotcha: If you don't set a repetition penalty (e.g., repetition_penalty=1.2), DialoGPT tends to repeat itself after 3 turns. I learned this after a demo where the bot kept saying “I'm sorry, I didn't get that” in a loop.

3. Recommendation System with Surprise

For the third workslop, I choose a collaborative filtering recommendation system using the Surprise library. It's a perfect entry point because you don't need deep learning — just matrix factorization.

What you'll need

  • Dataset: MovieLens 100k (free, ~100,000 ratings from 943 users on 1682 movies)
  • Libraries: scikit‑surprise, pandas

Step-by-step

1. Load data. Surprise's built‑in Dataset.load_builtin('ml-100k') handles it.

2. Choose algorithm. I use SVD (Singular Value Decomposition) with 20 latent factors.

3. Train/test split. 80/20 random split. Fit the model and evaluate with RMSE (root mean squared error). Expect RMSE around 0.94.

4. Make recommendations. For a given user, predict ratings for all unrated movies and return top‑10. The result is surprisingly accurate — for user 196, the model recommends “Star Wars” and “The Godfather”.

Non‑consensus insight: Don't obsess over RMSE numbers. A 0.94 RMSE is fine for a prototype. In production, you'll care more about business metrics (click‑through rate, diversity) than pure accuracy. I've seen teams waste weeks trying to squeeze RMSE down by 0.01.

Tools & Cost Breakdown

All three workslops run on free tiers. Here's the exact cost (as of writing):

Workslop Platform GPU Total Cost
Image Classifier Google Colab (free) T4 (optional) $0
Chatbot Colab (free) T4 (optional) $0
Recommender Local / Colab CPU only $0

If you need persistent storage, both Kaggle and Colab offer free tiers with enough disk space for these datasets. For larger datasets, consider Google Drive mounting (also free).

Frequently Asked Questions

I have zero coding experience. Can I still run these AI workslop examples?
I'd recommend at least basic Python and some familiarity with Jupyter notebooks. The examples assume you can install libraries and run cells. If you're starting from scratch, first do a 2‑hour Python tutorial — then come back.
My image classifier only gets 70% accuracy – what am I doing wrong?
Check your preprocessing: are images normalized? Did you use data augmentation? The most common mistake is not shuffling the training data. Also, reduce the learning rate to 0.001 and increase dropout. In my experience, those two changes alone lift accuracy by 5‑10 points.
The chatbot repeats itself after a few exchanges. How do I fix it?
Set repetition_penalty=1.2 and max_new_tokens=50. If that doesn't help, reduce the temperature to 0.6. I also clip the conversation history to the last 2 turns to keep the context short.
Do I need a GPU for the recommender system workslop?
No. Surprise runs entirely on CPU. The MovieLens 100k dataset takes less than 2 minutes to train on an old laptop. GPU would actually be overkill for matrix factorization.
How long does each workslop take from start to finish?
For a group workshop (with explanation), I budget 2‑3 hours per project. If you're working solo and already have the environment set up, you can finish the image classifier in 45 minutes (including training wait). The chatbot takes about an hour because fine‑tuning takes 30 minutes.

These examples have been fact‑checked against the latest library versions and are reproducible at the time of writing. I personally run each one at least once per quarter to catch any deprecations.