Méthode et reproductibilité
Les deux pages voisines, Lexicométrie et Étiquetage morpho-syntaxique, avancent des nombres. Or un nombre que l'on ne peut refaire est une anecdote, non un résultat. Cette page réunit donc tout ce qu'il faut pour refaire ces nombres, à savoir les données identifiées, chaque règle de préparation et de calcul énoncée, les dictionnaires de décision au complet, le programme intégral et un mode d'emploi de vérification avec valeurs-témoins.
La chaîne, où rien n'est aléatoire ni appris, est déterministe de bout en bout. Deux exécutions sur les mêmes fichiers donnent les mêmes nombres, à la machine près. Un écart constaté tient le plus souvent à une différence entre les deux copies du texte, la nôtre et celle du lecteur (le programme signale tout écart de plus de 0,5 % sur le nombre de mots), sinon à une erreur, d'un côté ou de l'autre. Ouvrir un pli ne fait rien disparaître.
le contratCe que « reproductible » veut dire ici
La page ne vaut que si quatre conditions sont toutes remplies :
1. Données publiques. Le corpus est fait des transcriptions intégrales publiées sur ce site, et non d'un état privé du texte. Quiconque lit les mêmes pages part des mêmes octets.
2. Règles énoncées. Chaque transformation (ce qu'on retire, ce qu'on recolle, comment on découpe les mots et les phrases, comment on calcule) est écrite en toutes lettres dans le pli « Les règles, une à une », puis une seconde fois, sous forme exécutable, dans le programme.
3. Programme publié. Le pli « Le programme, intégral » contient le code complet du dépouillement, sans dépendance cachée, puisqu'il ne requiert que Python 3 et les bibliothèques de calcul numpy et scipy. La chaîne, sans modèle statistique appris ni tirage aléatoire, est déterministe.
4. Résultats confrontables. Le programme imprime, dans l'ordre, tous les tableaux des deux pages voisines. Le dernier pli donne des valeurs-témoins pour une vérification en cinq minutes.
Ce contrat entraîne une conséquence assumée. Lorsque la consolidation du programme a déplacé un chiffre d'un dixième par rapport à un premier dépouillement de travail, ce sont les pages qui ont été corrigées, jamais le programme qui a été ajusté pour retrouver un nombre. Le code fait foi.
les octets de départLes données, identifiées et contrôlées
Huit fichiers forment quatre strates. Les effectifs de la dernière colonne sont ceux qu'attend le programme, qui compare son propre décompte à ces valeurs et avertit si l'écart dépasse 0,5 %. Ce garde-fou détecte une copie divergente du texte.
| strate | volumes (transcriptions du site) | mots attendus |
|---|---|---|
| 1875 | Premier Essai t. II et t. III · Deuxième Essai t. II et t. III (2ᵉ éd.) | 376 259 |
| 1885-1886 | Esquisse, t. I et t. II | 399 690 |
| 1903 | Le Personnalisme (avec l'Étude) | 174 042 |
| 1892 | Troisième Essai, t. I (2ᵉ éd.) | 88 913 |
Ce qui est retiré avant tout comptage comprend l'en-tête technique de chaque fichier, la notice d'édition, le balisage des titres de chapitres, les marqueurs de pagination, les appels de note numériques (ceux de la forme [^p246-1] ne sont pas retirés et laissent chacun un jeton parasite « p », environ 0,1 % du texte) et les marques typographiques d'italique. Ce qui est gardé englobe tout le texte de Renouvier, préfaces, formulaires et citations d'autrui compris.
Ce qui est recollé. Les transcriptions coupent des mots en trois circonstances, toutes réparées avant comptage (le programme publié n'imprime pas ces nombres de cas ; on les obtient en comptant les substitutions de chaque règle).
| règle | motif | exemple | cas |
|---|---|---|---|
| a | tiret devant un marqueur de page | « probable- [p. 71] ment » | 215 |
| b | tiret en fin de ligne | « déduc-⏎tions » | 108 |
| c | marqueur de page enclavé dans le mot | « mouve[p. 218]ment » | 506 |
La règle c est de loin la plus fréquente, et la plus insidieuse. Sans elle, 506 mots deviendraient 1 012 fragments, dont des dizaines de faux « ment » isolés. On ne soupçonne ce genre de défaut qu'en inspectant ses propres résidus. Nous l'avons trouvé parce qu'un premier comptage donnait 49 occurrences du « mot » ment.
la chaîneLes règles, une à une
Découpage en mots. Un mot est une suite de lettres, traits d'union internes compris (peut-être, c'est-à-dire restent entiers), apostrophe finale comprise pour les élisions. Trois normalisations d'époque détachent les élisions (l'espace → l' + espace), dénouent le trait d'union du XIXᵉ siècle après très- (très-grand → très grand) et rendent les inversions verbe-pronom à leurs mots (est-il → est + il, a-t-on → a + on), sans quoi tout pronom inversé échapperait au comptage des personnes. Tous les comptages se font en minuscules.
Découpage en phrases. Après protection d'une liste close d'abréviations (M., MM., Mme, Mlle, St, etc., ch., liv., art., sect., vol., t., p., pp., fig., no, cf., ibid., op., cit., trad., éd., Voy., les initiales isolées et le signe §), le texte est coupé après point, point d'interrogation, point d'exclamation ou points de suspension suivis d'une majuscule ou d'un guillemet ouvrant. Seules comptent les phrases d'au moins dix lettres. Les erreurs résiduelles de ce découpage, non mesurées, sont supposées peser à peu près également sur les quatre strates, et donc peu sur les écarts entre elles, qui seuls sont interprétés.
Fréquences. Toute fréquence est rapportée pour 10 000 mots de la strate. Les regroupements (force(s), je, j') sont indiqués sur la ligne même du tableau qui les utilise, ce qui exclut toute lemmatisation cachée.
Richesse lexicale. Nombre moyen de mots différents par tranches consécutives de 10 000 mots, seule façon de comparer des livres de tailles différentes, la richesse brute croissant mécaniquement avec la taille.
Spécificités. Méthode hypergéométrique de Lafon (1980). Soit un mot de fréquence totale K dans la réunion des trois strates (N mots) et de fréquence k dans une strate de taille n. S'il y est sur-représenté, on calcule la probabilité d'observer au moins k occurrences en tirant n mots sans remise parmi N ; s'il y est sous-représenté, la probabilité d'en observer au plus k. L'indice publié est S = ±log₁₀ de cette probabilité, positif en cas de sur-représentation. Le seuil de calcul est K ≥ 20, le seuil d'affichage S ≥ 8 pour les palmarès, qui ne retiennent que les sur-représentations (les valeurs négatives, comme S = −46 pour création en 1875, sont calculées mais non imprimées). La strate de contrôle de 1892 n'entre ni dans N ni dans aucun calcul de spécificité.
Étiquetage. Trois voies se succèdent, d'abord les classes fermées (listes exhaustives du pli suivant), puis les désinences verbales sûres avec dictionnaires d'exceptions, enfin les formes en -ment par règles suffixales et listes. Toute forme non couverte reste sans étiquette ; le taux de couverture est publié (58-59 % selon la strate), ainsi que le résidu.
Delta de Burrows. Chaque strate est découpée en segments consécutifs de 20 000 mots (18 segments pour 1875, 19 pour 1886, 8 pour 1903, 4 pour 1892). On mesure dans chaque segment la fréquence des 120 mots-outils les plus fréquents du corpus commun ; chaque mot-outil est centré-réduit sur l'ensemble des segments, ceux de 1892 compris ; la distance entre deux segments est la moyenne des écarts absolus. Chaque segment de 1892 reçoit la date de la strate dont le profil moyen lui est le plus proche. Le programme imprime à chaque exécution la liste exacte des 120 mots-outils, formes les plus fréquentes des trois strates datées parmi une liste fermée de 178 mots grammaticaux (FERMEES), établie à la main.
les décisionsLes dictionnaires, complets par construction
Le principe veut qu'aucune décision de classement n'existe hors du programme. Les listes que l'on lit dans le code du pli suivant sont la totalité des décisions, et non des extraits d'un ensemble plus vaste. Suit leur inventaire.
| ensemble | rôle | formes |
|---|---|---|
| EXCL_AIT | faux imparfaits écartés (fait, sait, parfait…) | 33 |
| IMP_RAIT | imparfaits des verbes en -rer (considérait, durait…) | 69 |
| COND_X | conditionnels hors règle -erait (serait, faudrait…) | 128 |
| PS_OK | passés simples irréguliers (furent, prirent…) | 51 |
| PRES_ERENT | présents en -èrent et voisins écartés (diffèrent…) | 41 |
| EXCL_FUT / FUT_IRREG | faux futurs écartés / futurs irréguliers admis | 24 / 84 |
| NOM_MENT / V_MENT / ADV_X | noms, verbes, adverbes en -ment tranchés un à un | 132 / 30 / 48 |
| FERMEES | classes grammaticales fermées (couverture, mots-outils) | 178 |
Deux règles générales complètent ces listes, parce qu'elles sont sûres sans exception rencontrée dans ce corpus. Selon l'une, une forme en -erait est un conditionnel et une forme en -érait un imparfait (un seul e sépare considérerait de considérait) ; selon l'autre, les terminaisons adverbiales productives (-quement, -ellement, -amment, -ivement…) classent d'office. Chaque forme qui échappe aux règles et aux listes reste sans étiquette et grossit le résidu publié (918 occurrences en -ment, soit 0,088 % du corpus). Qui veut contester un classement n'a qu'un mot à chercher dans le code, où la décision figure nommément.
le juge de paixLe programme, intégral
Ci-dessous figure le programme complet, celui-là même qui a produit chaque nombre des deux pages voisines. Il requiert Python 3, numpy et scipy. Adapter la variable DOSSIER et, si besoin, les noms de fichiers du dictionnaire FICHIERS aux chemins locaux des transcriptions. L'exécution prend quelques dizaines de secondes et imprime tous les tableaux, dans l'ordre des pages.
Télécharger le fichier : depouillement.py (servi tel quel, identique octet pour octet au code reproduit ci-dessous). Le télécharger plutôt que le copier évite toute altération à la transcription.
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# ============================================================================
# Dépouillement lexicométrique et morpho-syntaxique du corpus Renouvier
# — programme source des pages « Lexicométrie » et « Étiquetage
# morpho-syntaxique » de renouvier-papers.github.io.
#
# Dépendances : Python 3, numpy, scipy. Aucun aléa, aucun modèle appris :
# deux exécutions sur les mêmes fichiers donnent les mêmes nombres.
#
# Données : les transcriptions intégrales publiées sur le site. Adapter
# DOSSIER et FICHIERS aux chemins locaux ; les volumes s'identifient par
# leur notice de tête. Le programme vérifie les effectifs attendus et
# avertit si les fichiers diffèrent de ceux du dépouillement d'origine.
# ============================================================================
import re, math, statistics, itertools
from collections import Counter
import numpy as np
from scipy.stats import hypergeom
DOSSIER = "/mnt/project"
FICHIERS = { # strate -> liste de fichiers (transcriptions du site)
"1875": ["essai-1-tome-2.md", "essai-1-tome-3.md",
"essai-2-tome-2.md", "essai-2-tome-3.md"],
"1886": ["esquisse-tome-1.md", "esquisse-tome-2.md"],
"1903": ["personnalisme.md"],
"1892": ["essai-3-tome-1.md"], # point de contrôle
}
ORDRE = ["1875", "1886", "1903", "1892"]
TOKENS_ATTENDUS = {"1875": 376259, "1886": 399690, "1903": 174042, "1892": 88913}
# ----------------------------------------------------------------------------
# 1. NETTOYAGE — ce qui est retiré, ce qui est recollé
# ----------------------------------------------------------------------------
def nettoie(t):
t = re.sub(r'^---\n.*?\n---\n', '', t, flags=re.S) # en-tête du fichier
t = re.sub(r'^>.*$', '', t, flags=re.M) # notice d'édition
t = re.sub(r'^#{1,6} .*$', '', t, flags=re.M) # balisage des titres
# recollage des mots coupés :
# a) tiret + marqueur de page : « probable- [p. 71] ment »
t = re.sub(r'([A-Za-zà-ÿ])-\s*\[p\.\s*[^\]]{1,14}\]\s*([a-zà-ÿ])', r'\1\2', t)
# b) tiret + fin de ligne : « déduc-\ntions »
t = re.sub(r'([A-Za-zà-ÿ])-\n\s*([a-zà-ÿ])', r'\1\2', t)
# c) marqueur de page enclavé : « mouve[p. 218]ment »
t = re.sub(r'([a-zà-ÿ])\[p\.\s*[^\]]{1,14}\]([a-zà-ÿ])', r'\1\2', t)
t = re.sub(r'\[p\.\s*[^\]]{1,14}\]', ' ', t) # marqueurs de page
t = re.sub(r'\[\^?[0-9]{1,3}\]', ' ', t) # appels de note
t = t.replace('*', '').replace('_', '') # marques d'italique
t = re.sub(r'^\s*-{3,}\s*$', ' ', t, flags=re.M) # filets
return t
# ----------------------------------------------------------------------------
# 2. TOKENISATION — règles publiées telles quelles
# ----------------------------------------------------------------------------
ENCLITIQUES = r"(?:je|tu|il|elle|on|nous|vous|ils|elles|ce|en|y|moi|toi|le|la|les|lui|leur)"
def tokenise(t):
t = t.replace('\u2019', "'") # apostrophe courbe
t = re.sub(r'\b([Tt]rès)-(?=[a-zà-ÿ])', r'\1 ', t) # très-grand -> très grand
t = re.sub(r'([a-zà-ÿ])-t-(' + ENCLITIQUES + r')\b', r'\1 \2', t) # a-t-on
t = re.sub(r'([a-zà-ÿ])-(' + ENCLITIQUES + r')\b', r'\1 \2', t) # est-il
# token = lettres, traits d'union internes, apostrophe finale d'élision
return re.findall(r"[A-Za-zÀ-ÿ]+(?:-[A-Za-zÀ-ÿ]+)*'?", t)
TXT, LOW = {}, {}
for s in ORDRE:
brut = "\n".join(open(f"{DOSSIER}/{f}", encoding="utf-8", errors="replace").read()
for f in FICHIERS[s])
TXT[s] = nettoie(brut)
LOW[s] = [w.lower() for w in tokenise(TXT[s])]
C = {s: Counter(LOW[s]) for s in ORDRE}
N = {s: len(LOW[s]) for s in ORDRE}
for s in ORDRE:
ecart = abs(N[s] - TOKENS_ATTENDUS[s]) / TOKENS_ATTENDUS[s]
if ecart > 0.005:
print(f"!! {s} : {N[s]} tokens, attendu ~{TOKENS_ATTENDUS[s]} — fichiers différents ?")
def f10k(s, *mots):
return sum(C[s][m] for m in mots) / N[s] * 10000
def tab(titre, lignes, cols=ORDRE):
print("\n== " + titre + " ==")
for nom, vals in lignes:
print(f" {nom:26s} " + " ".join(f"{v:8.1f}" if isinstance(v, float) else f"{v:>8}" for v in vals))
# ----------------------------------------------------------------------------
# 3. MESURES DE BASE (richesse par tranches de 10 000 mots)
# ----------------------------------------------------------------------------
print("== BASE ==")
for s in ORDRE:
toks = LOW[s]
tranches = [toks[i:i+10000] for i in range(0, N[s]-10000+1, 10000)]
sttr = statistics.mean(len(set(tr))/10000 for tr in tranches)
print(f" {s} : {N[s]:>7} tokens · {len(set(toks)):>6} types · STTR {sttr:.3f} · "
f"lg. mot {sum(map(len,toks))/N[s]:.2f}")
# ----------------------------------------------------------------------------
# 4. PHRASES (abréviations protégées avant la coupe)
# ----------------------------------------------------------------------------
ABREV = (r"(?:M|MM|Mme|Mlle|St|etc|ch|liv|art|sect|vol|t|p|pp|fig|no|n|cf|Ibid|ibid|"
r"op|cit|trad|éd|Voy|V|C|J|A|B|D|E|F|G|H|I|K|L|N|O|P|Q|R|S|T|U|X|§)")
print("== PHRASES ==")
for s in ORDRE:
t = re.sub(r'\b' + ABREV + r'\.', lambda m: m.group(0).replace('.', '§'), TXT[s])
t = re.sub(r'\s+', ' ', t)
ph = [p for p in re.split(r'(?<=[.!?…])\s+(?=[«"A-ZÀ-Ý])', t)
if len(re.findall(r"[A-Za-zÀ-ÿ]", p)) >= 10]
lg = [len(tokenise(p)) for p in ph]
print(f" {s} : {len(ph):>5} phrases · moyenne {statistics.mean(lg):.1f} · "
f"médiane {statistics.median(lg):.0f}")
# ----------------------------------------------------------------------------
# 5. SPÉCIFICITÉS (Lafon ; hypergéométrique ; S = ±log10 p ; seuil K >= 20)
# Strates 1875, 1886, 1903 seulement — 1892 n'entre dans aucun calcul.
# ----------------------------------------------------------------------------
TROIS = ["1875", "1886", "1903"]
Ntot = sum(N[s] for s in TROIS)
Ftot = Counter()
for s in TROIS:
Ftot.update(C[s])
SPEC = {}
for s in TROIS:
d = {}
for w, K in Ftot.items():
if K < 20:
continue
k = C[s][w]
p_sur = hypergeom.sf(k-1, Ntot, K, N[s])
p_sous = hypergeom.cdf(k, Ntot, K, N[s])
d[w] = (-math.log10(max(p_sur, 1e-300)) if p_sur < p_sous
else math.log10(max(p_sous, 1e-300)))
SPEC[s] = d
STOP = set(("de la le les l' un une des du au aux et ou mais or ni car donc à en dans par "
"pour sur avec sans sous chez entre vers contre selon que qu' qui quoi dont où si comme "
"quand est sont était été être a ont avait avoir il elle on nous vous ils elles je tu ce "
"cette ces cet se ne n' pas point plus moins très bien tout toute tous toutes d' s' c' j' "
"m' t' y ainsi aussi même mêmes autre autres leur leurs son sa ses mon ma mes notre nos "
"votre vos peut peuvent fait faire deux trois premier première second seconde là ici "
"encore déjà toujours jamais rien quelque quelques chose choses celui celle ceux celles "
"lui eux soi cela ça alors puis enfin cependant néanmoins toutefois pourtant après avant "
"depuis pendant lorsque puisque quoique afin parce").split())
print("== SPÉCIFICITÉS (mots pleins, S >= 8) ==")
for s in TROIS:
sur = sorted(((v, w) for w, v in SPEC[s].items() if v >= 8 and w not in STOP),
reverse=True)[:22]
print(f" ++{s} : " + " · ".join(f"{w}({v:.0f})" for v, w in sur))
# ----------------------------------------------------------------------------
# 6. TRAJECTOIRES /10 000 mots (regroupements indiqués sur la ligne)
# ----------------------------------------------------------------------------
GROUPES = {
"catégorie(s)": ("catégorie", "catégories"), "représentation(s)": ("représentation", "représentations"),
"fonction(s)": ("fonction", "fonctions"), "science(s)": ("science", "sciences"),
"vérité(s)": ("vérité", "vérités"), "certitude": ("certitude",),
"dieu": ("dieu",), "création": ("création",), "créateur": ("créateur",),
"péché": ("péché",), "mal": ("mal",),
"corps": ("corps",), "force(s)": ("force", "forces"), "matière": ("matière",),
"monade(s)": ("monade", "monades"),
"liberté": ("liberté",), "volonté(s)": ("volonté", "volontés"),
"croyance(s)": ("croyance", "croyances"), "infini*": ("infini", "infinie", "infinis", "infinies"),
"nécessité": ("nécessité",), "conscience(s)": ("conscience", "consciences"),
"personne(s)": ("personne", "personnes"), "personnalisme": ("personnalisme",),
}
tab("TRAJECTOIRES /10k (1875 1886 1903 1892)",
[(nom, [f10k(s, *mots) for s in ORDRE]) for nom, mots in GROUPES.items()])
# ----------------------------------------------------------------------------
# 7. GRAMMAIRE : personnes, négation, connecteurs, ponctuation
# ----------------------------------------------------------------------------
tab("PERSONNES /10k", [
("je, j'", [f10k(s, "je", "j'") for s in ORDRE]),
("me, m', moi", [f10k(s, "me", "m'", "moi") for s in ORDRE]),
("nous", [f10k(s, "nous") for s in ORDRE]),
("on", [f10k(s, "on") for s in ORDRE]),
("il, ils", [f10k(s, "il", "ils") for s in ORDRE]),
])
print("\n== NÉGATION (forme dans les 5 mots après ne/n') ==")
for s in ORDRE:
toks = LOW[s]; d = Counter()
for i, w in enumerate(toks):
if w in ("ne", "n'"):
for fme in ("pas", "point", "plus", "jamais", "rien"):
if fme in toks[i+1:i+6]:
d[fme] += 1
break
tot = d["pas"] + d["point"]
print(f" {s} : pas {d['pas']} · point {d['point']} ({d['point']/tot*100:.1f} %) · "
f"ne/10k {sum(1 for w in toks if w in ('ne',chr(110)+chr(39)))/N[s]*10000:.0f}")
BIG = {s: Counter(zip(LOW[s], LOW[s][1:])) for s in ORDRE}
def conn(s, *unites):
n = 0
for u in unites:
n += BIG[s][tuple(u.split())] if " " in u else C[s][u]
return n / N[s] * 10000
CONNECTEURS = {"donc": ("donc",), "or": ("or",), "car": ("car",), "mais": ("mais",),
"si": ("si",), "ainsi": ("ainsi",), "cependant": ("cependant",),
"pourtant": ("pourtant",), "parce que": ("parce que",),
"en effet": ("en effet",), "au contraire": ("au contraire",),
"lorsque": ("lorsque", "lorsqu'"), "c'est-à-dire": ("c' est-à-dire",),
"d'ailleurs": ("d' ailleurs",)}
tab("CONNECTEURS /10k", [(nom, [conn(s, *u) for s in ORDRE]) for nom, u in CONNECTEURS.items()])
print("\n== PONCTUATION /10k ==")
for s in ORDRE:
print(f" {s} : ? {TXT[s].count('?')/N[s]*10000:5.1f} ! {TXT[s].count('!')/N[s]*10000:4.1f} "
f"; {TXT[s].count(';')/N[s]*10000:5.1f} : {TXT[s].count(':')/N[s]*10000:5.1f}")
# ----------------------------------------------------------------------------
# 8. ÉTIQUETAGE — dictionnaires de décision COMPLETS
# ----------------------------------------------------------------------------
EXCL_AIT = set("""fait ait sait aient parfait satisfait imparfait bienfait forfait méfait
souhait souhaits lait attrait attraits trait traits portrait portraits extrait extraits
abstrait abstraits soustrait retrait retraits distrait plait parait surfait refait
contrefait stupéfait""".split())
IMP_RAIT = set("""considérait opérait espérait désespérait exagérait tolérait libérait
générait conférait déférait préférait différait persévérait coopérait adhérait révérait
vénérait altérait désirait admirait tirait attirait retirait inspirait respirait
soupirait expirait aspirait empirait virait déchirait durait figurait mesurait assurait
murmurait procurait jurait demeurait éclairait comparait déclarait ignorait séparait
préparait montrait entrait rencontrait pénétrait montraient entraient considéraient
duraient figuraient demeuraient déclaraient ignoraient tiraient attiraient désiraient
admiraient offrait offraient découvrait démontrait souffrait ouvrait couvrait
recouvrait""".split())
COND_X = set("""serait seraient aurait auraient pourrait pourraient saurait sauraient
faudrait devrait devraient voudrait voudraient ferait feraient dirait diraient irait
iraient verrait verraient viendrait viendraient tiendrait mettrait mettraient prendrait
prendraient rendrait rendraient vaudrait vaudraient croirait croiraient suffirait
suffiraient agirait finirait choisirait servirait sortirait partirait ouvrirait
offrirait réussirait jouirait subirait unirait fournirait établirait établiraient
conviendrait deviendrait deviendraient connaîtrait connaîtraient paraîtrait
apparaîtrait disparaîtrait mourrait courrait sentirait consentirait appartiendrait
obtiendrait soutiendrait contiendrait maintiendrait comprendrait apprendrait
reprendrait entreprendrait attendrait entendrait perdrait répondrait correspondrait
suivrait vivrait écrirait produirait conduirait réduirait introduirait construirait
détruirait traduirait plairait déplairait permettrait concevrait reviendrait
produiraient parviendrait évanouirait tendrait permettraient admettrait démentirait
étendrait conduiraient tiendraient serviraient prétendrait conclurait paraîtraient
appartiendraient suivraient soumettrait résoudrait déduirait dépendrait naîtraient
obéirait reconnaîtraient reconnaîtrait aboutiraient introduiraient régirait ensuivrait
correspondraient équivaudrait définirait découvrirait défendrait descendrait
admettraient concluraient""".split())
PS_OK = set("""furent firent eurent purent durent vinrent tinrent prirent mirent virent
dirent surent voulurent connurent parurent reçurent crurent devinrent obtinrent
naquirent moururent vécurent suivirent servirent sentirent partirent sortirent
ouvrirent offrirent réussirent choisirent finirent établirent réunirent définirent
produisirent conduisirent introduisirent construisirent détruisirent écrivirent
comprirent apprirent reprirent entreprirent attendirent entendirent répondirent
perdirent rendirent descendirent""".split())
PRES_ERENT = set("""diffèrent demeurent tirent figurent suggèrent opèrent concourent
altèrent meurent attirent acquièrent mesurent éclairent considèrent préfèrent espèrent
tolèrent libèrent exagèrent digèrent insèrent coopèrent adhèrent révèrent vénèrent
réfèrent confèrent transfèrent persévèrent désespèrent gèrent cèdent secourent courent
parcourent discourent recourent conquièrent requièrent assurent réclament""".split())
EXCL_FUT = set("""vrai vrais barbara considérons ignorons comparons préparons désirons
admirons honorons mesurons assurons demeurons figurons tirons montrons rencontrons
entrons opérons espérons déclarons séparons adorons restaurons""".split())
FUT_IRREG = set("""sera seront serai serons serez aura auront aurai aurons aurez pourra
pourront pourrai pourrons ira iront irai irons fera feront ferai ferons ferez devra
devront devrai devrons dira diront dirai dirons direz faudra vaudra voudra voudront
viendra viendront tiendra tiendront verra verront verrai verrons saura sauront saurai
saurons mettra mettront prendra prendront rendra rendront comprendra apprendra
deviendra deviendront conviendra connaîtra connaîtront paraîtra apparaîtra recevra
recevront croira croiront vivra vivront suivra suivront écrira écriront répondra
attendra entendra perdra perdront enverra enverrons offriront souffriront ouvriront
découvriront""".split())
def cl_verbe(w):
"""Étiquette IMP / COND / FUT / PS, ou None (forme laissée sans étiquette)."""
if w in EXCL_AIT or w in PRES_ERENT:
return None
if w.endswith(("erait", "eraient")): # trouver+ait : conditionnel sûr
return "COND"
if w.endswith(("érait", "éraient")): # considér+ait : imparfait sûr
return "IMP"
if w in COND_X:
return "COND"
if w in IMP_RAIT:
return "IMP"
if w.endswith(("ait", "aient")) and not w.endswith(("rait", "raient")):
return "IMP"
if w in PS_OK or w.endswith("èrent"):
return "PS"
if w in FUT_IRREG:
return "FUT"
if w not in EXCL_FUT and re.search(r"(erai|eras|era|erons|erez|eront)$", w):
return "FUT"
return None
NOM_MENT = set("""mouvement sentiment comment développement moment jugement fondement
entendement commencement changement raisonnement établissement argument élément
enchaînement événement rapprochement consentement enseignement gouvernement
département comportement instrument monument document testament tempérament firmament
ornement fragment segment complément supplément appartement traitement vêtement
châtiment compartiment aliment ciment sacrement serment ferment tourment régiment
sédiment rudiment empêchement éclaircissement dévouement déroulement arrangement
enveloppement perfectionnement affranchissement avancement détriment rayonnement
recueillement accomplissement accroissement affaiblissement agrandissement amendement
acharnement anéantissement apaisement assentiment assujettissement attachement
balancement bouleversement classement commandement dédommagement dénombrement
dénouement déplacement dérangement détachement discernement écartement écoulement
effacement égarement élancement éloignement emportement encouragement engagement
enlèvement entraînement envahissement épanouissement étonnement évanouissement
excrément fonctionnement froissement gémissement groupement isolement jaillissement
licenciement ligament mécontentement ménagement morcellement pansement parlement
payement pressentiment prolongement raffinement ralentissement rassemblement
rattachement redoublement refroidissement relâchement remaniement renoncement
renouvellement renversement retentissement retranchement revirement roulement
soulèvement tremblement tâtonnement vieillissement""".split())
V_MENT = set("""forment ment mentent aiment arment calment charment confirment déforment
dorment enferment estiment expriment ferment germent impriment infirment informent
priment réforment renferment réaffirment suppriment transforment affirment animent
réclament proclament acclament déclament""".split())
ADV_X = set("""seulement autrement simplement proprement absolument vraiment
immédiatement certainement indéfiniment nullement infiniment nettement réciproquement
non-seulement justement complètement complétement librement fortement pratiquement
facilement pleinement difficilement légitimement diversement manifestement vainement
rarement extrêmement franchement uniquement hardiment indissolublement brièvement
parallèlement naïvement longuement rapidement pareillement ouvertement secondement
résolument grandement fermement premièrement deuxièmement troisièmement
dernièrement""".split())
def cl_ment(w):
"""Étiquette ADV / NOM / V pour les formes en -ment, ou None (résidu compté)."""
if not w.endswith("ment") or len(w) < 5:
return None
if w in V_MENT:
return "V"
if w in NOM_MENT:
return "NOM"
if w in ADV_X or w.endswith(("amment", "emment", "quement", "ellement", "alement",
"iblement", "ablement", "ivement", "eusement", "airement", "èrement",
"ièrement", "ûrement", "itement", "ctement", "ément")):
return "ADV"
return "RESIDU"
print("\n== TEMPS/MODES /10k (IMP COND FUT PS) et -MENT /10k (ADV NOM) ==")
residu_ment = 0
for s in ORDRE:
dv, dm = Counter(), Counter()
for w in LOW[s]:
e = cl_verbe(w)
if e:
dv[e] += 1
m = cl_ment(w)
if m == "RESIDU":
residu_ment += 1
elif m:
dm[m] += 1
print(f" {s} : IMP {dv['IMP']/N[s]*1e4:5.1f} COND {dv['COND']/N[s]*1e4:5.1f} "
f"FUT {dv['FUT']/N[s]*1e4:5.1f} PS {dv['PS']/N[s]*1e4:4.1f} | "
f"ADV {dm['ADV']/N[s]*1e4:6.1f} NOM {dm['NOM']/N[s]*1e4:5.1f}")
print(f" résidu -ment non classé : {residu_ment} occ. "
f"({residu_ment/sum(N.values())*100:.3f} % des tokens)")
# ----------------------------------------------------------------------------
# 9. COUVERTURE + DELTA DE BURROWS + DATATION DE 1892
# ----------------------------------------------------------------------------
FERMEES = set("""le la les l' un une des du au aux ce cet cette ces mon ma mes ton ta tes
son sa ses notre nos votre vos leur leurs quel quelle quels quelles chaque plusieurs
quelques aucun aucune nul nulle tout toute tous toutes je tu il elle on nous vous ils
elles me m' te t' se s' moi toi soi lui eux y en de d' à dans par pour sur avec sans
sous chez entre vers contre selon malgré parmi envers hors dès depuis pendant durant
devant derrière après avant jusque jusqu' outre et ou mais or ni car donc que qu' qui
dont où si comme quand lorsque lorsqu' puisque puisqu' quoique quoiqu' ne n' pas point
plus jamais rien guère est sont était étaient être été sera seront serait seraient
soit soient fut furent a ont avait avaient avoir eu aura auront aurait auraient ait
aient eut eurent c' j' très bien peu ainsi aussi encore déjà toujours alors puis enfin
cependant néanmoins toutefois pourtant même mêmes autre autres tel telle tels
telles""".split())
print("\n== COUVERTURE (classes fermées + paradigmes + -ment classés) ==")
for s in ORDRE:
n_ok = sum(1 for w in LOW[s]
if w in FERMEES or cl_verbe(w) or cl_ment(w) in ("ADV", "NOM", "V"))
print(f" {s} : {n_ok/N[s]*100:.1f} %")
Ctot = Counter()
for s in TROIS:
Ctot.update(LOW[s])
MOTS_OUTILS = [w for w, _ in Ctot.most_common(400) if w in FERMEES][:120]
segments, etiquettes = [], []
for s in ORDRE:
toks = LOW[s]
for i in range(0, len(toks) - 20000 + 1, 20000):
c = Counter(toks[i:i+20000])
segments.append([c[w] / 20000 * 1000 for w in MOTS_OUTILS])
etiquettes.append(s)
X = np.array(segments)
Z = (X - X.mean(0)) / (X.std(0) + 1e-9)
idx = {s: [i for i, l in enumerate(etiquettes) if l == s] for s in ORDRE}
def delta(a, b):
return float(np.mean(np.abs(Z[a] - Z[b])))
print("\n== DELTA DE BURROWS (segments de 20 000 mots ; 120 mots-outils) ==")
print(" mots-outils :", " ".join(MOTS_OUTILS))
for s in TROIS:
print(f" intra-{s} : "
f"{statistics.mean(delta(a,b) for a,b in itertools.combinations(idx[s],2)):.3f}")
for s1, s2 in [("1875", "1886"), ("1886", "1903"), ("1875", "1903")]:
print(f" {s1} <-> {s2} : "
f"{statistics.mean(delta(a,b) for a in idx[s1] for b in idx[s2]):.3f}")
centres = {s: Z[idx[s]].mean(0) for s in TROIS}
print(" -- datation des segments de 1892 --")
for k, i in enumerate(idx["1892"]):
d = {s: float(np.mean(np.abs(Z[i] - centres[s]))) for s in TROIS}
print(f" 1892-{k+1} : " + " ".join(f"{s} {d[s]:.3f}" for s in TROIS)
+ f" -> {min(d, key=d.get)}")
en cinq minutesVérifier — mode d'emploi et valeurs-témoins
1. Récupérer les huit transcriptions au format Markdown dans le dépôt du site (docs/oeuvres/essais/premier/tome-2.md et tome-3.md, docs/oeuvres/essais/deuxieme/tome-2.md et tome-3.md, docs/oeuvres/autres/esquisse/tome-1.md et tome-2.md, docs/oeuvres/autres/personnalisme.md, docs/oeuvres/essais/troisieme/tome-1.md) et les enregistrer sous les noms que leur donne FICHIERS dans le programme (essai-1-tome-2.md, etc.). 2. Télécharger depouillement.py (ou copier le programme du pli précédent) ; régler DOSSIER. 3. Exécuter python3 depouillement.py. 4. Confronter la sortie aux tableaux des deux pages ou, plus vite, aux témoins ci-dessous, choisis pour couvrir toute la chaîne (préparation, lexique, grammaire, stylométrie).
| témoin | valeur attendue |
|---|---|
| mots de la strate 1875 | 376 259 |
| longueur moyenne de phrase, 1885-1886 | 49,5 mots |
| spécificité de corps en 1903 | S = 126 |
| je, j' pour 10 000 mots en 1903 | 5,4 |
| part de ne… point en 1875 | 17,5 % |
| conditionnel pour 10 000 mots en 1875 | 50,5 |
| Delta 1875 ↔ 1903 | 1,279 |
| datation des 4 segments de 1892 | 1875 · 1875 · 1875 · 1886 |
Un écart sur les mots de la strate signale des fichiers différents (le programme l'aura déjà dit) ; un écart ailleurs, à fichiers identiques, indique une erreur, d'un côté ou de l'autre, et mérite d'être signalé, car ces pages s'amendent ainsi. Les limites de fond, elles, restent celles qu'énoncent les deux pages, à savoir les citations d'autrui comptées avec leur hôte, les ambiguïtés assumées (il impersonnel, que non ventilé) et une couverture d'étiquetage de 59 % par choix de certitude. La reproductibilité ne rend pas ces choix indiscutables, mais discutables avec précision.
Note de méthode
Cette page suit les règles des dépliants de la sous-section « Œuvres à déplier », Compliquer les Essais pour les expliquer et La physique du personnalisme. Le pli y conserve tout, les voies non prises restent visibles, la profondeur se compte aux filets et le parcours se souvient.
Elle en ajoute une qui lui est propre, selon laquelle tout ce qui y est décrit s'exécute ; le programme publié est celui qui produit les nombres des deux pages voisines, et chacun peut le vérifier sur les transcriptions du site.
Sources. Transcriptions intégrales de ce site (huit volumes, listés au pli « Les données »). Méthode des spécificités : P. Lafon, « Sur la variabilité de la fréquence des formes dans un corpus », Mots, 1, 1980. Delta : J. F. Burrows, « 'Delta' : a Measure of Stylistic Difference and a Guide to Likely Authorship », Literary and Linguistic Computing, 17, 2002.