"""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")