Week 3 · Assessment Quiz

Model Deployment, Gradio & Hugging Face

25 multiple-choice on deploying FastAI models with Gradio and Hugging Face Spaces, plus 5 short-answer questions.

📋 30 questions total ⭐ 30 marks 🕐 No time limit 🔒 Answers not revealed

learn.export("model.pkl") in FastAI saves:

AOnly the model architecture as a Python class definition BThe complete model including architecture, weights, and DataLoaders (enough to run inference) COnly the trained weights as a PyTorch state_dict DThe training history and metric logs

To load a FastAI exported model for inference, you use:

Atorch.load("model.pkl") BFastAI.restore("model.pkl") Cload_learner("model.pkl") Dlearn.load("model.pkl")

Hugging Face Spaces is primarily used for:

AHosting and publicly sharing machine learning demos and web apps BTraining large language models in the cloud CStoring raw datasets for research purposes DRunning automated model evaluation benchmarks

In Gradio, gr.Interface(fn, inputs, outputs) — what does fn represent?

AThe name of the Gradio theme to apply to the interface BThe Python function that takes user inputs and returns the model output CThe file path to the exported model weights DThe URL where the app will be deployed

What does learn.predict(img) return?

AThe raw pixel values of the processed image BThe gradient of the loss with respect to the input image CA tuple of (predicted category, category index, probability tensor) DOnly the probability of the top-1 class

FastAI exports models using which file format by default?

A.pt (PyTorch native format) B.pkl (Python pickle format) C.onnx (Open Neural Network Exchange) D.h5 (Keras/HDF5 format)

What is a key advantage of deploying a model on Hugging Face Spaces over a local machine?

AThe model is publicly accessible via a URL without needing the user to install Python or dependencies BThe model trains faster on Hugging Face hardware than locally CHugging Face Spaces automatically retrains the model as new data arrives DThe model weights are encrypted and protected from copying

In a Gradio interface for an image classifier, which input component is most appropriate?

Agr.Textbox() Bgr.Slider() Cgr.Image() Dgr.Checkbox()

The file that Hugging Face Spaces looks for to run a Gradio app is:

Amain.py Bapp.py Cserver.py Dgradio_app.py

Q10

PILImage.create(img) is used in FastAI inference to:

AConvert an input (file path, URL, or array) into a FastAI-compatible PIL image object BResize the image to the model's expected input resolution CApply normalisation and augmentation transforms to the image DDownload an image from the internet given its URL

Q11

learn.dls.vocab contains:

AThe list of all training image file paths BThe list of class names in the order the model uses internally CThe transforms applied to each batch DThe hyperparameters used during training

Q12

What is the difference between model weights and model architecture?

AThey are the same thing — architecture and weights are always saved together BWeights are the learned numerical parameters; architecture is the structure (layers and connections) CArchitecture is specific to PyTorch; weights are framework-agnostic DWeights define the type of layers; architecture defines the numerical values

Q13

Latency in model serving refers to:

AThe total training time for the model BThe time taken to process a single inference request and return a result CThe number of requests the server can handle per second DThe file size of the exported model

Q14

The examples= argument in gr.Interface provides:

ASample inputs that users can click to auto-fill the interface and try the model quickly BA list of valid class names the model can predict CValidation examples used to compute the displayed accuracy DPre-computed outputs to display without running the model

Q15

Inference in the context of a trained model means:

ARetraining the model on new data to update its weights BEvaluating the model on the training set to compute the training loss CUsing the trained model to make predictions on new, unseen inputs DExporting the model to a different framework such as TensorFlow

Q16

requirements.txt in a deployed app lists:

AThe names of the training datasets used BPython package dependencies that must be installed for the app to run CThe hardware requirements (GPU/CPU) for the deployment server DModel evaluation metrics computed during training

Q17

CPU inference is sometimes preferred over GPU inference when:

AServing individual requests with low latency requirements and no GPU is available, making CPU cost-effective BProcessing large batches of 1000+ images simultaneously CThe model has more than 100 million parameters DThe deployment environment requires real-time retraining

Q18

What is the purpose of gr.Label() as a Gradio output component?

ADisplays a text description of the model architecture BDisplays a free-text string generated by the model CDisplays class probabilities as a dictionary or ranked label list DDisplays the input image with bounding boxes overlaid

Q19

When a FastAI load_learner model processes an image through learn.predict(), it automatically applies:

AOnly the model's architecture — preprocessing must be coded manually BThe same transforms stored in the DataLoaders (resize, normalise, etc.) before running inference CRandom augmentations to improve prediction accuracy DGPU-specific optimisations that are not available during training

Q20

A Gradio gr.Interface with live=True means:

APredictions are generated in real-time as the user types or uploads, without a submit button BThe app is connected to a live database that updates the model continuously CThe interface streams video from the user's webcam DMultiple users can collaborate on the same interface simultaneously

Q21

Which of the following best describes model quantisation?

AIncreasing the number of model parameters to improve accuracy BReducing numerical precision (e.g. from float32 to int8) to shrink model size and speed up inference CDuplicating the model across multiple GPUs for parallel training DConverting the model to ONNX format for cross-framework compatibility

Q22

What is the role of a README.md in a Hugging Face Space repository?

AIt contains the Python code that runs the Gradio app BIt defines Python dependencies that Spaces must install CIt includes metadata (title, description, SDK type) that configures how the Space appears on the platform DIt stores the exported model weights for direct download

Q23

After calling learn.export(), the exported file contains enough information to:

ARun inference on new examples without needing the original training code or dataset BResume training from exactly where it left off with all optimiser state CConvert the model to a different framework such as TensorFlow or JAX DReproduce the original training dataset from the stored transforms

Q24

In a production recommender system, the model is typically served via:

AA Jupyter notebook shared with users as a link BAn API endpoint (REST or gRPC) that applications query to get predictions CA CSV file of pre-computed recommendations refreshed weekly DA local Python script run on each user's device

Q25

Which of the following is the correct way to call a FastAI model on a new image in an inference script?

Amodel.forward(img_tensor) Blearn.fit(1) Clearn.predict(PILImage.create(img_path)) Dlearn.export(img_path)

Answer each question in 2–4 sentences. Precise technical language is expected. Code snippets are welcome where relevant.

Q26

Describe the end-to-end process of deploying a FastAI image classifier to Hugging Face Spaces using Gradio. What files are needed and what does each contain?written

Your answer

0 / 700

Q27

What is the difference between learn.export() and saving only the model weights with torch.save()? When would you use each?written

Your answer

0 / 700

Q28

Explain what happens step-by-step when a user uploads an image to a deployed Gradio app backed by a FastAI classifier — from the browser click to the displayed result.written

Your answer

0 / 700

Q29

What are three important practical considerations when deploying a deep learning model to a public-facing web application?written

Your answer

0 / 700

Q30

What is model latency and throughput? Why might there be a tradeoff between them, and how would you address this tradeoff in a high-traffic application?written

Your answer

0 / 700

Your full name

Complete all 30 questions then click Submit. Your MCQ score (25/25) will be shown. Short answers are marked separately.

Model Deployment, Gradio & Hugging Face

Multiple Choice (25 marks)

Short Answer (5 marks — marked by lecturer)