# This Python 3 environment comes with many helpful analytics libraries installed
# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python

import numpy as np   # linear algebra
import pandas as pd  # data processing, CSV file I/O (e.g. pd.read_csv)

import os
for dirname, _, filenames in os.walk('/kaggle/input'):
    for filename in filenames:
        print(os.path.join(dirname, filename))

!pip install -q label-studio scikit-learn statsmodels albumentations nlpaug audiomentations librosa soundfile

!pip install -q label-studio scikit-learn statsmodels albumentations nlpaug audiomentations librosa soundfile



import json, time, random, requests
from pathlib import Path

DATA_DIR = Path("data"); DATA_DIR.mkdir(exist_ok=True)
POSTER_DIR = DATA_DIR / "posters"; POSTER_DIR.mkdir(exist_ok=True)

TONES = ["Dark", "Uplifting", "Tense", "Comedic", "Romantic"]

random.seed(42)
np.random.seed(42)
print("Tones:", TONES)

OMDB_KEY = "PASTE_YOUR_KEY_HERE"
OMDB_URL = "https://www.omdbapi.com/"

# SOLVED - read this, you will use `movies` in every section
TITLES = [
    "Inception","The Matrix","Titanic","Parasite","Toy Story","Joker","La La Land",
    "Get Out","Interstellar","Frozen","The Godfather","Alien","Amelie","Se7en",
    "Up","The Shining","Notting Hill","Mad Max Fury Road","Her","Whiplash",
    "The Notebook","Hereditary","Paddington","Gravity","Moonlight","Coco",
    "The Big Lebowski","No Country for Old Men","Pride and Prejudice","Arrival",
    "Superbad","The Conjuring","Before Sunrise","Blade Runner","Groundhog Day",
    "A Quiet Place","Call Me by Your Name","Dunkirk","Shrek","The Revenant",
    "Little Miss Sunshine","It Follows","Casablanca","Gladiator","Ratatouille",
    "Black Swan","Love Actually","Sicario","The Grand Budapest Hotel","Room",
    "Zombieland","Eternal Sunshine of the Spotless Mind","Prisoners","Booksmart",
    "The Witch","500 Days of Summer","Nightcrawler","Finding Nemo","Oldboy",
    "Bridesmaids","Midsommar","Brooklyn","Dune","Inside Out","The Departed",
    "Silver Linings Playbook","Train to Busan","Knives Out","Carol","Uncut Gems",
    "Spirited Away","The Truman Show","Jaws","Juno","Requiem for a Dream",
    "About Time","Green Book","The Babadook","Wall-E","Fight Club","Roma",
    "Crazy Rich Asians","Us","Lion","Baby Driver","The Lighthouse","Soul",
    "Manchester by the Sea","Kill Bill","Legally Blonde","Nomadland","Gone Girl",
    "Toy Story 3","The Farewell","Split","Chef","Marriage Story","Hot Fuzz",
    "The Sixth Sense","Boyhood","Lady Bird","Doctor Strange","Rocky",
]

def fetch_movie(title):
    r = requests.get(OMDB_URL, params={"t": title, "apikey": OMDB_KEY}, timeout=10)
    return r.json()

rows = []
for t in TITLES:
    d = fetch_movie(t)
    if d.get("Response") == "False":
        continue
    rows.append({
        "imdb_id": d.get("imdbID"),
        "title":   d.get("Title"),
        "year":    d.get("Year"),
        "genre":   d.get("Genre", ""),
        "plot":    d.get("Plot", ""),
        "poster":  d.get("Poster", ""),
    })
    time.sleep(0.2)                      # be polite to the server

movies = pd.DataFrame(rows)
movies = movies[movies["poster"] != "N/A"].reset_index(drop=True)
movies.to_csv(DATA_DIR / "movies.csv", index=False)
print(movies.shape)
movies.head()

# SOLVED
from PIL import Image
from io import BytesIO

def download_poster(row):
    path = POSTER_DIR / f"{row['imdb_id']}.jpg"
    if path.exists():
        return path
    try:
        r = requests.get(row["poster"], timeout=10)
        Image.open(BytesIO(r.content)).convert("RGB").save(path)
        return path
    except Exception:
        return None

movies["poster_path"] = movies.apply(download_poster, axis=1)
movies = movies[movies["poster_path"].notna()].reset_index(drop=True)
print("Posters downloaded:", len(movies))

