Build an AI Talking Avatar

Animate a portrait photo with your own expressions using LivePortrait.

Introduction

30 Second Summary

AI-generated talking avatars are everywhere. Video platforms, customer support bots, and marketing tools use them to create realistic talking-head videos from a single photo.

In this project, you will set up and run LivePortrait, an open-source AI model, on your Mac to animate a portrait photo of yourself using motion transfer from a driving video.

What You'll Build

You'll configure a local AI environment and use LivePortrait to transfer your facial movements from a recorded video onto a still portrait photo, producing a realistic animated talking-head video.

By the end of this project, you'll have:

A fully configured local AI environment on your Mac with Miniconda, FFmpeg, and all required dependencies.
A working demo video generated from LivePortrait's built-in examples, proving the system runs on your machine.
A personalized talking avatar video using your own face and expressions, powered by motion transfer.
Secret Mission: Launch the Gradio web UI and experiment with retargeting controls to fine-tune lip movement, eye gaze, and head pose independently.

Are there any prerequisites?

None. This project includes full setup instructions for every tool you need. You just need a Mac with Apple Silicon (M1 or later) and at least 16GB of RAM.

Install Your Tools

Before you can run any AI models locally, your Mac needs the right tools installed.

In this step, you'll install three things: a Python environment manager called Miniconda, a video processor called FFmpeg, and a version control tool called Git LFS.

In this step, get ready to:

Install Miniconda for managing Python environments.
Install Git, FFmpeg, and Git LFS via Homebrew.
Verify all tools are working from your Terminal.

Install Miniconda

Miniconda is a lightweight Python environment manager. It lets you create isolated environments so that different AI projects don't conflict with each other.

Press Cmd+Space to open Spotlight search.
Type Terminal and press Enter to open it.
Download the Miniconda installer for macOS Apple Silicon by running this command:

curl -O https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh

Run the installer by running this command:

bash Miniconda3-latest-MacOSX-arm64.sh

What will the installer ask me?

The installer will show you a license agreement. Press Enter to scroll through it, then type yes to accept.

It will ask where to install. Press Enter to accept the default location. When it asks if you want to initialize Miniconda, type yes.

Close your Terminal window completely and open a new one for the changes to take effect.
Verify Miniconda installed correctly by running:

conda --version

You should see a version number printed, like conda 24.x.x or similar.

✔️ I see a version number

Miniconda is installed and ready to go.

ⓧ Command not found

This means your Terminal didn't pick up the new conda path. Try these fixes:

Make sure you completely closed and reopened Terminal (not just a new tab).
If that doesn't work, run this command to manually initialize conda for your shell:

source ~/miniconda3/bin/activate
conda init --all

Close and reopen Terminal again, then retry conda --version.

Install Git and FFmpeg

You need Git for cloning code repositories and FFmpeg for encoding and decoding video files. Both are installed through Homebrew, a package manager for macOS.

First, check if Git is already available by running:

git --version

What if macOS asks to install developer tools?

macOS includes Git through Xcode Command Line Tools. If you see a popup asking to install them, click Install and wait for it to finish. This can take a few minutes.

You should see a version number like git version 2.x.x.

Next, install Homebrew by running this command:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

What does this command do?

