| """ |
| SpatialDiscourseAnalysis v2 |
| H4rmony Project · Jorge Vallego · https://theh4rmonyproject.org |
| |
| Places the sentences of up to four texts on an evaluative axis defined by two sets of |
| example sentences (poles), in the semantic space of all-mpnet-base-v2. |
| |
| New in v2 |
| - Relevance filter: keeps only sentences that match an editable lexicon, and logs why |
| - Pole check: leave-one-out test that flags pole sentences sitting on the wrong side |
| - Spread: median, SD, IQR, share of sentences leaning to each pole, tail direction |
| - Principal-axis leaning: how each text's own main dimension of variation relates to the axis |
| - Pairwise differences between texts with effect size and permutation test |
| - Most aligned / most misaligned sentences for each text |
| - Optional neutral baseline text |
| - Per-sentence scores as a downloadable CSV |
| |
| Scale: 0% = centroid of pole A, 100% = centroid of pole B, 50% = midpoint. |
| """ |
| import re |
| import json |
| import tempfile |
|
|
| import numpy as np |
| import pandas as pd |
|
|
| try: |
| import gradio as gr |
| except ImportError: |
| gr = None |
|
|
| try: |
| import spaces |
| GPU = spaces.GPU |
| except ImportError: |
| def GPU(fn=None, **kwargs): |
| return fn if fn is not None else (lambda f: f) |
|
|
| MODEL_NAME = "sentence-transformers/all-mpnet-base-v2" |
| _model = None |
|
|
|
|
| def get_model(): |
| global _model |
| if _model is None: |
| from sentence_transformers import SentenceTransformer |
| _model = SentenceTransformer(MODEL_NAME) |
| return _model |
|
|
|
|
| @GPU(duration=120) |
| def _embed_gpu(sentences): |
| import torch |
| m = get_model() |
| if torch.cuda.is_available(): |
| m = m.to("cuda") |
| return m.encode(sentences, batch_size=64, normalize_embeddings=True, |
| convert_to_numpy=True, show_progress_bar=False) |
|
|
|
|
| def embed(sentences): |
| """Replaceable in tests.""" |
| if not sentences: |
| return np.zeros((0, 768)) |
| return np.asarray(_embed_gpu(list(sentences)), dtype=np.float64) |
|
|
|
|
| |
| |
| |
| SENT_SPLIT = re.compile(r'(?<=[.!?])\s+(?=[A-Z“"‘(\[])') |
|
|
|
|
| def split_sentences(text, min_words=4): |
| """Paragraphs or lines -> sentences. One-sentence-per-line input is preserved.""" |
| out = [] |
| for block in re.split(r'\n+', text or ""): |
| block = " ".join(block.split()) |
| if not block: |
| continue |
| for s in SENT_SPLIT.split(block): |
| s = s.strip() |
| if len(s.split()) >= min_words: |
| out.append(s) |
| |
| seen, uniq = set(), [] |
| for s in out: |
| if s not in seen: |
| seen.add(s) |
| uniq.append(s) |
| return uniq |
|
|
|
|
| def pole_sentences(text): |
| return [" ".join(l.split()) for l in (text or "").splitlines() if l.strip()] |
|
|
|
|
| |
| |
| |
| |
| |
| |
| DEFAULT_LEXICON = """\ |
| Key nodes: nature, natural, sustainab*, smart, green |
| Appraisal of nature: charming, crystal clear, crystal-clear, stunning, unspoil*, beautiful, relaxing, pristine, untouched, wild, wilder, wilderness, breathtaking, enchanting, paradise, oasis, oases, scenery, landscape, landscapes, panoramic, picturesque, evocative, untamed, unbridled |
| Sustainable activities: bike, bikes, bicycle, bicycles, cycling, cycle, cyclist, cyclists, itinerary, itineraries, horseback, birdwatch*, trekking, hiking, nordic walking, canoe*, trail, trails, slow |
| Slow-travel framing: authentic*, hidden gem, under the radar, under-the-radar, natural wonders, traveller, travellers, traveler, travelers, responsible, eco-conscious, eco-friendly, best-kept secret, best kept secret, lesser-known, lesser known, off the beaten, meaningful |
| Ecological care: preserv*, protect*, conserv*, ecosystem, ecosystems, biodiversity, wildlife, species, habitat, habitats, safeguard*, coexist*, balance, fragile, reintroduc*, climate change |
| Commercial modifiers: luxury, investment, invest, value, property, properties, exclusive, privacy, price, deal, deals, upscale, villa, villas, buyer, buyers, income, secluded, asset |
| Offer framing: offer, offers, offered, offering | with: nature, park, coast, coastline, area, maremma, grosseto, beach, beaches, landscape, sea |
| """ |
|
|
|
|
| def _term_regex(term): |
| t = re.escape(term.strip().lower()).replace(r"\*", r"\w*") |
| t = t.replace(r"\ ", r"[\s-]+").replace(r"\-", r"[\s-]+") |
| return t |
|
|
|
|
| def parse_lexicon(text): |
| cats = [] |
| for line in (text or "").splitlines(): |
| if ":" not in line or not line.strip(): |
| continue |
| name, rest = line.split(":", 1) |
| with_part = None |
| if "| with:" in rest: |
| rest, with_part = rest.split("| with:", 1) |
| terms = [t for t in rest.split(",") if t.strip()] |
| if not terms: |
| continue |
| rx = re.compile(r"\b(" + "|".join(_term_regex(t) for t in terms) + r")\b", re.I) |
| wrx = None |
| if with_part: |
| wt = [t for t in with_part.split(",") if t.strip()] |
| wrx = re.compile(r"\b(" + "|".join(_term_regex(t) for t in wt) + r")\b", re.I) |
| cats.append((name.strip(), rx, wrx)) |
| return cats |
|
|
|
|
| def match_categories(sentence, cats): |
| hit = [] |
| for name, rx, wrx in cats: |
| if rx.search(sentence) and (wrx is None or wrx.search(sentence)): |
| hit.append(name) |
| return hit |
|
|
|
|
| |
| |
| |
| def axis_scores(E, cA, cB): |
| d = cB - cA |
| return 100.0 * ((E - cA) @ d) / (d @ d) |
|
|
|
|
| def pole_check(EA, EB, sents_a, sents_b): |
| """Leave-one-out: re-score each pole sentence against centroids computed without it.""" |
| cA, cB = EA.mean(0), EB.mean(0) |
| sA, sB = axis_scores(EA, cA, cB), axis_scores(EB, cA, cB) |
| pooled = np.sqrt((sA.var(ddof=1) + sB.var(ddof=1)) / 2) |
| dprime = (sB.mean() - sA.mean()) / pooled if pooled > 0 else float("inf") |
| stray = [] |
| for i in range(len(EA)): |
| cA_i = np.delete(EA, i, 0).mean(0) |
| s = axis_scores(EA[i:i + 1], cA_i, cB)[0] |
| if s >= 50: |
| stray.append(("A", sents_a[i], s)) |
| for i in range(len(EB)): |
| cB_i = np.delete(EB, i, 0).mean(0) |
| s = axis_scores(EB[i:i + 1], cA, cB_i)[0] |
| if s <= 50: |
| stray.append(("B", sents_b[i], s)) |
| cos = float(cA @ cB / (np.linalg.norm(cA) * np.linalg.norm(cB))) |
| if dprime >= 3: |
| quality = "clearly defined" |
| elif dprime >= 1.5: |
| quality = "adequately defined" |
| else: |
| quality = "weakly defined: poles overlap; consider rewriting the stray sentences" |
| return dict(cA=cA, cB=cB, sA=sA, sB=sB, dprime=float(dprime), stray=stray, |
| centroid_cosine=cos, quality=quality) |
|
|
|
|
| def spread(scores, low, high): |
| q1, med, q3 = np.percentile(scores, [25, 50, 75]) |
| sd = scores.std(ddof=1) if len(scores) > 1 else 0.0 |
| skew = float((((scores - scores.mean()) / sd) ** 3).mean()) if sd > 0 else 0.0 |
| return dict(n=int(len(scores)), mean=float(scores.mean()), median=float(med), sd=float(sd), |
| iqr=float(q3 - q1), p10=float(np.percentile(scores, 10)), |
| p90=float(np.percentile(scores, 90)), |
| share_a=float((scores < low).mean()), |
| share_neutral=float(((scores >= low) & (scores <= high)).mean()), |
| share_b=float((scores > high).mean()), skew=skew) |
|
|
|
|
| def principal_axis(E, cA, cB, k=3): |
| d_hat = (cB - cA) / np.linalg.norm(cB - cA) |
| X = E - E.mean(0) |
| _, S, Vt = np.linalg.svd(X, full_matrices=False) |
| var = S ** 2 / max(len(E) - 1, 1) |
| total = float(var.sum()) if var.sum() > 0 else 1.0 |
| comps = [] |
| for i in range(min(k, len(var))): |
| pc, proj = Vt[i], X @ Vt[i] |
| if abs(proj.min()) > abs(proj.max()): |
| pc = -pc |
| cos = float(pc @ d_hat) |
| comps.append(dict(pc=i + 1, variance_share=float(var[i] / total), |
| angle=float(np.degrees(np.arccos(min(1.0, abs(cos))))), |
| leaning="B" if cos > 0 else "A")) |
| axis_var = float(((X @ d_hat) ** 2).sum() / max(len(E) - 1, 1)) |
| return dict(components=comps, axis_share=axis_var / total, baseline=1.0 / E.shape[1]) |
|
|
|
|
| def compare(s1, s2, n_perm=5000, seed=0): |
| diff = float(s2.mean() - s1.mean()) |
| pooled = np.sqrt((s1.var(ddof=1) + s2.var(ddof=1)) / 2) |
| d = diff / pooled if pooled > 0 else 0.0 |
| rng = np.random.default_rng(seed) |
| allv, n1 = np.concatenate([s1, s2]), len(s1) |
| count = 0 |
| for _ in range(n_perm): |
| rng.shuffle(allv) |
| if abs(allv[n1:].mean() - allv[:n1].mean()) >= abs(diff): |
| count += 1 |
| p = (count + 1) / (n_perm + 1) |
| return dict(diff=diff, cohen_d=float(d), p=float(p)) |
|
|
|
|
| def size_label(d): |
| d = abs(d) |
| return "negligible" if d < 0.2 else "small" if d < 0.5 else "medium" if d < 0.8 else "large" |
|
|
|
|
| |
| |
| |
| def analyse(name_a, poles_a, name_b, poles_b, texts, baseline_text, use_filter, lexicon, |
| low, high, n_extremes=10): |
| """texts: list of (name, raw_text). Returns a dict of results (no plotting).""" |
| name_a = name_a.strip() or "Pole A" |
| name_b = name_b.strip() or "Pole B" |
| PA, PB = pole_sentences(poles_a), pole_sentences(poles_b) |
| if len(PA) < 3 or len(PB) < 3: |
| raise ValueError("Each pole needs at least 3 sentences (one per line).") |
| EA, EB = embed(PA), embed(PB) |
| pc = pole_check(EA, EB, PA, PB) |
| cA, cB = pc["cA"], pc["cB"] |
|
|
| cats = parse_lexicon(lexicon) if use_filter else [] |
| items, filter_log = [], [] |
| if baseline_text and baseline_text.strip(): |
| texts = list(texts) + [("Neutral baseline", baseline_text)] |
| for name, raw in texts: |
| if not raw or not raw.strip(): |
| continue |
| name = name.strip() or f"Text {len(items) + 1}" |
| sents = split_sentences(raw) |
| kept, kept_cats = [], [] |
| for s in sents: |
| c = match_categories(s, cats) if (cats and name != "Neutral baseline") else [] |
| if cats and name != "Neutral baseline" and not c: |
| continue |
| kept.append(s) |
| kept_cats.append(c) |
| filter_log.append(dict(text=name, total=len(sents), kept=len(kept), |
| by_category={n: sum(n in c for c in kept_cats) for n, _, _ in cats})) |
| if len(kept) < 3: |
| continue |
| E = embed(kept) |
| s = axis_scores(E, cA, cB) |
| order = np.argsort(s) |
| items.append(dict(name=name, sentences=kept, categories=kept_cats, E=E, scores=s, |
| spread=spread(s, low, high), |
| pa=principal_axis(E, cA, cB) if len(kept) > 3 else None, |
| most_a=[(kept[i], float(s[i])) for i in order[:n_extremes]], |
| most_b=[(kept[i], float(s[i])) for i in order[::-1][:n_extremes]])) |
| if not items: |
| raise ValueError("No text has at least 3 sentences after filtering.") |
| pairs = [] |
| main = [it for it in items if it["name"] != "Neutral baseline"] |
| for i in range(len(main)): |
| for j in range(i + 1, len(main)): |
| pairs.append((main[i]["name"], main[j]["name"], |
| compare(main[i]["scores"], main[j]["scores"]))) |
| base = next((it for it in items if it["name"] == "Neutral baseline"), None) |
| return dict(name_a=name_a, name_b=name_b, PA=PA, PB=PB, EA=EA, EB=EB, pole=pc, |
| items=items, pairs=pairs, baseline=base, filter_log=filter_log, |
| use_filter=use_filter, low=low, high=high) |
|
|
|
|
| |
| |
| |
| def z(x): |
| """Round for display without printing -0.""" |
| r = round(float(x)) |
| return 0 if r == 0 else r |
|
|
|
|
| def bar(pct, width=41): |
| pos = int(round(min(max(pct, 0), 100) / 100 * (width - 1))) |
| return "░" * pos + "●" + "░" * (width - 1 - pos) |
|
|
|
|
| def format_report(R): |
| A, B, pc = R["name_a"], R["name_b"], R["pole"] |
| L = ["═" * 66, " SPATIAL DISCOURSE ANALYSIS v2 — Results", "═" * 66, "", |
| f" AXIS: {A} ←────────→ {B}", |
| f" 0% = {A} centroid · 100% = {B} centroid · 50% = midpoint", |
| f" ({len(R['PA'])} sentences at {A} · {len(R['PB'])} at {B})", "", |
| "─" * 66, " 1. POLE CHECK", "─" * 66, |
| f" Axis quality: {pc['quality']} (separation d′ = {pc['dprime']:.2f})", |
| f" Leave-one-out: {len(pc['stray'])} of {len(R['PA']) + len(R['PB'])} pole sentences fall on the wrong side"] |
| for side, s, sc in pc["stray"]: |
| L.append(f" [{A if side == 'A' else B}] {sc:.0f}% {s}") |
| L += ["", "─" * 66, " 2. SENTENCE SELECTION", "─" * 66] |
| if R["use_filter"]: |
| L.append(" Relevance filter ON: sentences kept only if they match at least one lexicon category.") |
| else: |
| L.append(" Relevance filter OFF: all sentences used.") |
| for f in R["filter_log"]: |
| L.append(f" {f['text']}: {f['kept']} of {f['total']} sentences kept") |
| if R["use_filter"] and f["text"] != "Neutral baseline": |
| L.append(" " + " · ".join(f"{k}: {v}" for k, v in f["by_category"].items())) |
| L += ["", "─" * 66, " 3. ORIENTATION AND SPREAD", "─" * 66, |
| f" Leaning bands: {A} < {R['low']:.0f}% ≤ neutral ≤ {R['high']:.0f}% < {B}", ""] |
| for it in R["items"]: |
| sp = it["spread"] |
| L += [f" {it['name']} ({sp['n']} sentences)", |
| f" {bar(sp['mean'])} mean {z(sp['mean'])}% · median {z(sp['median'])}%", |
| f" spread: SD {sp['sd']:.0f} · IQR {sp['iqr']:.0f} · middle 80% between {z(sp['p10'])}% and {z(sp['p90'])}%", |
| f" leaning {A}: {sp['share_a']:.0%} · neutral: {sp['share_neutral']:.0%} · leaning {B}: {sp['share_b']:.0%}", |
| " tail: " + (f"longer towards {B}" if sp['skew'] > 0.2 else f"longer towards {A}" if sp['skew'] < -0.2 else "symmetric") |
| + f" (skew {sp['skew']:+.2f})", ""] |
| if R["baseline"] is not None: |
| b = R["baseline"]["spread"]["mean"] |
| L.append(f" Relative to the neutral baseline ({b:.0f}%):") |
| for it in R["items"]: |
| if it["name"] != "Neutral baseline": |
| dlt = it["spread"]["mean"] - b |
| L.append(f" {it['name']}: {dlt:+.0f} points ({'towards ' + B if dlt > 0 else 'towards ' + A})") |
| L.append("") |
| L += ["─" * 66, " 4. PRINCIPAL-AXIS LEANING", "─" * 66, |
| " Does each text vary mainly along this axis, or along other dimensions (topics, registers)?", ""] |
| for it in R["items"]: |
| pa = it["pa"] |
| if pa is None: |
| continue |
| c1 = pa["components"][0] |
| L += [f" {it['name']}", |
| f" main dimension of variation (PC1, {c1['variance_share']:.0%} of variance): " |
| f"{c1['angle']:.0f}° from the axis, far end leaning {A if c1['leaning'] == 'A' else B}", |
| f" variance along the axis: {pa['axis_share']:.1%} of total " |
| f"({pa['axis_share'] / pa['baseline']:.0f}× a random direction)"] |
| for c in pa["components"][1:]: |
| L.append(f" PC{c['pc']} ({c['variance_share']:.0%}): {c['angle']:.0f}° from the axis") |
| L.append("") |
| if R["pairs"]: |
| L += ["─" * 66, " 5. DIFFERENCES BETWEEN TEXTS", "─" * 66] |
| for a, b, c in R["pairs"]: |
| L.append(f" {b} vs {a}: {c['diff']:+.1f} points ({'towards ' + B if c['diff'] > 0 else 'towards ' + A}) · " |
| f"Cohen's d = {c['cohen_d']:+.2f} ({size_label(c['cohen_d'])}) · permutation p = {c['p']:.4f}") |
| L.append("") |
| L += ["═" * 66, |
| " Scores computed in the full 768-dimensional space of all-mpnet-base-v2", |
| " (normalised embeddings). The 3D map is a reduced view for orientation only.", |
| "═" * 66] |
| return "\n".join(L) |
|
|
|
|
| def format_extremes(R): |
| A, B = R["name_a"], R["name_b"] |
| out = [] |
| for it in R["items"]: |
| if it["name"] == "Neutral baseline": |
| continue |
| out.append(f"### {it['name']}\n\n**Closest to {A}**\n") |
| out += [f"{k}. ({sc:.0f}%) {s}" for k, (s, sc) in enumerate(it["most_a"], 1)] |
| out.append(f"\n**Closest to {B}**\n") |
| out += [f"{k}. ({sc:.0f}%) {s}" for k, (s, sc) in enumerate(it["most_b"], 1)] |
| out.append("") |
| return "\n".join(out) |
|
|
|
|
| def results_table(R): |
| rows = [] |
| for it in R["items"]: |
| sp = it["spread"] |
| pa = it["pa"] or {"components": [{"angle": np.nan}], "axis_share": np.nan} |
| rows.append({"Text": it["name"], "Sentences": sp["n"], "Mean %": round(sp["mean"], 1), |
| "Median %": round(sp["median"], 1), "SD": round(sp["sd"], 1), |
| "IQR": round(sp["iqr"], 1), |
| f"Leaning {R['name_a']}": f"{sp['share_a']:.0%}", |
| "Neutral": f"{sp['share_neutral']:.0%}", |
| f"Leaning {R['name_b']}": f"{sp['share_b']:.0%}", |
| "Skew": round(sp["skew"], 2), |
| "PC1 angle °": round(pa["components"][0]["angle"], 0), |
| "Axis variance %": round(100 * pa["axis_share"], 1)}) |
| return pd.DataFrame(rows) |
|
|
|
|
| def sentences_csv(R): |
| rows = [] |
| for side, sents, E in [(R["name_a"], R["PA"], R["EA"]), (R["name_b"], R["PB"], R["EB"])]: |
| s = axis_scores(E, R["pole"]["cA"], R["pole"]["cB"]) |
| rows += [{"text": f"POLE: {side}", "sentence": x, "score_pct": round(float(v), 2), "categories": ""} |
| for x, v in zip(sents, s)] |
| for it in R["items"]: |
| rows += [{"text": it["name"], "sentence": x, "score_pct": round(float(v), 2), "categories": "; ".join(c)} |
| for x, v, c in zip(it["sentences"], it["scores"], it["categories"])] |
| f = tempfile.NamedTemporaryFile(delete=False, suffix="_sentence_scores.csv", mode="w", encoding="utf-8") |
| pd.DataFrame(rows).to_csv(f, index=False) |
| f.close() |
| return f.name |
|
|
|
|
| |
| |
| |
| PALETTE = ["#2a7f62", "#c0563f", "#3b6fb6", "#b08a1e", "#7a7a7a"] |
|
|
|
|
| def wrap(s, n=70): |
| words, lines, cur = s.split(), [], "" |
| for w in words: |
| if len(cur) + len(w) + 1 > n: |
| lines.append(cur) |
| cur = w |
| else: |
| cur = (cur + " " + w).strip() |
| lines.append(cur) |
| return "<br>".join(lines) |
|
|
|
|
| def distribution_plot(R): |
| import plotly.graph_objects as go |
| fig = go.Figure() |
| for k, it in enumerate(R["items"]): |
| fig.add_trace(go.Violin(x=it["scores"], name=f"{it['name']} ({len(it['scores'])})", |
| orientation="h", side="positive", points="all", pointpos=-0.4, |
| jitter=0.3, marker=dict(size=4, opacity=0.55), |
| line_color=PALETTE[k % len(PALETTE)], meanline_visible=True, |
| text=[wrap(s) for s in it["sentences"]], |
| hovertemplate="%{x:.0f}%<br>%{text}<extra></extra>")) |
| for x, label in [(0, R["name_a"]), (50, "midpoint"), (100, R["name_b"])]: |
| fig.add_vline(x=x, line_dash="dot" if x == 50 else "solid", line_color="#999", |
| annotation_text=label, annotation_position="top") |
| for x in (R["low"], R["high"]): |
| fig.add_vline(x=x, line_dash="dash", line_color="#ccc") |
| fig.update_layout(title="Distribution of sentences along the axis", |
| xaxis_title=f"← {R['name_a']} · position (%) · {R['name_b']} →", |
| height=180 + 120 * len(R["items"]), showlegend=False, |
| margin=dict(l=10, r=10, t=60, b=40)) |
| return fig |
|
|
|
|
| def map_3d(R): |
| """x = position on the axis (true scale); y, z = main dimensions of variation orthogonal to it.""" |
| import plotly.graph_objects as go |
| cA, cB = R["pole"]["cA"], R["pole"]["cB"] |
| d_hat = (cB - cA) / np.linalg.norm(cB - cA) |
| blocks = [(f"Pole: {R['name_a']}", R["PA"], R["EA"]), (f"Pole: {R['name_b']}", R["PB"], R["EB"])] |
| blocks += [(it["name"], it["sentences"], it["E"]) for it in R["items"]] |
| allE = np.vstack([b[2] for b in blocks]) |
| resid = allE - np.outer(allE @ d_hat, d_hat) |
| resid -= resid.mean(0) |
| _, _, Vt = np.linalg.svd(resid, full_matrices=False) |
| fig = go.Figure() |
| start = 0 |
| for k, (name, sents, E) in enumerate(blocks): |
| n = len(E) |
| sc = axis_scores(E, cA, cB) |
| yz = (resid[start:start + n]) @ Vt[:2].T |
| start += n |
| is_pole = name.startswith("Pole:") |
| colour = ("#2a7f62" if k == 0 else "#c0563f") if is_pole else PALETTE[(k - 2) % len(PALETTE)] |
| fig.add_trace(go.Scatter3d(x=sc, y=yz[:, 0], z=yz[:, 1], mode="markers", name=name, |
| marker=dict(size=6 if is_pole else 3.5, color=colour, |
| symbol="diamond" if is_pole else "circle", |
| opacity=0.9 if is_pole else 0.6), |
| text=[wrap(s) for s in sents], |
| hovertemplate="%{x:.0f}%<br>%{text}<extra>" + name + "</extra>")) |
| fig.update_layout(title="Semantic map: x = position on the axis; y, z = other main dimensions", |
| scene=dict(xaxis_title=f"{R['name_a']} ← axis % → {R['name_b']}", |
| yaxis_title="other dim. 1", zaxis_title="other dim. 2"), |
| height=640, margin=dict(l=0, r=0, t=50, b=0)) |
| return fig |
|
|
|
|
| |
| |
| |
| INTRO = """ |
| # SpatialDiscourseAnalysis v2 |
| Place the sentences of up to four texts on an evaluative axis defined by two sets of example sentences. |
| **Poles**: one sentence per line; avoid negations and keep both poles on the same topics and register, |
| so the axis captures stance rather than topic. **Texts**: paste running text or one sentence per line. |
| The optional **relevance filter** keeps only sentences matching an editable lexicon and reports what it kept. |
| Part of the [H4rmony Project](https://theh4rmonyproject.org). |
| """ |
|
|
|
|
| def run(name_a, poles_a, name_b, poles_b, |
| n1, t1, n2, t2, n3, t3, n4, t4, baseline, use_filter, lexicon, low, high): |
| if low >= high: |
| raise gr.Error("The lower band edge must be below the upper band edge.") |
| try: |
| R = analyse(name_a, poles_a, name_b, poles_b, |
| [(n1, t1), (n2, t2), (n3, t3), (n4, t4)], baseline, |
| use_filter, lexicon, float(low), float(high)) |
| except ValueError as e: |
| raise gr.Error(str(e)) |
| return ("```\n" + format_report(R) + "\n```", distribution_plot(R), map_3d(R), |
| results_table(R), format_extremes(R), sentences_csv(R)) |
|
|
|
|
| def build_ui(): |
| with gr.Blocks(title="SpatialDiscourseAnalysis v2") as demo: |
| gr.Markdown(INTRO) |
| with gr.Tab("1 · Poles"): |
| with gr.Row(): |
| with gr.Column(): |
| name_a = gr.Textbox(label="Pole A name", value="Ecologically aligned") |
| poles_a = gr.Textbox(label="Pole A sentences (one per line)", lines=14) |
| with gr.Column(): |
| name_b = gr.Textbox(label="Pole B name", value="Ecologically misaligned") |
| poles_b = gr.Textbox(label="Pole B sentences (one per line)", lines=14) |
| with gr.Tab("2 · Texts"): |
| texts = [] |
| for i in range(4): |
| with gr.Row(): |
| n = gr.Textbox(label=f"Text {i + 1} name", value=f"Text {i + 1}", scale=1) |
| t = gr.Textbox(label=f"Text {i + 1}" + (" (optional)" if i >= 1 else ""), lines=6, scale=4) |
| texts += [n, t] |
| baseline = gr.Textbox(label="Neutral baseline (optional): factual, stance-free text about the same subject", |
| lines=4) |
| with gr.Tab("3 · Settings"): |
| use_filter = gr.Checkbox(label="Apply relevance filter", value=False) |
| lexicon = gr.Textbox(label="Lexicon: 'Category: term, term*, multi word' · optional '| with: term, term' " |
| "requires a second term in the same sentence", |
| value=DEFAULT_LEXICON, lines=10) |
| with gr.Row(): |
| low = gr.Slider(5, 50, value=40, step=1, label=f"Leaning-A band edge (%)") |
| high = gr.Slider(50, 95, value=60, step=1, label=f"Leaning-B band edge (%)") |
| go_btn = gr.Button("Run analysis", variant="primary") |
| report = gr.Markdown() |
| dist = gr.Plot(label="Distribution along the axis") |
| map3d = gr.Plot(label="3D semantic map") |
| table = gr.Dataframe(label="Summary table") |
| extremes = gr.Markdown() |
| csv = gr.File(label="Per-sentence scores (CSV)") |
| go_btn.click(run, inputs=[name_a, poles_a, name_b, poles_b] + texts + [baseline, use_filter, lexicon, low, high], |
| outputs=[report, dist, map3d, table, extremes, csv]) |
| return demo |
|
|
|
|
| if gr is not None: |
| try: |
| get_model() |
| except Exception as e: |
| print("Model not preloaded:", e) |
| demo = build_ui() |
|
|
| if __name__ == "__main__" and gr is not None: |
| demo.launch() |
|
|