# SOLVED EXAMPLE
example = {
    "classification": "Dark",                                 # tone of the film
    "regression":     7.8,                                    # predicted rating
    "detection":      [{"box": [30, 40, 120, 200], "class": "face"},
                       {"box": [10, 260, 300, 40],  "class": "title_text"}],
}
for k, v in example.items():
    print(k, "->", v)

# YOUR CODE HERE

# YOUR ANSWER HERE
answer_1_3 = "..."

# YOUR ANSWER HERE
challenges = ["...", "...", "..."]

# SOLVED EXAMPLE
def rule_from_genre(genre):
    """Guess tone from the genre string. Return None if unsure."""
    g = str(genre).lower()
    if "horror" in g or "thriller" in g:
        return "Tense"
    if "romance" in g:
        return "Romantic"
    if "comedy" in g:
        return "Comedic"
    if "crime" in g or "war" in g:
        return "Dark"
    return None                       # rule refuses to guess

movies["rule_tone"] = movies["genre"].apply(rule_from_genre)
print(movies["rule_tone"].value_counts(dropna=False))

# YOUR CODE HERE
def rule_v2(genre, poster_path):
    pass

# SOLVED EXAMPLE
# A model labels unlabelled data, and we treat those labels as if they were real.
# We keep only the predictions the model is very confident about.

def pseudo_label(model, X_unlabelled, threshold=0.95):
    proba = model.predict_proba(X_unlabelled)
    confident = proba.max(axis=1) >= threshold
    labels = model.classes_[proba.argmax(axis=1)]
    return confident, labels          # train on labels[confident] only

# YOUR ANSWER HERE
answer_2_4 = "..."

# YOUR ANSWERS HERE
answer_2_5 = {1: "...", 2: "...", 3: "...", 4: "..."}

bash
label-studio start movie-tone --init
# open http://localhost:8080

xml
<View>
  <Image name="poster" value="$image"/>
  <Text name="plot" value="$plot"/>
  <Choices name="tone" toName="poster" choice="single-radio">
    <Choice value="Dark"/>
    <Choice value="Uplifting"/>
    <Choice value="Tense"/>
    <Choice value="Comedic"/>
    <Choice value="Romantic"/>
  </Choices>
</View>

### Question 3.2: Build the task file

json
{"data": {"image": "<poster url>", "plot": "<plot text>",
          "imdb_id": "tt1375666", "title": "Inception"}}

# YOUR CODE HERE

# SOLVED EXAMPLE
def parse_export(path):
    """Turn a Label Studio JSON export into a DataFrame[imdb_id, tone]."""
    raw = json.loads(Path(path).read_text())
    rows = []
    for task in raw:
        result = task["annotations"][0]["result"]
        if not result:                     # task was skipped
            continue
        rows.append({"imdb_id": task["data"]["imdb_id"],
                     "tone": result[0]["value"]["choices"][0]})
    return pd.DataFrame(rows)

# ann_a = parse_export("export_A.json")
# ann_b = parse_export("export_B.json")

# YOUR CODE HERE
# merged = ann_a.merge(ann_b, on="imdb_id", suffixes=("_a", "_b"))

# YOUR ANSWERS HERE
answer_3_6 = {1: "...", 2: "...", 3: "..."}

# SOLVED EXAMPLE
GUIDELINES_V1 = {
    "Dark":      "Sad, violent, or hopeless story. Poster is mostly black or grey.",
    "Uplifting": "The story ends in hope or success. Bright warm poster.",
    "Tense":     "The viewer is meant to feel fear or suspense. Not funny.",
    "Comedic":   "The film is meant to make you laugh.",
    "Romantic":  "A love story is the main plot, not a side plot.",
}
for k, v in GUIDELINES_V1.items():
    print(f"{k:10s} : {v}")

# YOUR ANSWERS HERE
hard_cases = [
    # {"movie": "...", "why_confusing": "...", "new_rule": "..."},
]

# YOUR ANSWERS HERE
hard_cases = [
    # {"movie": "...", "why_confusing": "...", "new_rule": "..."},
]

# YOUR ANSWER HERE
answer_4_3 = "..."

# YOUR ANSWER HERE
review_plan = "..."

# SOLVED EXAMPLE
from sklearn.metrics import cohen_kappa_score, confusion_matrix