This downloads and runs the official Homebrew installer script. It will explain what it plans to do and ask for your password. Type your Mac login password (it won't appear on screen) and press Enter.

Homebrew installs to /opt/homebrew on Apple Silicon Macs. After installation, it prints some directions for updating your shell config. Follow those directions to add Homebrew to your PATH.

Install FFmpeg by running:

brew install ffmpeg

Verify FFmpeg installed correctly by running:

ffmpeg -version

You should see version info and a list of configuration flags printed to your terminal.

Seeing 'brew: command not found'?

This means Homebrew isn't in your PATH yet. Run the following command to add it to your shell, then try again:

eval "$(/opt/homebrew/bin/brew shellenv)"

If you're still stuck, help me fix my Homebrew installation on Apple Silicon.

Install Git LFS

LivePortrait's AI model weights are large files (over 1GB). Git Large File Storage (Git LFS) is required to download them from HuggingFace.

Install Git LFS via Homebrew by running:

brew install git-lfs

Initialize Git LFS for your user account by running:

git lfs install

You should see Git LFS initialized printed in your terminal.

Git LFS command not found?

Make sure the brew install git-lfs command completed without errors. If Homebrew isn't in your PATH, run eval "$(/opt/homebrew/bin/brew shellenv)" first, then retry the install.

If you're still stuck, help me troubleshoot my Git LFS installation.

Your Mac is now equipped with everything you need to run AI models locally. Next up, you'll clone the LivePortrait repository and set up a dedicated Python environment for it.

Set Up LivePortrait

Your Mac now has all the foundational tools it needs to run AI models locally. In this step, you'll set up LivePortrait itself.

LivePortrait is an open-source AI model from Kling AI Research that animates portrait photos using motion transfer. You'll clone its source code, create an isolated Python environment, and download the pretrained model weights that power the AI.

In this step, get ready to:

Clone the LivePortrait repository from GitHub.
Create and configure a dedicated Python environment.
Download the pretrained model weights from HuggingFace.

Clone the repository and create your environment

LivePortrait's code lives on GitHub. You'll clone it to your Desktop so you can find it easily later.

Move to your Desktop and clone the LivePortrait repository by running these commands:

cd ~/Desktop
git clone https://github.com/KlingTeam/LivePortrait
cd LivePortrait

What do these commands do?

cd ~/Desktop moves you to your Desktop folder so the project lands somewhere visible.
git clone downloads the entire LivePortrait source code from GitHub.
cd LivePortrait moves you inside the newly cloned folder.

Confirm you're inside the project folder by running:

ls

You should see files like inference.py, app.py, and a folder called assets in the output.

Don't see those files?

Make sure you typed the clone URL exactly as shown. A typo in the URL will cause the command to fail.
Check your internet connection. git clone needs to download files from GitHub.
help me troubleshoot my git clone

Now you'll create an isolated Python environment specifically for LivePortrait. This keeps LivePortrait's dependencies separate from anything else on your system.

Create a dedicated Python 3.10 environment by running this command:
When conda asks Proceed ([y]/n)?, type y and press Enter.

conda create -n LivePortrait python=3.10

What is a conda environment?

A conda environment is like a sealed container for a specific project's Python version and packages. Without it, installing packages for one AI project could break another.

The -n LivePortrait flag names the environment, and python=3.10 pins the exact Python version LivePortrait needs.

Activate the new environment by running:

conda activate LivePortrait

Your terminal prompt should now show (LivePortrait) at the beginning of the line instead of (base).

Still seeing (base) in your prompt?

Double-check you typed conda activate LivePortrait with the exact capitalization. Environment names are case-sensitive.
If you see an error saying the environment doesn't exist, re-run the conda create command above and make sure you typed y when prompted.
help me activate my conda environment

Install dependencies and fix FFmpeg

LivePortrait needs specific Python packages to run on macOS Apple Silicon. You'll also install a conda-specific version of FFmpeg that fixes a known video encoding issue.

Install the macOS-specific Python packages by running:

pip install -r requirements_macOS.txt

What is this installing?

The requirements_macOS.txt file lists all the Python packages LivePortrait needs on Apple Silicon. This includes PyTorch (the AI framework), onnxruntime-silicon (optimized for Apple chips), and various image processing libraries.

This command may take a few minutes as it downloads and installs dozens of packages.

You should see packages being downloaded and installed, ending with a success message.

Seeing installation errors?

Make sure your terminal prompt shows (LivePortrait) and not (base). Running pip install in the wrong environment causes conflicts.
If a package fails to build, check that you have Xcode Command Line Tools installed. Run xcode-select --install if needed.
help me fix my pip install errors

Install FFmpeg from conda-forge to fix a known video encoding issue on Apple Silicon:
When conda asks Proceed ([y]/n)?, type y and press Enter.

conda install -c conda-forge ffmpeg

Why install FFmpeg again?

You installed FFmpeg via Homebrew in Step 1, but LivePortrait needs a specific version inside your conda environment. The Homebrew version on Apple Silicon is missing the libx264 encoder that LivePortrait requires for creating MP4 videos.

Installing from conda-forge adds the missing encoder to your environment. Without this fix, LivePortrait would fail when trying to save your animated video.

You should see the packages installed successfully with no errors.

Download the pretrained model weights

The AI model needs pretrained weights to function. These are the learned parameters from training on millions of face images.

What are model weights?

Think of model weights as the AI's learned knowledge. The code you cloned is the structure of the brain. The weights are everything it learned during training.

These files are about 1.5GB total, stored on HuggingFace (a platform for sharing AI models). The download uses Git LFS (which you set up in Step 1) to handle the large files.

Download the model weights from HuggingFace by running this command:
This download is approximately 1.5GB and may take several minutes depending on your internet speed.

git clone https://huggingface.co/KwaiVGI/LivePortrait pretrained_weights

Verify the weights downloaded correctly by running:

ls pretrained_weights

You should see several folders containing model files.

Download seems stuck or failed?

The download is large (1.5GB). On slower connections, it may appear to freeze. Give it time.
If you see a Git LFS error, make sure you ran git lfs install in Step 1. You can run it again to be safe.
If the download fails partway through, delete the folder with rm -rf pretrained_weights and try the clone command again.
help me download the LivePortrait model weights

LivePortrait is fully set up and ready to run. Next up, you'll test the system by generating your first AI animation using built-in example assets.

Run the Demo

You have all the pieces in place: a Python environment, model weights, and dependencies. Now it's time to see the AI in action.

In this step, you'll run LivePortrait's inference script using its built-in example assets. This proves everything works and gives you a front-row seat to watch motion transfer happen in real time.

In this step, get ready to:

Run the built-in demo and generate your first AI-animated video.
Understand the output and how the LivePortrait pipeline works.
Try a different source image to see how results vary.

Run inference with the built-in examples

LivePortrait ships with example source images and driving videos so you can test the system immediately. The inference script loads the pretrained model weights you downloaded and processes the inputs through the full animation pipeline.

Run the LivePortrait inference script by running this command:

PYTORCH_ENABLE_MPS_FALLBACK=1 python inference.py

What does this command do?

The PYTORCH_ENABLE_MPS_FALLBACK=1 environment variable tells PyTorch to fall back to CPU for operations that Apple's MPS (Metal Performance Shaders) backend doesn't support yet.

Without it, the script crashes because one critical operation (aten::grid_sampler_3d) isn't implemented in MPS. You'll need this prefix every time you run LivePortrait on Apple Silicon.

How long will this take?

On Apple Silicon, LivePortrait runs approximately 20x slower than an RTX 4090 GPU. The built-in demo uses a short driving video, so expect it to take 1-2 minutes to complete.

If you have 16GB of RAM, close other apps during processing to free up memory.

Once the script finishes, open the generated video by running:

open animations/s6--d0_concat.mp4

Your default video player opens and plays a three-panel video showing the driving video, source image, and generated result side by side.

Script crashing or no output file?

If you see a message about aten::grid_sampler_3d, make sure you included PYTORCH_ENABLE_MPS_FALLBACK=1 at the start of the command. It must be on the same line, before python.
If you see a memory error, close other applications and try again. LivePortrait needs at least 16GB of RAM with no other apps running.
If you see an FFmpeg encoder error mentioning libx264, make sure you ran conda install -c conda-forge ffmpeg in the previous step.

Still stuck? Help me debug a LivePortrait inference error on macOS Apple Silicon

Understand what happened

The video you just watched is the core magic of AI portrait animation. Each of the three panels tells part of the story.

The left panel shows the driving video. This is the motion source. The AI extracts head movements, facial expressions, and lip movements from this video.
The middle panel shows the source image. This is a still portrait photo. The AI keeps this person's identity (face shape, skin, hair) but replaces their expression with motion from the driving video.
The right panel shows the generated result. This is what the AI produced. The source person's face now moves and talks exactly like the person in the driving video.

What is the LivePortrait pipeline?

Under the hood, LivePortrait runs five stages to produce each frame of the output video:

Face detection finds and crops the face in both the source image and each driving frame.
Landmark extraction identifies key facial points (eyes, nose, mouth, jaw) in each frame.
Motion coefficient computation converts those landmarks into a compact set of numbers describing the movement.
Neural warping and rendering deforms the source face to match the extracted motion, then generates a photorealistic frame.
Stitching blends the animated face seamlessly back into the original image frame.

Try a different source and driving combination

LivePortrait includes several example source images and driving videos. Running a different combination helps you see how the same driving motion produces different results on different faces.

Run inference with a different source image by running this command:

PYTORCH_ENABLE_MPS_FALLBACK=1 python inference.py -s assets/examples/source/s9.jpg -d assets/examples/driving/d0.mp4

What do the -s and -d flags do?

The -s flag specifies the source image (the face to animate). The -d flag specifies the driving video (where motion comes from).

When you ran the script without flags, it used built-in defaults. Now you're explicitly choosing a different source face (s9.jpg) while keeping the same driving video (d0.mp4).

Once it finishes processing, open the new output by running:

open animations/s9--d0_concat.mp4

Compare this result to the first video. The driving motion is identical, but the generated face looks completely different because it preserves the identity from s9.jpg.

Why do results look different on different faces?

The AI separates identity (what someone looks like) from motion (how they move). The Motion Extractor pulls movement data from the driving video. The Appearance Feature Extractor captures the source person's look. The Warping Module then applies the driving motion to the source appearance, producing a result that moves like the driver but looks like the source.

Second run taking longer than expected?

The model weights are already loaded in memory from the first run. If you ran a different command in between, PyTorch needs to reload the model. This is normal on Apple Silicon.
If processing seems frozen, check Activity Monitor. The python process should be using significant CPU. If it's idle, something went wrong. Press Ctrl+C and run the command again.

Need help? Why is my second LivePortrait inference taking so long on Apple Silicon?

You've confirmed that LivePortrait works end to end on your Mac. Next up, you'll create a personalized talking avatar using your own face and expressions.

Create Your Own Talking Avatar

In the previous step, you proved the AI pipeline works by animating LivePortrait's built-in example faces. Now it's time to use YOUR face.

You'll prepare a portrait photo of yourself, record a short driving video of you talking, and feed both into LivePortrait. The result is a video of your still photo coming alive with your actual expressions and speech movements.

In this step, get ready to:

Prepare a clear, front-facing portrait photo of yourself.
Record a short driving video of yourself talking.
Generate your personalized talking avatar video.

Prepare your source portrait

LivePortrait needs a source image to define the face identity in your output. The clearer and more centered your photo, the better the AI can detect and animate your facial features.

Take a new photo or select an existing one that meets these criteria:
Save or transfer the photo into the LivePortrait folder on your Desktop.
Name the file my_portrait.jpg.

Best results come from passport-style photos

Think of a passport or ID photo. A plain background, direct eye contact, and soft lighting all help the face detector lock onto your features cleanly.

Confirm the file is in place by running:

ls my_portrait.jpg

You should see my_portrait.jpg listed in the output.

Record your driving video

The driving video provides the motion that gets transferred onto your portrait. Every head tilt, blink, and lip movement in this video will appear on your still photo.

Open QuickTime Player on your Mac.
Click File in the menu bar, then select New Movie Recording.
Record yourself talking for 3 to 5 seconds.
Start with a neutral expression, then talk, smile, or move your head slightly.
Click the stop button when you're done, then save the recording with File > Export As > 1080p.
Save it into your LivePortrait folder with the name my_driving.mp4.

Tips for a good driving video

Focus the frame on your head area and minimize shoulder movement. Your first frame should be a frontal face with a neutral expression.

Keep the video short. Processing time scales with video length. A 5-second clip takes approximately 3 to 4 minutes on Apple Silicon.

Using your phone instead

You can also record on your phone and AirDrop the video to your Mac. Just make sure the final file lands in the LivePortrait folder and is named my_driving.mp4.

Confirm the file is in place by running:

ls my_driving.mp4

You should see my_driving.mp4 listed in the output.

Generate your avatar animation

With both your portrait and driving video ready, you can now run the same inference pipeline you tested earlier. This time it uses YOUR inputs.

What is the crop flag?

The --flag_crop_driving_video flag tells LivePortrait to automatically detect and crop the face region from your driving video. This is important because your self-recorded video likely includes your shoulders and background, not just a tight face crop.

Close other apps before running

LivePortrait requires at least 16GB of RAM with no other apps running. Close browsers, Slack, and other heavy applications before starting inference to avoid slowdowns or crashes.

Generate your personalized talking avatar by running this command:

PYTORCH_ENABLE_MPS_FALLBACK=1 python inference.py -s my_portrait.jpg -d my_driving.mp4 --flag_crop_driving_video

What does this command do?

PYTORCH_ENABLE_MPS_FALLBACK=1 allows PyTorch to fall back to CPU for operations not yet supported on Apple's Metal GPU backend.
-s my_portrait.jpg sets your photo as the source face identity.
-d my_driving.mp4 sets your video as the motion source.
--flag_crop_driving_video auto-crops the driving video to focus on the face region.

Processing takes a few minutes on Apple Silicon. You'll see progress output in the terminal as each frame is processed.

Once processing completes, open your result by running:

open animations/my_portrait--my_driving_concat.mp4

Your video player opens showing the same three-panel layout you saw earlier. This time, the right panel is YOUR face animated with YOUR expressions from the driving video.

Video not generating or crashing?

If you see a memory error, close all other applications and try again. LivePortrait needs at least 16GB of free RAM.
If the face isn't detected in your portrait, make sure you're looking directly at the camera with good lighting. Heavily angled or shadowed faces can fail detection.
If the output looks distorted, try re-recording your driving video starting from a completely neutral expression in the first frame.

Help me troubleshoot my LivePortrait inference on macOS. I'm getting an error when running with my own portrait and driving video.

You've just brought a still photo of yourself to life using AI. Next up, you'll experiment with different inputs to see how motion transfer handles various scenarios and understand the model's strengths and limits.

Experiment and Understand

You've created your own AI talking avatar. The video proves the entire LivePortrait pipeline works on your Mac.

Now it's time to push the system further. By experimenting with different inputs and learning to reuse motion data, you'll build intuition for what makes motion transfer succeed or fail.

In this step, get ready to:

Reuse extracted motion data as templates for faster inference.
Test the limits of motion transfer with different inputs.
Understand the five-module LivePortrait architecture.

Try motion templates for speed

Every time LivePortrait processes a driving video, it extracts motion coefficients for every single frame. This extraction is the slowest part of the pipeline.

LivePortrait automatically saves these coefficients as a .pkl template file during each run. You can reuse the template to skip re-extraction entirely.

What is a motion template?

A .pkl file stores the motion coefficients (head rotation, expression parameters, lip movements) extracted from a driving video. Once saved, you can apply those same movements to any portrait without re-processing the video.

This also protects privacy. You can share a .pkl file without sharing the original video of someone's face.

Check that the template file from your previous run exists by running:

ls animations/my_driving.pkl

You should see the file listed. LivePortrait generated it automatically during your Step 4 run.

Re-run inference using the motion template instead of the video by running this command:

PYTORCH_ENABLE_MPS_FALLBACK=1 python inference.py -s my_portrait.jpg -d animations/my_driving.pkl

What does this command do?

The -d animations/my_driving.pkl flag points to the saved motion template instead of the original video file. LivePortrait skips the motion extraction step entirely and jumps straight to warping and rendering.

You should notice the processing finishes faster than before since the expensive extraction work is already done.

Open the output to confirm it looks the same as your earlier result:

open animations/my_portrait--my_driving_concat.mp4

The result should be identical to your Step 4 output. The template preserved all the motion data perfectly.

Don't see the .pkl file?

The template is only generated when the driving input is a video file (not when it's already a .pkl). If it's missing, re-run the Step 4 command with your my_driving.mp4 file and check the animations/ directory again.

help me find my .pkl motion template file

Test the limits

The best way to understand an AI model is to push it beyond its comfort zone. These experiments reveal how LivePortrait separates identity from motion.

Try using a profile photo (non-frontal face) as your source image. Take or find a photo where you're looking to the side.
Record a new driving video with extreme head movements. Turn your head far left and right, tilt dramatically, or nod exaggeratedly.
Use a different person's driving video with your portrait. Ask a friend to record a short clip, or use one of the built-in examples as the driving source with your photo:

PYTORCH_ENABLE_MPS_FALLBACK=1 python inference.py -s my_portrait.jpg -d assets/examples/driving/d0.mp4 --flag_crop_driving_video

What should I notice?

The AI preserves YOUR identity from the source photo while transferring MOTION from the driving video. No matter whose movements you use as input, the output face still looks like you.

You'll also notice quality degrades with extreme angles or movements that go beyond what the model saw during training. Profile photos produce artifacts because the model can't hallucinate the hidden side of a face reliably.

Understand the architecture

Now that you've seen the model succeed and struggle, let's look at what's happening under the hood. LivePortrait is built from five specialized neural network modules, each handling one part of the animation pipeline.

What are the five modules?

Appearance Feature Extractor (0.84M params): Encodes the source image's visual identity into a compact representation. This is why the output always looks like YOUR face.
Motion Extractor (28.12M params): Extracts motion coefficients (head pose, expression, lip shape) from each frame of the driving video. This is what gets saved in .pkl templates.
Warping Module (45.53M params): Deforms the source appearance using the extracted motion. It bends and stretches the face to match the driving pose.
Spade Generator (55.37M params): Renders the final realistic frame from the warped features. This is the largest module because generating photorealistic pixels is the hardest task.
Stitching Module (0.23M params): Blends the animated face back into the full frame seamlessly. It handles the boundary between the generated face and the original image background.

Why does this matter?

This same pipeline architecture (detect face, extract motion, warp appearance, render, stitch) powers commercial products like Kling, HeyGen, and other AI avatar platforms. Understanding it here gives you a mental model for evaluating any talking-head AI system.

The separation of identity and motion is the key insight. It's what allows a single photo to be animated with unlimited different motion sequences.

Secret mission

Launch the Web UI and Master Retargeting

So far you've controlled LivePortrait entirely from the command line. But the real creative power lives in LivePortrait's Gradio web interface, where retargeting sliders let you override specific motion channels independently. Lip openness, eye gaze, head rotation. You can sculpt expressions that never existed in your driving video.

Clean Up Your Resources

This project runs entirely locally on your Mac, so there are no ongoing cloud costs. Decide whether to keep your resources available, pause them to free up memory, or delete them entirely.

Resources you used:

LivePortrait directory (cloned repository, ~1.5GB pretrained weights, generated videos, personal media files).
Conda environment LivePortrait (Python 3.10 with AI dependencies).
Miniconda installation (Python environment manager).
FFmpeg (installed via Homebrew).
Git LFS (installed via Homebrew).

Keep everything running

No action needed. Choose this if you're still actively experimenting with LivePortrait or plan to animate more portraits soon.

The Gradio app will keep running in your Terminal until you press Ctrl+C or close the window.
Your conda environment and pretrained weights stay ready for instant re-use.
The pretrained weights take up ~1.5GB of disk space.

Pause - I'll come back to this later

Stop the running process and deactivate the environment to free up memory. Your files and environment stay on disk for next time.

In Terminal, press Ctrl+C to stop the Gradio app.
Deactivate the conda environment by running:

conda deactivate

Close the browser tab at http://localhost:7860.
To resume later, open Terminal, navigate to your LivePortrait folder, run conda activate LivePortrait, and re-launch with PYTORCH_ENABLE_MPS_FALLBACK=1 python app.py.

Delete - I don't want to use this again

Remove all project resources and start fresh. This frees up ~2GB of disk space.

In Terminal, press Ctrl+C to stop the Gradio app.
Deactivate the conda environment and remove it by running:

conda deactivate
conda env remove -n LivePortrait

Navigate out of the LivePortrait directory and delete it by running:

cd ~/Desktop
rm -rf LivePortrait

Uninstall FFmpeg and Git LFS (installed via Homebrew) by running:

brew uninstall ffmpeg
brew uninstall git-lfs

If you no longer need Miniconda for other projects, remove it entirely by running:

conda init --reverse --all
rm -rf ~/miniconda3
rm -rf ~/.condarc ~/.conda ~/.continuum

Restart your Terminal after removing Miniconda so the shell changes take effect.

Nice Work!

You just built your own AI talking avatar system running entirely on your Mac. From a blank terminal to generating realistic animated videos of yourself, you now have hands-on experience with the same core technology behind commercial products like Kling and HeyGen.

You've learned how to:

Set up a complete local AI/ML environment on your Mac with Miniconda, FFmpeg, and Git LFS.
Run LivePortrait locally to generate AI-animated talking videos of yourself using motion transfer.
Understand the full animation pipeline from face detection to motion extraction to neural rendering and stitching.
Launch the Gradio web UI and master retargeting controls for independent lip, eye, and head pose adjustments.

Ready to quiz yourself?