Download build_notebook.py from regicid/guardian_attribute_counts: direct link, hf CLI and curl.
- Browser
- Download file 30 kB
-
https://huggingface.co/datasets/regicid/guardian_attribute_counts/resolve/main/build_notebook.py
- Command line
-
hf download hf://datasets/regicid/guardian_attribute_counts/build_notebook.py
-
curl -L -o build_notebook.py https://huggingface.co/datasets/regicid/guardian_attribute_counts/resolve/main/build_notebook.py
30 kB
| """Generate semantic_axis_gender.ipynb (run once; then execute the notebook).""" | |
| import nbformat as nbf | |
| cells = [] | |
| md = lambda s: cells.append(nbf.v4.new_markdown_cell(s.strip("\n"))) | |
| code = lambda s: cells.append(nbf.v4.new_code_cell(s.strip("\n"))) | |
| # ═══════════════════════════════════════════════════════════════════════════ | |
| md(r""" | |
| # Are words gendered? Semantic axes, word embeddings and *The Guardian* (1999–2026) | |
| This notebook asks a simple question: **when The Guardian writes about a man or a woman, does it use different words?** It also asks whether that has changed over 25 years. | |
| We will: | |
| 1. look at **what the data is**: words attached to male and female characters; | |
| 2. learn how **word embeddings** (fastText) put words in a geometric space; | |
| 3. use them to build a **semantic axis** (e.g. *brutal ↔ gentle*) or a **semantic category** (e.g. *cognition verbs*) from a handful of seed words; | |
| 4. measure whether that axis or category is **male- or female-skewed**, and **how this changes over time**. | |
| > **For students.** Every section ends with something you can change: seed words, slot, pooling. The functions are short and documented, so read them! | |
| """) | |
| md(r""" | |
| ## 0. Where the data comes from | |
| Each Guardian article (1999–2026) was processed with **BookNLP**, a pipeline that: | |
| 1. finds **characters**, i.e. people mentioned in the text (*Theresa May*, *she*, *the prime minister*…); | |
| 2. groups the mentions that refer to the same person (**coreference**); | |
| 3. assigns a **gender** to each character, from pronouns (*he/she*), honorifics (*Mr/Mrs*) and first names. Characters with contradictory cues are dropped; | |
| 4. collects the words **syntactically attached** to each character, in four **slots**: | |
| | slot | what it is | example: *"Angry, she **attacked** her **rival**, who was later **sacked**"* | | |
| |---|---|---| | |
| | `agent` | verbs the character **does** | she → *attack* | | |
| | `patient` | verbs **done to** the character | the rival → *sack* | | |
| | `mod` | adjectives / nouns **describing** the character | she → *angry* | | |
| | `poss` | nouns the character **possesses** | she → *rival* | | |
| We then **count**, per year and slot, how often each word was attached to a man vs a woman. The output is a table of counts, with no text in it. This is the dataset [`regicid/guardian_attribute_counts`](https://huggingface.co/datasets/regicid/guardian_attribute_counts). | |
| """) | |
| code(r""" | |
| import numpy as np | |
| import pandas as pd | |
| import matplotlib.pyplot as plt | |
| from sklearn.linear_model import LogisticRegression | |
| from sklearn.preprocessing import normalize | |
| pd.set_option("display.width", 140) | |
| # --- a small, consistent visual vocabulary for the whole notebook -------- | |
| MALE, FEMALE = "#2a78d6", "#eb6834" # men = blue, women = orange | |
| SLOT_COLORS = {"agent": "#2a78d6", "patient": "#eb6834", | |
| "mod": "#1baf7a", "poss": "#eda100"} | |
| plt.rcParams.update({ | |
| "figure.figsize": (8, 4.5), "figure.dpi": 110, | |
| "axes.spines.top": False, "axes.spines.right": False, | |
| "axes.grid": True, "grid.color": "#e5e4e0", "grid.linewidth": .6, | |
| "axes.edgecolor": "#8a8984", "axes.labelcolor": "#52514e", | |
| "xtick.color": "#52514e", "ytick.color": "#52514e", | |
| "lines.linewidth": 2, "lines.markersize": 4, "legend.frameon": False, | |
| }) | |
| """) | |
| md(r""" | |
| ### 0.1 Loading the counts | |
| The file has one row per `(year, slot, word)`. The `word` column is the raw token (*said*, *says*, *told*). The `lemma` column is its dictionary form (*say*, *say*, *tell*): this lets us count *says* and *said* as the same verb. See `lemmatize.py` on the dataset page for how this was done. | |
| """) | |
| code(r""" | |
| URL = "hf://datasets/regicid/guardian_attribute_counts/attribute_counts_by_year.csv" | |
| raw = pd.read_csv(URL, keep_default_na=False) # keep_default_na: "null", "nan" are real words here | |
| raw.sample(8, random_state=0) | |
| """) | |
| md(r""" | |
| **From tokens to lemmas.** We sum the counts of all tokens that share a lemma. From now on, `word` means *lemma*. | |
| We also compute, for each `(year, slot)`, the **total** number of male and female attributes (`male_slot_total`, `female_slot_total`). These are the denominators that we will compare everything against. | |
| """) | |
| code(r""" | |
| attr = (raw.groupby(["corpus", "year", "slot", "lemma"], as_index=False) | |
| [["male_count", "female_count", "total"]].sum() | |
| .rename(columns={"lemma": "word"})) | |
| slot_tot = (attr.groupby(["year", "slot"])[["male_count", "female_count"]].sum() | |
| .rename(columns={"male_count": "male_slot_total", | |
| "female_count": "female_slot_total"})) | |
| attr = attr.merge(slot_tot, on=["year", "slot"]) | |
| print(f"{len(raw):,} token rows -> {len(attr):,} lemma rows") | |
| attr[attr.word == "say"].head() | |
| """) | |
| # ═══════════════════════════════════════════════════════════════════════════ | |
| md(r""" | |
| ## 1. First look: who gets written about? | |
| Before asking *how* women and men are described, we need to know *how often* they are. This **baseline** is crucial: if women make up 25% of all attributes, then a word attached to women 25% of the time is **not** female-skewed. It is exactly average. | |
| """) | |
| code(r""" | |
| share = (attr.groupby(["year", "slot"])[["male_count", "female_count"]].sum() | |
| .assign(female_share=lambda d: d.female_count / (d.male_count + d.female_count)) | |
| .reset_index()) | |
| fig, ax = plt.subplots() | |
| for slot, g in share.groupby("slot"): | |
| ax.plot(g.year, g.female_share, marker="o", color=SLOT_COLORS[slot], label=slot) | |
| ax.annotate(slot, (g.year.iloc[-1] + .3, g.female_share.iloc[-1]), | |
| color="#52514e", va="center", fontsize=9) | |
| ax.set_ylim(0, .5) | |
| ax.yaxis.set_major_formatter(plt.matplotlib.ticker.PercentFormatter(1)) | |
| ax.set_ylabel("share of attributes attached to women") | |
| ax.set_title("Women's share of attributes, by slot") | |
| ax.legend(title="slot", ncol=4, loc="upper left"); | |
| """) | |
| md(r""" | |
| **Things to notice** | |
| * Women are a clear **minority** of the people the Guardian writes about, but their share **grows** over the period. | |
| * The share **differs by slot**: women are relatively more often *possessors* or *patients* than *agents*. That is already a finding: see §1.2. | |
| * 2026 is a **partial year**. | |
| ### 1.1 The most gendered words (no embeddings yet) | |
| A simple way to rank words is the **log-odds ratio**: how much more likely is a word for a woman than for a man, *given* each gender's total? We pool all years and keep reasonably frequent words. | |
| """) | |
| code(r""" | |
| def gendered_words(attr, slot, n=15, min_total=500, k=.5): | |
| # log OR > 0 = female-skewed, relative to the slot baseline | |
| d = attr[attr.slot == slot] | |
| w = d.groupby("word")[["male_count", "female_count"]].sum() | |
| M, F = d.drop_duplicates("year")[["male_slot_total", "female_slot_total"]].sum() | |
| w = w[w.sum(axis=1) >= min_total] | |
| w["log_or"] = (np.log((w.female_count + k) / (F - w.female_count + k)) | |
| - np.log((w.male_count + k) / (M - w.male_count + k))) | |
| w = w.sort_values("log_or") | |
| return pd.concat([w.head(n).assign(side="male"), w.tail(n).assign(side="female")]) | |
| g = gendered_words(attr, "mod") | |
| fig, ax = plt.subplots(figsize=(7, 7)) | |
| ax.barh(g.index, g.log_or, color=np.where(g.log_or > 0, FEMALE, MALE), height=.7) | |
| ax.axvline(0, color="#8a8984", lw=1) | |
| ax.set_xlabel("log odds ratio (← male-skewed | female-skewed →)") | |
| ax.set_title("Most gendered modifiers (mod), 1999–2026"); | |
| """) | |
| md(r""" | |
| Some of these are **trivial** (*woman*, *actress*), because they are part of how gender was detected. Others are **interesting** (look at the *appearance* and *family* words). | |
| You can try `gendered_words(attr, "agent")` or `"poss"`. | |
| But word-by-word lists have two problems: (i) there are tens of thousands of words, and (ii) single words are noisy. We want to ask about **meanings**: *"are women described with more emotional words?"* For that we need to group words by meaning, which is what embeddings are for. | |
| ### 1.2 A first, embedding-free measure: agentivity | |
| Are men more often **agents** (doing things) and women more often **patients** (having things done to them)? We build a **2×2 table** for each year: | |
| | | agent | patient | | |
| |---|---|---| | |
| | **men** | a | b | | |
| | **women** | c | d | | |
| The **odds ratio** OR = (a/b) / (c/d) is **> 1** if men are relatively more often agents. We'll reuse this 2×2 logic all the way through the notebook. | |
| """) | |
| code(r""" | |
| def agentivity_or(attr, pool=1): | |
| # men-vs-women odds ratio of being agent rather than patient, per year | |
| t = attr.drop_duplicates(["year", "slot"])[["year", "slot", "male_slot_total", "female_slot_total"]].copy() | |
| t["year"] = t.year // pool * pool | |
| t = t.groupby(["year", "slot"]).sum().unstack("slot") | |
| a, b = t[("male_slot_total", "agent")], t[("male_slot_total", "patient")] | |
| c, d = t[("female_slot_total", "agent")], t[("female_slot_total", "patient")] | |
| log_or = np.log(a) + np.log(d) - np.log(b) - np.log(c) | |
| se = np.sqrt(1/a + 1/b + 1/c + 1/d) | |
| return pd.DataFrame({"odds_ratio": np.exp(log_or), "log_or": log_or, "se": se}).reset_index() | |
| ag = agentivity_or(attr) | |
| fig, ax = plt.subplots() | |
| ax.axhline(1, color="#8a8984", lw=1, ls="--") | |
| ax.plot(ag.year, ag.odds_ratio, marker="o", color=MALE) | |
| ax.fill_between(ag.year, np.exp(ag.log_or - 1.96*ag.se), np.exp(ag.log_or + 1.96*ag.se), color=MALE, alpha=.15, lw=0) | |
| ax.set_ylabel("odds ratio (men vs women)") | |
| ax.set_title("Agentivity: are men more often agents than patients?"); | |
| """) | |
| # ═══════════════════════════════════════════════════════════════════════════ | |
| md(r""" | |
| ## 2. Word embeddings in five minutes | |
| A **word embedding** maps each word to a vector (here 300 numbers) so that **words used in similar contexts get similar vectors**. *"You shall know a word by the company it keeps"* (Firth, 1957). | |
| We use **fastText** (Bojanowski et al., 2017), trained by Facebook on Common Crawl, i.e. billions of words of web text. Two properties matter for us: | |
| * it is **not trained on the Guardian**, so the geometry is "general English", not "Guardian English". This is a good thing: we don't want the embedding to have already absorbed the gender bias we are measuring *from the same corpus*; | |
| * it builds vectors from **character n-grams**, so it can produce a vector for any word, even misspelled or rare ones. | |
| **Similarity** between two words = **cosine** of the angle between their vectors (1 = same direction, 0 = unrelated). | |
| #### Loading the vectors | |
| * **Option A (full model, ~7 GB of RAM).** Download `cc.en.300.bin` with `fasttext.util.download_model('en')` and set `FT_PATH`. | |
| * **Option B (light, for laptops).** We pre-computed the fastText vector of every lemma in the dataset (`fasttext_vectors.npz`, ~90 MB on the dataset page). This is enough for everything below, **as long as your seed words appear in the data**. | |
| The code picks A if the file exists, and B otherwise. | |
| """) | |
| code(r""" | |
| import os | |
| FT_PATH = os.path.expanduser("~/Downloads/cc.en.300.bin") | |
| if os.path.exists(FT_PATH): # Option A | |
| import fasttext | |
| ft = fasttext.load_model(FT_PATH) | |
| vec = ft.get_word_vector | |
| print("full fastText model loaded") | |
| else: # Option B | |
| from huggingface_hub import hf_hub_download | |
| z = np.load(hf_hub_download("regicid/guardian_attribute_counts", | |
| "fasttext_vectors.npz", repo_type="dataset")) | |
| _index = {w: i for i, w in enumerate(z["words"])} | |
| _M = z["vectors"].astype(np.float32) | |
| def vec(w): | |
| i = _index.get(w) | |
| if i is None: | |
| print(f" ! '{w}' not in the pre-computed vocabulary: ignored") | |
| return np.zeros(_M.shape[1], np.float32) | |
| return _M[i] | |
| print(f"pre-computed vectors loaded: {len(_index):,} words") | |
| def embed(words): | |
| # one L2-normalised row per word: dot product = cosine similarity | |
| return normalize(np.array([vec(w) for w in words])) | |
| """) | |
| code(r""" | |
| def cosine(w1, w2): | |
| a, b = embed([w1, w2]) | |
| return float(a @ b) | |
| for pair in [("angry", "furious"), ("angry", "happy"), ("angry", "table"), | |
| ("husband", "wife"), ("career", "job"), ("career", "baby")]: | |
| print(f"{pair[0]:>8} – {pair[1]:<8} {cosine(*pair):.2f}") | |
| """) | |
| md(r""" | |
| Note that *angry–happy* is quite similar: **antonyms share contexts** (*"I am very ___"*). Embeddings capture *relatedness* more than *synonymy*. This is why we will build axes from **two contrasting poles**, rather than from one list of words. | |
| Let's look at the **nearest neighbours** of a word, among the vocabulary of one slot: | |
| """) | |
| code(r""" | |
| VOCAB = {s: (attr[attr.slot == s].groupby("word").total.sum() | |
| .loc[lambda x: x >= 20].index.to_list()) # words seen >= 20 times | |
| for s in attr.slot.unique()} | |
| EMB = {s: embed(VOCAB[s]) for s in VOCAB} # cached: computed once | |
| def neighbours(word, slot, n=12): | |
| sims = EMB[slot] @ embed([word])[0] | |
| top = np.argsort(-sims)[:n] | |
| return pd.Series(sims[top], index=np.array(VOCAB[slot])[top]).round(2) | |
| neighbours("caress", "agent").to_frame("cosine").T | |
| """) | |
| # ═══════════════════════════════════════════════════════════════════════════ | |
| md(r""" | |
| ## 3. From seed words to a semantic axis | |
| Suppose we want to study **brutality vs gentleness** in what characters *do* (agent verbs). We write down a few **seed words** for each pole: | |
| * brutal pole: *attack, hit, smash, slam, crush, threaten, …* | |
| * gentle pole: *caress, comfort, soothe, whisper, hug, …* | |
| We then need a score for **every** verb in the data (thousands of them). There are two classic ways to get one. | |
| ### 3.1 Method 1: the centroid axis (SemAxis, An et al. 2018; Kozlowski et al. 2019) | |
| 1. average the vectors of each pole: $\bar v_+$ and $\bar v_-$; | |
| 2. the **axis** is the difference $a = \bar v_+ - \bar v_-$; | |
| 3. a word's score is its **projection** on the axis: $\text{score}(w) = \cos(w, a)$. | |
| It is simple, transparent and has no parameters. | |
| ### 3.2 Method 2: a classifier (what we used for the French press) | |
| Train a **logistic regression** to tell pole + from pole – using the 300 dimensions, then score every word by $P(+\mid w)$. The classifier learns **which dimensions matter**, which is often sharper than a plain average. It can also handle a **category** ("cognition verbs" vs *anything else*) when there is no natural opposite pole: then the negatives are random words. | |
| """) | |
| code(r""" | |
| def semaxis(pos, neg, slot): | |
| # Method 1: projection on (centroid+ − centroid−); returns word, score | |
| a = embed(pos).mean(0) - embed(neg).mean(0) | |
| a /= np.linalg.norm(a) | |
| return pd.DataFrame({"word": VOCAB[slot], "score": EMB[slot] @ a}) | |
| def classify(pos, slot, neg=None, threshold=.8, seed=0): | |
| # Method 2: logistic regression pos vs neg (default: random vocabulary words). | |
| # Returns word, prob, category (= prob > threshold). | |
| if neg is None: # a "category" rather than an axis: contrast with random words | |
| rng = np.random.default_rng(seed) | |
| neg = list(rng.choice([w for w in VOCAB[slot] if w not in pos], 3 * len(pos), replace=False)) | |
| X, y = embed(pos + neg), np.r_[np.ones(len(pos)), np.zeros(len(neg))] | |
| clf = LogisticRegression(max_iter=1000, class_weight="balanced").fit(X, y) | |
| out = pd.DataFrame({"word": VOCAB[slot], "prob": clf.predict_proba(EMB[slot])[:, 1]}) | |
| out["category"] = out.prob > threshold | |
| return out | |
| def show_poles(scores, col, n=20): | |
| # the n words at each end of the axis: the first sanity check | |
| s = scores.sort_values(col) | |
| return pd.DataFrame({"← low end": s.word.head(n).values, "high end →": s.word.tail(n).values[::-1]}) | |
| """) | |
| code(r""" | |
| brutal = ["attack", "hit", "smash", "slam", "crush", "batter", "threaten", "punch", | |
| "bully", "intimidate", "force", "dominate", "lash", "berate", "storm", "thump"] | |
| gentle = ["caress", "comfort", "soothe", "console", "whisper", "hug", "cuddle", "nurture", | |
| "reassure", "embrace", "murmur", "stroke", "tend", "cradle", "smile", "thank"] | |
| ax_brut = semaxis(brutal, gentle, "agent") | |
| show_poles(ax_brut, "score") | |
| """) | |
| md(r""" | |
| **Always read the poles before you trust an axis.** Does the top look brutal, and the bottom gentle? If you see words that don't belong, think about why. They may be polysemous (*strike* = hit, or go on strike), or they may share contexts with the seeds without sharing meaning. Then refine the seeds. | |
| The same axis with the classifier: | |
| """) | |
| code(r""" | |
| clf_brut = classify(brutal, "agent", neg=gentle, threshold=.5) | |
| show_poles(clf_brut, "prob") | |
| """) | |
| code(r""" | |
| # Do the two methods agree? (rank correlation over all agent verbs) | |
| m = ax_brut.merge(clf_brut, on="word") | |
| print("Spearman ρ =", round(m.score.corr(m.prob, method="spearman"), 2)) | |
| """) | |
| # ═══════════════════════════════════════════════════════════════════════════ | |
| md(r""" | |
| ## 4. Is the axis gendered? Two measures | |
| We now have a score for each word. Each word also has a male count and a female count. There are two ways to combine them. | |
| ### 4.1 Continuous: the standardized mean difference (SMD) | |
| Take **every attribute token** attached to a man and average its axis score; do the same for women. The difference, divided by the overall standard deviation, is Cohen's **d**: | |
| $$ d = \frac{\bar s_{\text{men}} - \bar s_{\text{women}}}{\sigma} $$ | |
| * $d>0$: men's words sit **further toward the + pole** (here: brutal). | |
| * $d = 0.1$ means the two distributions are shifted by a tenth of a standard deviation. That is small in psychology terms, but it is a *systematic* shift across millions of tokens. | |
| This uses **all** words, weighted by how often they occur. It does not need a threshold. | |
| """) | |
| code(r""" | |
| def weighted_axis_smd(attr, scores, col="score", slots=None, pool=1, min_tokens=30, logit=False, eps=1e-6): | |
| # Male-minus-female gap on a continuous axis, in SD units (Cohen's d). | |
| # scores: DataFrame with `word` and a score column `col`. | |
| # logit: if the score is a probability, un-bunch it with log(p/(1-p)). | |
| # The SD is computed once, on all years, so it is a fixed ruler over time. | |
| d = attr[attr.slot.isin(slots)] if slots else attr | |
| sc = scores[["word", col]].rename(columns={col: "s"}) | |
| if logit: | |
| p = sc.s.clip(eps, 1 - eps); sc["s"] = np.log(p / (1 - p)) | |
| d = d.merge(sc, on="word") | |
| N = d.male_count + d.female_count | |
| sbar = np.average(d.s, weights=N) | |
| sigma = np.sqrt(np.average((d.s - sbar) ** 2, weights=N)) | |
| d = d.assign(year=d.year // pool * pool) | |
| def stats(g): | |
| wM, wF, s = g.male_count.values, g.female_count.values, g.s.values | |
| if wM.sum() < min_tokens or wF.sum() < min_tokens: | |
| return pd.Series(dict(d=np.nan, se=np.nan)) | |
| muM, muF = np.average(s, weights=wM), np.average(s, weights=wF) | |
| vM, vF = np.average((s - muM)**2, weights=wM), np.average((s - muF)**2, weights=wF) | |
| nM, nF = wM.sum()**2 / (wM**2).sum(), wF.sum()**2 / (wF**2).sum() # Kish effective N: | |
| se = np.sqrt(vM/nM + vF/nF) / sigma # a few frequent words ≠ many tokens | |
| return pd.Series(dict(d=(muM - muF) / sigma, se=se)) | |
| return d.groupby("year").apply(stats, include_groups=False).reset_index() | |
| def plot_skew(o, y="d", log_band=False, ax=None, label=None, color="#52514e", | |
| ylabel="d (men − women, SD units)", title=None, ref=0): | |
| # One time series with a 95% band. Above `ref` = male-skewed, below = female-skewed. | |
| if ax is None: | |
| _, ax = plt.subplots() | |
| o = o.dropna(subset=[y]).sort_values("year") | |
| if log_band: # odds ratios: the band is symmetric on the log scale | |
| lo, hi = np.exp(o.log_or - 1.96 * o.se), np.exp(o.log_or + 1.96 * o.se) | |
| else: | |
| lo, hi = o[y] - 1.96 * o.se, o[y] + 1.96 * o.se | |
| ax.axhline(ref, color="#8a8984", lw=1, ls="--", zorder=0) | |
| ax.plot(o.year, o[y], marker="o", color=color, label=label) | |
| ax.fill_between(o.year, lo, hi, color=color, alpha=.15, lw=0) | |
| ax.text(1.01, .98, "male-skewed ↑", transform=ax.transAxes, color=MALE, fontsize=8, va="top") | |
| ax.text(1.01, .02, "female-skewed ↓", transform=ax.transAxes, color=FEMALE, fontsize=8, va="bottom") | |
| ax.set_ylabel(ylabel); ax.set_title(title) | |
| return ax | |
| """) | |
| code(r""" | |
| smd = weighted_axis_smd(attr, ax_brut, slots=["agent"]) | |
| plot_skew(smd, title="Brutal ↔ gentle verbs (agent): gap between men and women"); | |
| """) | |
| md(r""" | |
| ### 4.2 Categorical: the odds ratio of a lexicon | |
| Sometimes we want to talk about a **category** (*"physical-appearance adjectives"*) rather than a position on an axis. Then: | |
| 1. turn the scores into a **lexicon** (words with `prob > threshold`, or the top-k of an axis), and **read it**; | |
| 2. for each year, the 2×2 table: | |
| | | words in the lexicon | all other words of the slot | | |
| |---|---|---| | |
| | **men** | a | b | | |
| | **women** | c | d | | |
| 3. **OR = (a/b)/(c/d)**. OR = 2 means *the odds that a man's modifier is a lexicon word are twice a woman's*. OR = 0.5 means the reverse. | |
| Because we compare with each gender's **own total**, the result does not depend on women being written about less often. | |
| """) | |
| code(r""" | |
| def lexicon_or(attr, lex, slots=None, pool=1, k=.5, max_se=.25): | |
| # Men-vs-women odds ratio of using a word from `lex`, per (pooled) year. | |
| # k: Haldane–Anscombe correction (avoids log 0). Points with se > max_se are dropped. | |
| d = attr[attr.slot.isin(slots)] if slots else attr | |
| d = d.assign(year=d.year // pool * pool) | |
| # one total per (year, slot) BEFORE pooling years, otherwise we'd drop some | |
| tot = (attr[attr.slot.isin(slots)] if slots else attr).drop_duplicates(["year", "slot"]) | |
| tot = tot.assign(year=tot.year // pool * pool).groupby("year")[["male_slot_total", "female_slot_total"]].sum() | |
| hit = d[d.word.isin(set(lex))].groupby("year")[["male_count", "female_count"]].sum() | |
| o = tot.join(hit).fillna(0) | |
| a, c = o.male_count, o.female_count | |
| b, dd = o.male_slot_total - a, o.female_slot_total - c | |
| o["log_or"] = np.log(a + k) + np.log(dd + k) - np.log(b + k) - np.log(c + k) | |
| o["se"] = np.sqrt(1/(a+k) + 1/(b+k) + 1/(c+k) + 1/(dd+k)) | |
| o.loc[o.se > max_se, "log_or"] = np.nan | |
| o["odds_ratio"] = np.exp(o.log_or) | |
| return o.reset_index() | |
| def plot_or(o, **kw): | |
| # odds ratio on a log scale, 95% CI band; > 1 = male-skewed | |
| ax = plot_skew(o, y="odds_ratio", log_band=True, | |
| ref=1, ylabel=kw.pop("ylabel", "odds ratio (men vs women, log scale)"), **kw) | |
| ax.set_yscale("log") | |
| ax.yaxis.set_major_formatter(plt.matplotlib.ticker.ScalarFormatter()) | |
| ax.yaxis.set_minor_formatter(plt.matplotlib.ticker.NullFormatter()) | |
| return ax | |
| def drivers(attr, lex, slot, n=15): | |
| # Which lexicon words carry the effect? counts pooled over all years | |
| d = attr[(attr.slot == slot) & attr.word.isin(set(lex))].groupby("word")[["male_count", "female_count"]].sum() | |
| tot = attr[attr.slot == slot].drop_duplicates("year")[["male_slot_total", "female_slot_total"]].sum() | |
| d["per_10k_men"] = 1e4 * d.male_count / tot.male_slot_total | |
| d["per_10k_women"] = 1e4 * d.female_count / tot.female_slot_total | |
| d["ratio_w/m"] = d.per_10k_women / d.per_10k_men | |
| return d.sort_values("female_count", ascending=False).head(n).round(2) | |
| """) | |
| # ═══════════════════════════════════════════════════════════════════════════ | |
| md(r""" | |
| ## 5. Worked examples | |
| ### 5.1 A category: physical appearance (mod) | |
| """) | |
| code(r""" | |
| physical = ["beautiful", "pretty", "ugly", "bald", "blonde", "brunette", "slim", "skinny", | |
| "fat", "chubby", "sexy", "gorgeous", "attractive", "handsome", "petite", "curvy", | |
| "bearded", "glamorous", "stunning", "slender", "muscular", "tanned", "busty", "lanky"] | |
| phys = classify(physical, "mod", threshold=.6) | |
| lex_phys = pd.Series(sorted(set(phys.loc[phys.category, "word"]) | set(physical))) # seeds always in | |
| print(len(lex_phys), "words in the lexicon:\n", ", ".join(lex_phys.sort_values())) | |
| """) | |
| md(r""" | |
| 👉 **Read the list.** The classifier extends the seeds to words we hadn't thought of, but it may also let in errors. If it does, raise the threshold or add those words as negatives (`neg=[...]`). | |
| """) | |
| code(r""" | |
| o = lexicon_or(attr, lex_phys, slots=["mod"], pool=2) | |
| plot_or(o, color=FEMALE, title="Physical-appearance modifiers: odds ratio men vs women (2-year bins)"); | |
| """) | |
| code(r""" | |
| drivers(attr, lex_phys, "mod") | |
| """) | |
| md(r""" | |
| ### 5.2 A category: cognition verbs (agent) | |
| Do women *think*, *argue*, *analyse* as often as men in the news? | |
| """) | |
| code(r""" | |
| cognition = ["think", "analyse", "argue", "reason", "predict", "estimate", "conclude", | |
| "consider", "reflect", "deduce", "assess", "calculate", "theorise", "evaluate", | |
| "ponder", "infer", "hypothesise", "speculate"] | |
| cog = classify(cognition, "agent", threshold=.6) | |
| lex_cog = pd.Series(sorted(set(cog.loc[cog.category, "word"]) | set(cognition))) | |
| print(len(lex_cog), "words:", ", ".join(lex_cog.sort_values())) | |
| plot_or(lexicon_or(attr, lex_cog, slots=["agent"]), color=MALE, | |
| title="Cognition verbs (agent): odds ratio men vs women"); | |
| """) | |
| md(r""" | |
| ### 5.3 An axis: family ↔ career (poss) | |
| What do men and women **have**, according to the Guardian? Here an axis is more natural than a category, because there are two poles. We show both measures. | |
| """) | |
| code(r""" | |
| family = ["husband", "wife", "child", "daughter", "son", "baby", "mother", "father", | |
| "family", "home", "wedding", "marriage", "pregnancy", "kitchen", "grandchild"] | |
| career = ["career", "job", "salary", "company", "office", "promotion", "colleague", "business", | |
| "boss", "contract", "employer", "profession", "employee", "client", "firm"] | |
| ax_fc = semaxis(career, family, "poss") # + pole = career | |
| display(show_poles(ax_fc, "score", n=15)) | |
| fig, axes = plt.subplots(1, 2, figsize=(13, 4.5)) | |
| plot_skew(weighted_axis_smd(attr, ax_fc, slots=["poss"]), ax=axes[0], | |
| title="Family ↔ career (poss): SMD, + = men nearer career") | |
| top = ax_fc.sort_values("score").word | |
| plot_or(lexicon_or(attr, top.tail(300), slots=["poss"]), ax=axes[1], color=MALE, | |
| label="300 most 'career' nouns") | |
| plot_or(lexicon_or(attr, top.head(300), slots=["poss"]), ax=axes[1], color=FEMALE, | |
| label="300 most 'family' nouns", title="…and as two lexicons (top-300 at each pole)") | |
| axes[1].legend(loc="center left") | |
| plt.tight_layout(); | |
| """) | |
| md(r""" | |
| ### 5.4 One axis, all slots | |
| The same axis can be computed in every slot where it makes sense. Here is the brutal ↔ gentle axis for what characters **do** (`agent`) and what is **done to them** (`patient`): | |
| """) | |
| code(r""" | |
| fig, ax = plt.subplots() | |
| for slot in ["agent", "patient"]: | |
| sc = semaxis(brutal, gentle, slot) | |
| plot_skew(weighted_axis_smd(attr, sc, slots=[slot], pool=2), ax=ax, | |
| color=SLOT_COLORS[slot], label=slot) | |
| ax.legend(title="slot"); ax.set_title("Brutal ↔ gentle: men − women gap, agent vs patient (2-year bins)"); | |
| """) | |
| md(r""" | |
| --- | |
| ## 6. Caveats | |
| * **Seed words are a theory.** The axis is only as good as the seeds, so always show the poles and the lexicon. Try to break your own axis: swap a few seeds and check that the result holds. | |
| * **Embedding bias.** fastText was trained on web text that is itself gendered. An axis like *strong ↔ weak* may partly encode gender in its own geometry. A useful check is to project *he / she / man / woman* on your axis. | |
| * **Extraction errors.** BookNLP's parsing, coreference and gender detection are imperfect. Errors that are **constant over time** do not create trends, but errors that **differ by gender** can bias levels. | |
| * **Lemmatization without context.** Lemmas were assigned to isolated words, so *left* is always *leave*, never the adjective. This is mostly harmless, but it's worth remembering for ambiguous words. | |
| * **Composition.** A trend can come from **who** is written about (more female politicians, more sportswomen) rather than **how** they are written about. To separate the two, you would need finer metadata (sections, occupations). | |
| * **Significance ≠ size.** With millions of tokens, everything is "significant". Look at the **magnitude** (d, OR) and at its **stability over time**. | |
| ## 7. Exercises | |
| 1. **Emotion.** Build an *emotional ↔ composed* axis on `mod` (*upset, tearful, emotional, hysterical, anxious, …* vs *calm, composed, measured, rational, …*). Is it gendered? Has it changed? | |
| 2. **Robustness.** Re-run 5.2 with `threshold=.5` and `.9`. Does the trend survive? | |
| 3. **Method.** For the family ↔ career axis, compare `semaxis` and `classify(career, "poss", neg=family)`. Where do they disagree? | |
| 4. **Your own axis.** Pick a dimension you care about (competence, morality, danger, sport, …), write 15 seeds per pole, and produce one SMD figure and one OR figure. | |
| 5. **Embedding bias.** Compute `embed(["he","she","man","woman"]) @ axis` for one of your axes (see `semaxis`). What does it tell you? | |
| """) | |
| nb = nbf.v4.new_notebook(cells=cells, metadata={ | |
| "kernelspec": {"name": "python3", "display_name": "Python 3", "language": "python"}, | |
| "language_info": {"name": "python"}}) | |
| nbf.write(nb, "semantic_axis_gender.ipynb") | |
| print("written", len(cells), "cells") | |