a = ["Dark","Dark","Tense","Comedic","Romantic","Dark","Tense","Uplifting"]
b = ["Dark","Tense","Tense","Comedic","Romantic","Dark","Dark","Uplifting"]

percent = np.mean([x == y for x, y in zip(a, b)])
kappa = cohen_kappa_score(a, b)
print(f"Percent agreement: {percent:.2f}")
print(f"Cohen's Kappa:     {kappa:.2f}")

# SOLVED EXAMPLE
def read_kappa(k):
    if k < 0.00:  return "Poor (worse than guessing)"
    if k <= 0.20: return "Slight"
    if k <= 0.40: return "Fair"
    if k <= 0.60: return "Moderate"
    if k <= 0.80: return "Substantial"
    return "Almost perfect"

print(read_kappa(kappa))

# YOUR CODE HERE

# YOUR CODE HERE

# YOUR ANSWER HERE
answer_5_5 = "..."

# YOUR CODE HERE
from statsmodels.stats.inter_rater import fleiss_kappa, aggregate_raters

# labels_matrix: shape (30, 3), one column per annotator, cells are tone names
# table, _ = aggregate_raters(labels_matrix)     # -> counts, shape (30, 5)
# print(fleiss_kappa(table))

# YOUR CODE HERE

# SOLVED EXAMPLE
movies["decade"] = pd.to_numeric(movies["year"].str[:4], errors="coerce") // 10 * 10

random_sample = movies.sample(n=30, random_state=0)

strat_sample = movies.groupby("decade", group_keys=False).apply(
    lambda g: g.sample(n=min(5, len(g)), random_state=0)
)
print(random_sample["decade"].value_counts().sort_index())
print(strat_sample["decade"].value_counts().sort_index())

# YOUR CODE HERE
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.neighbors import NearestNeighbors

# YOUR ANSWER HERE
answer_6_3 = "..."

# YOUR ANSWER HERE
answer_6_4 = "..."

# SOLVED EXAMPLE
def least_confidence(proba):     # 1 minus the top probability
    return 1.0 - proba.max(axis=1)

def margin_sampling(proba):      # small gap between top two classes = unsure
    top2 = np.sort(proba, axis=1)[:, -2:]
    return 1.0 - (top2[:, 1] - top2[:, 0])

def entropy_sampling(proba):     # spread-out probabilities = unsure
    p = np.clip(proba, 1e-9, 1.0)
    return -(p * np.log(p)).sum(axis=1)

# In all three, a HIGHER score means "label this one next".

# SOLVED EXAMPLE
from sklearn.linear_model import LogisticRegression

def query_next(X_pool, model, strategy=entropy_sampling, k=10):
    """Indices of the k most uncertain items in the pool."""
    proba = model.predict_proba(X_pool)
    return np.argsort(strategy(proba))[-k:]

# clf = LogisticRegression(max_iter=1000).fit(X_labelled, y_labelled)
# to_label = query_next(X_pool, clf)

# YOUR CODE HERE
import matplotlib.pyplot as plt

# YOUR CODE HERE

# YOUR ANSWER HERE
answer_7_5 = "..."

# YOUR ANSWER HERE
answer_7_6 = "..."

# SOLVED EXAMPLE
ABSTAIN = None

def lf_genre(row):
    """Vote from the genre string."""
    return rule_from_genre(row["genre"])

def lf_plot_keywords(row):
    """Vote from words in the plot summary."""
    p = str(row["plot"]).lower()
    if any(w in p for w in ["murder", "kill", "death", "war"]):
        return "Dark"
    if any(w in p for w in ["love", "romance", "wedding"]):
        return "Romantic"
    return ABSTAIN

# YOUR CODE HERE

# YOUR CODE HERE

# YOUR ANSWER HERE
answer_8_4 = "..."

# SOLVED EXAMPLE
counts = pd.Series({"Dark": 120, "Tense": 90, "Comedic": 60,
                    "Uplifting": 45, "Romantic": 12})
print(counts)
print("\nBiggest : smallest =", round(counts.max() / counts.min(), 1))

# YOUR CODE HERE
extra_needed = {}
answer_9_2 = "..."

# SOLVED EXAMPLE
from torchvision import transforms

img = Image.open(movies.loc[0, "poster_path"]).convert("RGB")

basic = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.RandomHorizontalFlip(p=0.5),
    transforms.RandomRotation(degrees=10),
    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),
])
basic(img).save("aug_example.jpg")
print("Saved one augmented poster")

# YOUR CODE HERE

# SOLVED EXAMPLE
import albumentations as A
import cv2

pipeline = A.Compose([
    A.HorizontalFlip(p=0.5),
    A.RandomBrightnessContrast(p=0.5),
    A.GaussNoise(p=0.3),
    A.CoarseDropout(max_holes=4, max_height=32, max_width=32, p=0.3),  # Cutout
])
arr = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
print("Output shape:", pipeline(image=arr)["image"].shape)

# YOUR CODE HERE

# YOUR CODE HERE

# YOUR ANSWER HERE
answer_10_6 = "..."

# SOLVED EXAMPLE
def random_deletion(text, p=0.1):
    words = text.split()
    kept = [w for w in words if random.random() > p]
    return " ".join(kept) if kept else text

def random_swap(text, n=1):
    words = text.split()
    for _ in range(n):
        i, j = random.sample(range(len(words)), 2)
        words[i], words[j] = words[j], words[i]
    return " ".join(words)

plot = movies.loc[0, "plot"]
print("original :", plot)
print("deletion :", random_deletion(plot))
print("swap     :", random_swap(plot))

# YOUR CODE HERE

# YOUR CODE HERE

# YOUR CODE HERE

# SOLVED EXAMPLE
import librosa, soundfile as sf

sr = 16000
t = np.linspace(0, 3, sr * 3)
# a simple three-note tone, standing in for a trailer clip
clip = (0.4*np.sin(2*np.pi*220*t) + 0.3*np.sin(2*np.pi*330*t)
        + 0.2*np.sin(2*np.pi*440*t)).astype(np.float32)
sf.write("clip.wav", clip, sr)

noisy = clip + np.random.normal(0, 0.01, len(clip)).astype(np.float32)
sf.write("clip_noisy.wav", noisy, sr)
print("Length in seconds:", len(clip) / sr)

# YOUR CODE HERE

# SOLVED EXAMPLE
from audiomentations import Compose, AddGaussianNoise, TimeStretch, PitchShift, Gain

augment = Compose([
    AddGaussianNoise(min_amplitude=0.001, max_amplitude=0.01, p=0.5),
    TimeStretch(min_rate=0.9, max_rate=1.1, p=0.5),
    PitchShift(min_semitones=-2, max_semitones=2, p=0.5),
    Gain(min_gain_db=-6, max_gain_db=6, p=0.5),
])
aug_clip = augment(samples=clip, sample_rate=sr)

### Question 12.4: Look at the spectrogram

Draw the **mel spectrogram** of the original and of one augmented clip, side by
side (`librosa.feature.melspectrogram`, `librosa.display.specshow`).

Then explain: **time masking** hides some time steps, **frequency masking** hides
some frequency rows. Point to where each would sit on your picture.

# YOUR CODE HERE

# YOUR ANSWER HERE
answer_12_5 = "..."

# SOLVED EXAMPLE
# OFFLINE: build the new files once and save them.
#   + fast at training time, easy to inspect
#   - uses disk, the same fixed set every epoch

# ONLINE: augment inside the DataLoader, fresh every epoch.
#   + endless variety, no extra disk
#   - costs CPU time on every step

from torch.utils.data import DataLoader
# train_ds = PosterDataset(paths, labels, transform=basic)     # online
# loader = DataLoader(train_ds, batch_size=32, shuffle=True, num_workers=2)

# YOUR CODE HERE
import torch, torchvision
print("GPU available:", torch.cuda.is_available())

# YOUR CODE HERE

# YOUR ANSWER HERE
answer_13_4 = "..."

Task	What the label looks like
Classification	one class name (`"Dark"`)
Regression	one number (`7.8`)
Object Detection	boxes: `[x, y, width, height, class]`
Semantic Segmentation	one class per pixel (a mask)
NER	text spans: `(start, end, entity_type)`

Method	Who labels	Speed	Quality
Manual	human only	slow	high
Rule-based	code rules	fast	depends on rules
Model-assisted	model suggests, human fixes	medium	high
Semi-automatic	model does easy ones, human does hard ones	medium	good
Pseudo-labelling	model labels unlabelled data, used as truth	very fast	risky

Tool	Best for
Label Studio	many data types (image, text, audio) - we use this
CVAT	video and images, especially boxes and masks
LabelImg	simple: bounding boxes on images only
Doccano	text only: classification and NER

Strategy	How it picks	Watch out for
Random	every item equally likely	rare classes get missed
Stratified	a fixed share from each group	you must know the groups
Snowball	start from a few, add similar ones	not representative
Convenience	whatever is easiest to reach	strong bias

Lab 2: Data Labelling and Data Augmentation¶

Setup¶

Getting the movies (same source as Lab 1)¶

Downloading the posters¶

PART A - LABELLING DATA¶

Section 1: Types of Label¶

Question 1.1 (Solved): One movie, three label types¶

Question 1.2: Write a segmentation label and an NER label¶

Question 1.3: Cost of labelling¶

Question 1.4: Name three challenges¶

Section 2: Manual vs Automatic Labelling¶

Question 2.1 (Solved): A rule-based labeller¶

Question 2.2: Add a poster-brightness rule and measure coverage¶

Question 2.3 (Solved): Pseudo-labelling, and its danger¶

Question 2.4: Why pseudo-labelling can go wrong¶

Question 2.5: Pick a method for each situation¶

Section 3: Annotation Tools¶

Question 3.1 (Solved): Start Label Studio¶

Question 3.3: Label 30 movies (work with a partner)¶

Question 3.4 (Solved): Read the export file¶

Question 3.5: Join the two annotators¶

Question 3.6: Choose the right tool¶

Section 4: Annotation Guidelines¶

Question 4.1 (Solved): A first rule book¶

Question 4.2: Find hard cases and fix the rules¶

Question 4.3: Add an "I cannot decide" option¶

Question 4.3: Add an "I cannot decide" option¶

Question 4.4: Design a review step¶

Section 5: Inter-Annotator Agreement¶

Question 5.1 (Solved): Percent agreement vs Cohen's Kappa¶

Question 5.2 (Solved): How to read a Kappa score¶

Question 5.3: Compute Kappa on your own labels¶

Question 5.4: Fix the guidelines and measure again¶

Question 5.5: Name the sources of disagreement¶

Question 5.6: Fleiss' Kappa for three or more people¶

Question 5.7: A limit of Cohen's Kappa¶

Section 6: Sampling - Choosing What to Label¶

Question 6.1 (Solved): Random and stratified sampling¶

Question 6.2: Snowball sampling for a rare tone¶

Question 6.3: The hidden cost of snowball sampling¶

Question 6.4: Spot the convenience sample¶

Section 7: Active Learning¶

Question 7.1 (Solved): Three ways to measure "unsure"¶

Question 7.2 (Solved): One round of pool-based active learning¶

Question 7.3: Active learning vs random - draw the curves¶

Question 7.4: Report the saving¶

Question 7.5: Query-by-Committee (short answer)¶

Question 7.6: The diversity problem¶

Section 8: Weak Supervision¶

Question 8.1 (Solved): Two labelling functions¶

Question 8.2: Write a third rule and combine the votes¶

Question 8.3: Score your weak labels¶

Question 8.4: When is weak supervision worth it?¶

PART B - DATA AUGMENTATION¶

Section 9: Why Augment?¶

Question 9.1 (Solved): Show the imbalance¶

Question 9.2: Plan an augmentation budget¶

Section 10: Image Augmentation¶

Question 10.1 (Solved): Basic transforms with torchvision¶

Question 10.2: Build one transform per technique¶

Question 10.3 (Solved): The same job with Albumentations¶

Question 10.4: Compare the two libraries¶

Question 10.5: MixUp¶

Question 10.6: Find the augmentation that breaks the label¶

Section 11: Text Augmentation¶

Question 11.1 (Solved): Two simple text edits¶

Question 11.2: Synonym replacement and random insertion¶

Question 11.3: Back translation¶

Question 11.4: Check the meaning survived¶

Section 12: Audio Augmentation¶

Question 12.1 (Solved): Build a clip and add noise¶

Question 12.2: Four more audio transforms¶

Question 12.3 (Solved): A pipeline with audiomentations¶

Question 12.5: An unrealistic audio augmentation¶

Section 13: Best Practices¶

Question 13.1 (Solved): Online vs offline augmentation¶

Question 13.2: Does augmentation actually help? Measure it.¶

Question 13.3: When augmentation hurts¶

Question 13.4: Never augment the test set¶

Section 14: Challenge Problems (Optional)¶