From 552217dad4f26652d71d162f4ec1700c3929de2a Mon Sep 17 00:00:00 2001 From: Arnaud Rachez Date: Thu, 21 Aug 2025 19:38:24 +0900 Subject: [PATCH 1/4] maint: refactor retriever + ranker --- examples/baseline.ipynb | 42 +++- pyproject.toml | 7 +- setup.py | 12 - wsd/models/__init__.py | 6 +- wsd/models/{baseline.py => dictionary.py} | 253 ++++++++-------------- wsd/models/gemini.py | 25 +-- wsd/models/{basic.py => rankers.py} | 104 +++++++-- wsd/models/retrievers.py | 87 ++++++++ wsd/models/tests/test_baseline.py | 23 ++ wsd/parsers/__init__.py | 8 +- wsd/parsers/jmdict.py | 16 +- wsd/utils.py | 12 +- 12 files changed, 361 insertions(+), 234 deletions(-) delete mode 100644 setup.py rename wsd/models/{baseline.py => dictionary.py} (55%) rename wsd/models/{basic.py => rankers.py} (51%) create mode 100644 wsd/models/retrievers.py diff --git a/examples/baseline.ipynb b/examples/baseline.ipynb index 85bfb8f..46ce8f4 100644 --- a/examples/baseline.ipynb +++ b/examples/baseline.ipynb @@ -1,5 +1,15 @@ { "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, { "cell_type": "code", "execution_count": null, @@ -11,8 +21,7 @@ "from sklearn.linear_model import LogisticRegression\n", "from sklearn.model_selection import train_test_split\n", "\n", - "from wsd.models import JMDict, JMDictWithPointWiseRanking, \\\n", - " JMDictGeminiRanking\n", + "from wsd.models import JMDict, PointWiseRanker, GeminiRanker\n", "from wsd.utils import load_dataset, accuracy" ] }, @@ -23,10 +32,9 @@ "outputs": [], "source": [ "basedir = os.getenv('PJ_DIR')\n", - "X, y = load_dataset(f'{basedir}/data/dataset.xml')\n", - "X = [''.join(x) for x in X]\n", + "X, y = load_dataset(f'{basedir}/data/dataset_.xml')\n", "X_train, X_test, y_train, y_test = train_test_split(\n", - " X, y, test_size=0.33, random_state=42)" + " X, y, test_size=0.33, random_state=44)" ] }, { @@ -46,7 +54,8 @@ "outputs": [], "source": [ "model = LogisticRegression(C=10, penalty='l1', solver='liblinear')\n", - "jmdict_basic = JMDictWithPointWiseRanking(ranking_model=model)\n", + "ranker = PointWiseRanker(ranking_model=model)\n", + "jmdict_basic = JMDict(ranker=ranker)\n", "jmdict_basic.fit(X_train, y_train)\n", "basic_preds = jmdict_basic.predict(X_test)" ] @@ -57,7 +66,8 @@ "metadata": {}, "outputs": [], "source": [ - "jmdict_gemini = JMDictGeminiRanking(\"gemini-2.5-pro-exp-03-25\")\n", + "ranker = GeminiRanker(\"gemini-2.5-flash-lite\")\n", + "jmdict_gemini = JMDict(ranker=ranker)\n", "gemini_preds = jmdict_gemini.predict(X_test)" ] }, @@ -72,6 +82,24 @@ "print(f\"gemini\\t = {accuracy(gemini_preds, y_test):.2%}\")" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import joblib" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "joblib.dump(model, filename='../data/basic.joblib')" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/pyproject.toml b/pyproject.toml index 447bb7b..6b0de2c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -38,7 +38,7 @@ all = [ "numpy", "pillow", "rich", - "scikit-learn", + "scikit-learn==1.7.1", "typer", ] @@ -50,5 +50,6 @@ Issues = "https://github.com/linalgo/wsd/issues" requires = ["setuptools >= 61.0"] build-backend = "setuptools.build_meta" -[tool.setuptools] -packages = ["wsd"] +[tool.setuptools.packages.find] +where = ["."] +include = ["wsd*"] diff --git a/setup.py b/setup.py deleted file mode 100644 index b613543..0000000 --- a/setup.py +++ /dev/null @@ -1,12 +0,0 @@ -"""WSD package setup script.""" -import re - -from setuptools import find_packages, setup - -with open("pyproject.toml", encoding="utf-8") as file: - setup( - version=re.search( - r'^version\s*=\s*"(.*?)"', file.read(), re.M - ).group(1), - packages=find_packages(), - ) diff --git a/wsd/models/__init__.py b/wsd/models/__init__.py index 634eb66..48b97fe 100644 --- a/wsd/models/__init__.py +++ b/wsd/models/__init__.py @@ -1,4 +1,4 @@ """A collection of WSD models.""" -from .baseline import JMDict, Token # noqa: F401 -from .basic import JMDictWithPointWiseRanking # noqa: F401 -from .gemini import JMDictGeminiRanking # noqa: F401 +from .dictionary import * # noqa: F401 +from .rankers import * # noqa: F401 +from .retrievers import * # noqa: F401 diff --git a/wsd/models/baseline.py b/wsd/models/dictionary.py similarity index 55% rename from wsd/models/baseline.py rename to wsd/models/dictionary.py index 5538e37..8309094 100644 --- a/wsd/models/baseline.py +++ b/wsd/models/dictionary.py @@ -3,8 +3,6 @@ import json import os import uuid -from abc import ABC, abstractmethod -from collections import defaultdict from dataclasses import asdict, dataclass from typing import Any @@ -12,76 +10,57 @@ from fugashi import Tagger from linalgo.annotate import Annotation, Annotator, Document, Entity, Task -from wsd.parsers import JMDictParser -from wsd.parsers.jmdict import Entry +from wsd.parsers.jmdict import Entry, Token +from wsd.models.retrievers import Retriever, LocalRetriever +from wsd.models.rankers import Candidate, Ranker, DummyRanker, \ + PointWiseRanker, GeminiRanker -@dataclass -class Token: - """Token dataclass.""" - text: str = '' - lemma: str = '' - pos: str = '' +class Dictionary: + """A simple dictionary base class.""" + def __init__( + self, + retriever: Retriever = None, + ranker: Ranker = None, + annotator: Annotator = None + ): + self.retriever = retriever + self.ranker = ranker or DummyRanker() + self.annotator = annotator or Annotator( + id=uuid.uuid3(uuid.NAMESPACE_URL, 'jmdict-v3').hex, + name='jmdict-v3', + model='MACHINE', + entity=Entity(id=os.getenv('LINHUB_ENTITY')), + task=Task(id=os.getenv('LINHUB_TASK')) + ) -data_dir = os.path.join(os.path.dirname(__file__), '../../data') + def search(self, text: str, context=None) -> list[Entry]: + """Search for an entry by text and rank the results. + Currently returns all entries that contain the text in either the kanji + or reading. + """ + return self.ranker.rank(self.retriever.retrieve(text), context)[0] -class RankingModel(ABC): - """Base class for the ranking models""" + def feeling_lucky(self, text: str, context=None) -> Entry: + """Return the first entry found. - @abstractmethod - def _rank(self, candidates: list[Entry], context: Any): - """Rank results based on the given context. + Currently returns the first entry that contains the text in either the + kanji or reading. Parameters ---------- - candidates : List[Entry] - A list of entries to rank - context : any - The context to use for ranking + text : str + The text to search for Returns ------- - List[Entry] - The ranked list of entries + Entry + The first entry that contains the query. """ - raise NotImplementedError - - -class JMDict(RankingModel): - """A simple dictionary interface for JMDict.""" - - entries = None - indexed = False - - def __init__( - self, - dictionary: str = 'JMdict_en.gz', - annotator: Annotator = None - ): - self._index(os.path.join(data_dir, dictionary)) - self.annotator = annotator or Annotator( - id=uuid.uuid3(uuid.NAMESPACE_URL, 'jmdict-v3').hex, - name='jmdict-v3', - model='MACHINE', - entity=Entity(id=os.getenv('LINHUB_ENTITY')), - task=Task(id=os.getenv('LINHUB_TASK')) - ) - - def _index(self, filename): - """Create an index to speed up lookups.""" - if self.indexed: - return - self.index = defaultdict(set) - self.entries = JMDictParser.parse(filename) - for entry in self.entries: - self.index[entry.ent_seq] = entry - for k_ele in entry.k_ele: - self.index[k_ele.keb].add(entry) - for r_ele in entry.r_ele: - self.index[r_ele.reb].add(entry) - self.indexed = True + entries = self.search(text, context) + return entries[0] if entries else None def annotate( self, @@ -113,7 +92,8 @@ def annotate( if body is not None: a = Annotation( document=doc, - body=json.dumps(body, ensure_ascii=False).encode('utf-8'), + body=json.dumps( + body, ensure_ascii=False).encode('utf-8'), start=start, end=start + len(token.surface), annotator=self.annotator, @@ -126,7 +106,7 @@ def annotate( return documents[0] return documents - def tokenize(self, sentence) -> list[Token]: + def tokenize(self, sentence: str) -> list[Token]: """Tokenize a sentence. Parameters ---------- @@ -149,8 +129,35 @@ def tokenize(self, sentence) -> list[Token]: ) ) return tokens + + def fit(self, X: list[list[str]], y: list[list[str]]): + """Fit the ranker. - def predict(self, sentences: list[str]) -> list[str]: + Parameters + ---------- + X : list[list[Token]] + The tokenized documents to 'featurize'. + y : list[list[str]] + The list of list of labels for each tokens in the X sentences. + + Returns + ------- + self + The fitted dictionary. + """ + XX = [] + for doc in X: + xx = [] + for token in doc: + candidates = [] + for candidate in self.retriever.retrieve(token.lemma): + candidates.append(Candidate(candidate, token)) + xx.append(candidates) + XX.append(xx) + self.ranker.fit(XX, y) + return self + + def predict(self, sentences: list[str|Token]) -> list[str]: """Predict the `ent_seq` for each token in a sentence. Parameters @@ -168,7 +175,9 @@ def predict(self, sentences: list[str]) -> list[str]: preds = [] for sentence in tqdm.tqdm(sentences): pred = [] - for token in self.tokenize(sentence): + if isinstance(sentence, str): + sentence = self.tokenize(sentence) + for token in sentence: context = {'sentence': sentence, 'token': token} entry = self.feeling_lucky(token.lemma, context) ent_seq = entry.ent_seq if entry else None @@ -176,100 +185,30 @@ def predict(self, sentences: list[str]) -> list[str]: preds.append(pred) return preds - def get(self, ent_seq: str) -> Entry: - """Get an entry by its `ent_seq`. - - Parameters - ---------- - ent_seq : str - The `ent_seq` of the entry to get - - Returns - ------- - Entry - The entry with the given `ent_seq`. - """ - for entry in self.entries: - if entry.ent_seq == ent_seq: - return entry - return None - - def _rank(self, candidates, context=None) -> tuple[list[Entry], list[float]]: - """A base ranking function that does nothing. - - Parameters - ---------- - candidates: List[Entry] - The candidates to rank - context : Any - A contet to inform the ranking - - Returns - ------- - candidates: List[Entry] - The ranked candidates - scores: List[float] - The score of each candidate - """ - if len(candidates) < 1: - return [], [] - return candidates, [1] * len(candidates) - - def _lookup(self, text) -> list[Entry]: - """Lookup an entry by text. - - Currently returns all entries that contain the text in either the kanji - or reading. - - Parameters - ---------- - text : str - The text to search for - - Returns - ------- - List[Entry] - A list of entries that contain the query. - """ - return list(self.index[text]) - - def search(self, text: str, context=None) -> list[Entry]: - """Search for an entry by text and rank the results. - - Currently returns all entries that contain the text in either the kanji - or reading. - - Parameters - ---------- - text : str - The text to search for - - Returns - ------- - List[Entry] - A list of entries that contain the query. - """ - res, _ = self._rank(self._lookup(text), context) - return res - - def feeling_lucky(self, text: str, context=None) -> Entry: - """Return the first entry found. - - Currently returns the first entry that contains the text in either the - kanji or reading. - - Parameters - ---------- - text : str - The text to search for - - Returns - ------- - Entry - The first entry that contains the query. - """ - entries = self.search(text, context) - return entries[0] if entries else None +class JMDict(Dictionary): + """A simple dictionary interface for JMDict.""" -__all__ = ['JMDict', 'Token', 'RankingModel'] + def __init__(self, retriever='local', ranker='dummy', file=None, *args, **kwargs): + if retriever == 'local': + retriever = LocalRetriever(file) + elif isinstance(retriever, Retriever): + pass + else: + raise ValueError(f"Invalid retriever: {retriever}") + if ranker == 'dummy': + ranker = DummyRanker() + elif ranker == 'pointwise': + ranker = PointWiseRanker(tokenize_fn=self.tokenize) + elif ranker == 'gemini': + ranker = GeminiRanker() + elif isinstance(ranker, Ranker): + ranker.tokenize = self.tokenize + else: + raise ValueError(f"Invalid ranker: {ranker}") + super().__init__(retriever, ranker, *args, **kwargs) + + +__all__ = [ + 'Dictionary', 'DummyRanker', 'JMDict', 'Ranker', 'Retriever', 'Token' +] diff --git a/wsd/models/gemini.py b/wsd/models/gemini.py index d5626ea..d1410ff 100644 --- a/wsd/models/gemini.py +++ b/wsd/models/gemini.py @@ -5,8 +5,7 @@ from google import genai from google.genai import types -from wsd.models.baseline import JMDict, Token -from wsd.parsers import Entry +from wsd.parsers import Entry, Token SYSTEM = """You are a Japanese dictionary ranking system. When given several candidate definitions for a Japanese word in the context of @@ -95,25 +94,5 @@ def generate(prompt, model_name): return json.loads(response.text) -class JMDictGeminiRanking(JMDict): - """A dictionary using Google's Gemini to rank candidate definitions.""" - def __init__(self, model_name="gemini-2.5-pro-exp-03-25", **kwargs): - super().__init__(**kwargs) - self.model_name = model_name - - # pylint: disable=signature-differs - def _rank(self, candidates: list[Entry], context): - if len(candidates) < 1: - return [], [] - prompt = get_prompt(context['sentence'], context['token'], candidates) - res = generate(prompt, model_name=self.model_name) - if 'answer' in res: - ans = max(0, min(res['answer'], len(candidates) - 1)) - top = candidates.pop(ans) - candidates.insert(0, top) - scores = [1] + [0] * (len(candidates) - 1) - return candidates, scores - - -__all__ = ['JMDictGeminiRanking'] +__all__ = ['GeminiRanker'] diff --git a/wsd/models/basic.py b/wsd/models/rankers.py similarity index 51% rename from wsd/models/basic.py rename to wsd/models/rankers.py index a70af0a..406df75 100644 --- a/wsd/models/basic.py +++ b/wsd/models/rankers.py @@ -1,23 +1,67 @@ -# pylint: disable=invalid-name -"""A basic dictionary with ranking based on a binary classifier.""" +"""A collection of rankers for WSD.""" + +from abc import ABC +from dataclasses import dataclass + from sklearn.feature_extraction import DictVectorizer from sklearn.linear_model import LogisticRegression -from wsd.models.baseline import JMDict, Token -from wsd.parsers import Entry +from wsd.parsers import Entry, Token +from wsd.models.gemini import get_prompt, generate + + +class Ranker(ABC): + """A simple dictionary interface for JMDict.""" + + def rank(self, candidates, context=None) -> tuple[list[Entry], list[float]]: + """A base ranking function that does nothing. + Parameters + ---------- + candidates: List[Entry] + The candidates to rank + context : Any + A contet to inform the ranking -class JMDictWithPointWiseRanking(JMDict): + Returns + ------- + candidates: List[Entry] + The ranked candidates + scores: List[float] + The score of each candidate + """ + if len(candidates) < 1: + return [], [] + return candidates, [1] * len(candidates) + + +class DummyRanker(Ranker): + """A simple dictionary interface for JMDict.""" + + def rank(self, candidates, context=None) -> tuple[list[Entry], list[float]]: + """A base ranking function that does nothing.""" + return candidates, [1] * len(candidates) + + +@dataclass +class Candidate: + """A candidate for a point-wise ranking.""" + entry: Entry + token: Token + + +class PointWiseRanker(Ranker): """A dictionary with the ranking function based on Binary Classification.""" - def __init__(self, ranking_model=None, **kwargs): + def __init__(self, ranking_model=None, tokenize_fn=None, **kwargs): super().__init__(**kwargs) self.vec = DictVectorizer() self.model = ranking_model if self.model is None: self.model = LogisticRegression() + self.tokenize = tokenize_fn - def _preprocess(self, X: list[str], y: list[str]): + def _preprocess(self, X: list[list[Candidate]], y: list[list[str]]): """Create features for each candidate In the PointWise Binary Classification, the preprocessing just creates @@ -27,10 +71,10 @@ def _preprocess(self, X: list[str], y: list[str]): Parameters ---------- - X : list[str] - A list of sentences to tokenize and 'featurize'. - y : list[str] - The list of labels for each tokens in the X sentences. + X : list[list[Candidate]] + A list of tokenized sentences to 'featurize'. + y : list[list[str]] + The list of list of labels for each tokens in the X sentences. Returns ------- @@ -39,15 +83,14 @@ def _preprocess(self, X: list[str], y: list[str]): flat_y : list[bool] Indicates whether the candidate is the best definition or not. """ - flat_X, flat_y = [], [] - for doc, labels in zip(X, y): - tokens = self.tokenize(doc) - for token, label in zip(tokens, labels): - candidates = self._lookup(token.lemma) + for sentence, labels in zip(X, y): + flat_X = [] + flat_y = [] + for candidates, label in zip(sentence, labels): for candidate in candidates: - feat = self._create_features(candidate, token) + feat = self._create_features(candidate.entry, candidate.token) flat_X.append(feat) - flat_y.append(label == candidate.ent_seq) + flat_y.append(label == candidate.entry.ent_seq) return flat_X, flat_y def fit(self, X: list[list[Token]], y: list[list[str]]): @@ -62,7 +105,7 @@ def fit(self, X: list[list[Token]], y: list[list[str]]): return self # pylint: disable=signature-differs - def _rank(self, candidates: list[Entry], context): + def rank(self, candidates: list[Entry], context): """A basic ranking function using the score of the binary classifier. Parameters @@ -106,4 +149,25 @@ def _create_features(self, candidate, token): return features -__all__ = ['JMDictWithPointWiseRanking'] +class GeminiRanker(Ranker): + """A dictionary using Google's Gemini to rank candidate definitions.""" + + def __init__(self, model_name="gemini-2.5-pro-exp-03-25", **kwargs): + super().__init__(**kwargs) + self.model_name = model_name + + # pylint: disable=signature-differs + def rank(self, candidates: list[Entry], context): + if len(candidates) < 1: + return [], [] + prompt = get_prompt(context['sentence'], context['token'], candidates) + res = generate(prompt, model_name=self.model_name) + if 'answer' in res: + ans = max(0, min(res['answer'], len(candidates) - 1)) + top = candidates.pop(ans) + candidates.insert(0, top) + scores = [1] + [0] * (len(candidates) - 1) + return candidates, scores + + +__all__ = ['DummyRanker', 'Ranker', 'PointWiseRanker', 'GeminiRanker'] diff --git a/wsd/models/retrievers.py b/wsd/models/retrievers.py new file mode 100644 index 0000000..4e1b913 --- /dev/null +++ b/wsd/models/retrievers.py @@ -0,0 +1,87 @@ +"""A collection of retrievers for WSD.""" +from collections import defaultdict +from abc import ABC + +from wsd.parsers import Entry, JMDictParser + + +class Retriever(ABC): + """Base class for the searcher models""" + + def retrieve(self, text: str) -> list[Entry]: + """Search for an entry by text and rank the results. + + Currently returns all entries that contain the text in either the kanji + or reading. + + Parameters + ---------- + text : str + The text to search for + + Returns + ------- + List[Entry] + A list of entries that contain the query. + """ + raise NotImplementedError("Subclasses must implement this method") + +class LocalRetriever(Retriever): + entries = None + indexed = False + + def __init__(self, file=None, **kwargs): + self.file = file + self._index(self.file) + + def _index(self, filename): + """Create an index to speed up lookups.""" + if self.indexed: + return + self.index = defaultdict(set) + self.entries = JMDictParser.parse(filename) + for entry in self.entries: + self.index[entry.ent_seq] = entry + for k_ele in entry.k_ele: + self.index[k_ele.keb].add(entry) + for r_ele in entry.r_ele: + self.index[r_ele.reb].add(entry) + self.indexed = True + + def retrieve(self, text) -> list[Entry]: + """Lookup an entry by text. + + Currently returns all entries that contain the text in either the kanji + or reading. + + Parameters + ---------- + text : str + The text to search for + + Returns + ------- + List[Entry] + A list of entries that contain the query. + """ + return list(self.index[text]) + + def get(self, ent_seq: str) -> Entry: + """Get an entry by its `ent_seq`. + + Parameters + ---------- + ent_seq : str + The `ent_seq` of the entry to get + + Returns + ------- + Entry + The entry with the given `ent_seq`. + """ + for entry in self.entries: + if entry.ent_seq == ent_seq: + return entry + return None + +__all__ = ['LocalRetriever', 'Retriever'] \ No newline at end of file diff --git a/wsd/models/tests/test_baseline.py b/wsd/models/tests/test_baseline.py index e69de29..c1ef93d 100644 --- a/wsd/models/tests/test_baseline.py +++ b/wsd/models/tests/test_baseline.py @@ -0,0 +1,23 @@ +import unittest + +from wsd.models import JMDict + + +class TestJMDict(unittest.TestCase): + """Test the JMDict model.""" + + def setUp(self): + self.jmdict = JMDict() + + def test_jmdict(self): + entries, _ = self.jmdict.search('日本語') + self.assertEqual(len(entries), 1) + self.assertEqual(entries[0].ent_seq, '1464530') + + def test_no_entry_found(self): + entries, _ = self.jmdict.search('qwefasdfasg') + self.assertEqual(len(entries), 0) + + +if __name__ == '__main__': + unittest.main() \ No newline at end of file diff --git a/wsd/parsers/__init__.py b/wsd/parsers/__init__.py index df57f93..6a08f97 100644 --- a/wsd/parsers/__init__.py +++ b/wsd/parsers/__init__.py @@ -1,7 +1,3 @@ """A collection of parsers for various data sources.""" -# from .jmdict import * -# from .xlwsd import * -from .jmdict import Entry, JMDictParser -from .xlwsd import XLWSDParser - -__all__=["Entry", "JMDictParser", "XLWSDParser"] +from .jmdict import * +from .xlwsd import * diff --git a/wsd/parsers/jmdict.py b/wsd/parsers/jmdict.py index 2ef7ff4..0c32e9a 100644 --- a/wsd/parsers/jmdict.py +++ b/wsd/parsers/jmdict.py @@ -1,6 +1,7 @@ # pylint: disable=not-callable """A parser for the JMdict dictionary.""" import gzip +import os import xml.etree.ElementTree as ET from dataclasses import dataclass, field @@ -139,6 +140,9 @@ class JMDictParser: @classmethod def parse(cls, file_path): """Parse a JMdict file.""" + if file_path is None: + file_path = os.path.join( + os.path.dirname(__file__), '../../data/JMdict_en.gz') entries = [] with gzip.open(file_path, "rb") as f: # pylint: disable=invalid-name tree = ET.parse(f) @@ -148,4 +152,14 @@ def parse(cls, file_path): return entries -__all__ = ['JMDictParser', 'Entry', 'Kanji', 'Reading', 'Gloss', 'Sense'] +@dataclass +class Token: + """Token dataclass.""" + text: str = '' + lemma: str = '' + pos: str = '' + + +__all__ = [ + 'JMDictParser', 'Entry', 'Kanji', 'Reading', 'Gloss', 'Sense', 'Token' +] diff --git a/wsd/utils.py b/wsd/utils.py index cbbabb2..b50af3c 100644 --- a/wsd/utils.py +++ b/wsd/utils.py @@ -7,6 +7,8 @@ from linalgo.annotate import Filter, Pipeline, Sequence2SequenceTransformer from linalgo.hub import BQClient +from wsd.parsers.jmdict import Token + tagger = Tagger('-Owakati') @@ -72,10 +74,16 @@ def load_dataset(filename: str) -> tuple[list[list[str]], list[list[str]]]: X, y = [], [] for doc_element in root.findall("document"): - doc_tokens: list[str] = [] + doc_tokens: list[Token] = [] doc_labels: list[str] = [] for token_element in doc_element.findall("token"): - doc_tokens.append(token_element.text) + doc_tokens.append( + Token( + text=token_element.text, + lemma=token_element.get("lemma"), + pos=token_element.get("pos") + ) + ) ent_seq = token_element.get("ent_seq") if ent_seq == '': ent_seq = None From 3cafbd4b4770054e85795905b9f02a9de8acebd9 Mon Sep 17 00:00:00 2001 From: Arnaud Rachez Date: Sat, 23 Aug 2025 09:50:09 +0900 Subject: [PATCH 2/4] feat: add save & load --- data/jmdict_basic_ranker.joblib | Bin 0 -> 1861 bytes examples/baseline.ipynb | 27 +-------------------------- wsd/__init__.py | 2 +- wsd/models/dictionary.py | 20 +++++++++++++++----- wsd/models/gemini.py | 1 - wsd/models/rankers.py | 19 ++++++++++++++++--- 6 files changed, 33 insertions(+), 36 deletions(-) create mode 100644 data/jmdict_basic_ranker.joblib diff --git a/data/jmdict_basic_ranker.joblib b/data/jmdict_basic_ranker.joblib new file mode 100644 index 0000000000000000000000000000000000000000..c7f50d7d0db6b90cac18d1bd96b7d906ebdecffe GIT binary patch literal 1861 zcmah}O>Epm6yDurvztwt-?nM<3lwNd>5@&Cwn7bQDL;ZifdO`D4(PM82AyukUE}TKCkT?KR1@usPidd+&Sm zz4@Shqa&M&p7+$GY+K~Il842D#hGUpE1da($0=X-J*NAnV;8Am>ORF~zT=tia8Jpe zXL06SbK;6R^q~sLvWCCnawW5NP;*z5%vCIh`NzuYijtjzyUb%qqGWnT$qs=~aJ44e zh2#17?P&zJS&a*--a^Li1x{VhoH2DUODcgjUlQBkw31!%V!JYhKU>hzEvUQ&J-G!P zZ$+gOt!R2`3)=Fpj4X{*h0Ape-?_lGqQz@9rer=G`&d(4g~e?Z6vKv~78nX@z`CF& z3I#P$D5!}-K}{42N>C&yL6M*)3I!!75)`9`Ag@JGIF1DgZVQe|?Wzxo%dSO7XIfw} zZ-s`YfXB%QJVC}`g7m;R*#$*121m#!^pg|}kTmQjZSVl;g$GF=93TU*pX6bZ48aiT zfJez5*h{kT2-yw8q!SL2eK1D4VIRrCL9!P{NC5^(1|B2(;UUrwqofNClVR9H+Tmd` z7|1>vI~xt`3A8hsvs64@EU7?~*_vZ;OUdzu`z_PPE}+qLky=jG6uyb=G4OIcoaa@K zi-;#Nea_`JvwXCB#=>)NHv(p}!_}J~cqi2rD^ch78a#zLlscHM%)43aZ zzCQs}=nUgm6-mo(-C{z}C2m&1S953@W*bh83ZMBLaffg$)Pp9oOs$?Ynyki_sfpBz z7_zGtSiVUk9wiF~cRjA-W&@iNcWMrH9!bf<67wQjY`}HdVbixAO<;h$RifCdri0@i zo5qbPFm|0VUNl|+<{3HqmHMpspCbWWdB@v0i5KvcN3MS)$l^E>?J?o>>%yVuh=AjoUueR(viL=?k=;aC`Gfr8myjug8?k>JG0^ z1+UicH+T(RhjS!NCN3+u5asr!%v4UaW_0pDGJ=b1z`{^%7$)XU-59&}=~tU~HXHc= zzCS$k$-VDR{yn>W-Na{?4xYMmKbfDowEVnrD}VFP=QfKsUi@`7xA;cCeCn?x&d}L= zAJ6CRCwM#GcHDkIzW?Q|-xB`D|4jMf`0XF>CiB^!{`mas-*cz(tJfEnuBUHmSARbL z?S)@vzqve7rr&?DxiJ;*l!d0}ca(OuQCLWdw*7o!nvGW)d^tO^{myer$nccRa`TkH b-07MmTyN6~(Wn>0Y~ list[Token]: ) ) return tokens - + def fit(self, X: list[list[str]], y: list[list[str]]): """Fit the ranker. @@ -157,7 +157,7 @@ def fit(self, X: list[list[str]], y: list[list[str]]): self.ranker.fit(XX, y) return self - def predict(self, sentences: list[str|Token]) -> list[str]: + def predict(self, sentences: list[str | Token]) -> list[str]: """Predict the `ent_seq` for each token in a sentence. Parameters @@ -199,7 +199,7 @@ def __init__(self, retriever='local', ranker='dummy', file=None, *args, **kwargs if ranker == 'dummy': ranker = DummyRanker() elif ranker == 'pointwise': - ranker = PointWiseRanker(tokenize_fn=self.tokenize) + ranker = PointWiseRanker() elif ranker == 'gemini': ranker = GeminiRanker() elif isinstance(ranker, Ranker): @@ -208,6 +208,16 @@ def __init__(self, retriever='local', ranker='dummy', file=None, *args, **kwargs raise ValueError(f"Invalid ranker: {ranker}") super().__init__(retriever, ranker, *args, **kwargs) + def save(self, path: str): + """Save the dictionary to a file.""" + joblib.dump({'retriever': self.retriever, 'ranker': self.ranker}, path) + + @classmethod + def load(cls, path: str): + """Load the dictionary from a file.""" + o = joblib.load(path) + return cls(retriever=o['retriever'], ranker=o['ranker']) + __all__ = [ 'Dictionary', 'DummyRanker', 'JMDict', 'Ranker', 'Retriever', 'Token' diff --git a/wsd/models/gemini.py b/wsd/models/gemini.py index d1410ff..06bf552 100644 --- a/wsd/models/gemini.py +++ b/wsd/models/gemini.py @@ -94,5 +94,4 @@ def generate(prompt, model_name): return json.loads(response.text) - __all__ = ['GeminiRanker'] diff --git a/wsd/models/rankers.py b/wsd/models/rankers.py index 406df75..0bead21 100644 --- a/wsd/models/rankers.py +++ b/wsd/models/rankers.py @@ -3,6 +3,7 @@ from abc import ABC from dataclasses import dataclass +import joblib from sklearn.feature_extraction import DictVectorizer from sklearn.linear_model import LogisticRegression @@ -53,13 +54,12 @@ class Candidate: class PointWiseRanker(Ranker): """A dictionary with the ranking function based on Binary Classification.""" - def __init__(self, ranking_model=None, tokenize_fn=None, **kwargs): + def __init__(self, ranking_model=None, **kwargs): super().__init__(**kwargs) self.vec = DictVectorizer() self.model = ranking_model if self.model is None: self.model = LogisticRegression() - self.tokenize = tokenize_fn def _preprocess(self, X: list[list[Candidate]], y: list[list[str]]): """Create features for each candidate @@ -88,7 +88,8 @@ def _preprocess(self, X: list[list[Candidate]], y: list[list[str]]): flat_y = [] for candidates, label in zip(sentence, labels): for candidate in candidates: - feat = self._create_features(candidate.entry, candidate.token) + feat = self._create_features( + candidate.entry, candidate.token) flat_X.append(feat) flat_y.append(label == candidate.entry.ent_seq) return flat_X, flat_y @@ -147,6 +148,18 @@ def _create_features(self, candidate, token): features['reb.text'] = token.text in reb features['reb.lemma'] = token.lemma in reb return features + + def save(self, path: str): + """Save the ranker to a file.""" + joblib.dump({'vec': self.vec, 'model': self.model}, path) + + @classmethod + def load(cls, path: str): + """Load the ranker from a file.""" + d = joblib.load(path) + o = cls(ranking_model=d['model']) + o.vec = d['vec'] + return o class GeminiRanker(Ranker): From 6ae55f02c52e595b4ddc7e73e3e652cf090a3348 Mon Sep 17 00:00:00 2001 From: Arnaud Rachez Date: Sat, 23 Aug 2025 10:50:43 +0900 Subject: [PATCH 3/4] maint: plot coefs --- examples/baseline.ipynb | 168 +++++++++++++++++++++++++++++++++++++--- 1 file changed, 156 insertions(+), 12 deletions(-) diff --git a/examples/baseline.ipynb b/examples/baseline.ipynb index 320294b..c7ff253 100644 --- a/examples/baseline.ipynb +++ b/examples/baseline.ipynb @@ -2,9 +2,18 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ "%load_ext autoreload\n", "%autoreload 2" @@ -12,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -27,21 +36,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ "basedir = os.getenv('PJ_DIR')\n", "X, y = load_dataset(f'{basedir}/data/dataset_.xml')\n", "X_train, X_test, y_train, y_test = train_test_split(\n", - " X, y, test_size=0.33, random_state=42)" + " X, y, test_size=0.33, random_state=44)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 8/8 [00:00<00:00, 17895.70it/s]\n" + ] + } + ], "source": [ "jmdict_base = JMDict()\n", "base_preds = jmdict_base.predict(X_test)" @@ -51,7 +68,15 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 8/8 [00:00<00:00, 309.44it/s]\n" + ] + } + ], "source": [ "model = LogisticRegression(C=10, penalty='l1', solver='liblinear')\n", "ranker = PointWiseRanker(ranking_model=model)\n", @@ -62,9 +87,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 8/8 [02:58<00:00, 22.30s/it]\n" + ] + } + ], "source": [ "ranker = GeminiRanker(\"gemini-2.5-flash-lite\")\n", "jmdict_gemini = JMDict(ranker=ranker)\n", @@ -73,14 +106,125 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "baseline = 49.62%\n", + "basic\t = 60.31%\n", + "gemini\t = 80.15%\n" + ] + } + ], "source": [ "print(f\"baseline = {accuracy(base_preds, y_test):.2%}\")\n", "print(f\"basic\\t = {accuracy(basic_preds, y_test):.2%}\")\n", "print(f\"gemini\\t = {accuracy(gemini_preds, y_test):.2%}\")" ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "jmdict_basic.fit(X_train, y_train)\n", + "pd.DataFrame(\n", + " np.exp(jmdict_basic.ranker.model.coef_), \n", + " columns=jmdict_basic.ranker.vec.get_feature_names_out()\n", + ").T\\\n", + " .sort_values(by=0, ascending=False)\\\n", + " .plot(kind='barh', figsize=(5, 7), title='Basic Ranker Coefficients')" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.00000000e+00, -2.90281631e-02, -4.90913157e-01,\n", + " -1.05428237e-01, 0.00000000e+00, 4.19182183e-01,\n", + " 0.00000000e+00, 2.78118162e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 9.07715233e-01,\n", + " 0.00000000e+00, -1.38683637e+00, 0.00000000e+00,\n", + " 0.00000000e+00, -1.75750801e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, -3.07991482e+00,\n", + " 0.00000000e+00, 1.35786622e-01, 1.13208954e+00,\n", + " -1.01917693e-04, -2.07167330e-01, -8.86978453e-01,\n", + " 0.00000000e+00, 1.14477566e+00, 0.00000000e+00,\n", + " 2.50980163e-01, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 1.43010440e+00, 0.00000000e+00,\n", + " -4.00766634e-02, 0.00000000e+00, 0.00000000e+00,\n", + " -6.04083083e-01, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 5.86520815e+00, -6.61320415e+00,\n", + " 3.93590717e+00, 2.00444485e-01]])" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "jmdict_basic.ranker.model.coef_" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([False, True])" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "jmdict_basic.ranker.model.classes_" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 39946e33acd30262571f852d9c2fcdea92dafca6 Mon Sep 17 00:00:00 2001 From: Arnaud Rachez Date: Sat, 23 Aug 2025 11:28:47 +0900 Subject: [PATCH 4/4] fix: basic preprocessing --- data/jmdict_basic_ranker.joblib | Bin 1861 -> 3781 bytes examples/baseline.ipynb | 163 ++++---------------------------- wsd/models/dictionary.py | 18 ++++ wsd/models/rankers.py | 7 +- 4 files changed, 39 insertions(+), 149 deletions(-) diff --git a/data/jmdict_basic_ranker.joblib b/data/jmdict_basic_ranker.joblib index c7f50d7d0db6b90cac18d1bd96b7d906ebdecffe..1611c434007191a8d22c25d691fe29dafd9d955c 100644 GIT binary patch literal 3781 zcmZuzX>=3U6_)oEW1Ge7*k%c4F_tVFvzU=%vzQCU5SD~(Jd#Gf!edEjMt}*V1rD(} zOj*j9t)cF5dO`{f1t%;ajmHfoP#U0MQlKfM<(M9beN0$eQUZM%TN=MZ^+S5!eDB@+ zy{qrNxjzlBog8b>KI@bba@b1VrpTkj3W4Xmu1p8dNj@*n@~b5;XOo<6S0-zB+9Z}t zliXhC8s4kO2}R_|0{y{GC1btf4;EpUsyw_RN4R{Io+?F-atLlt$~7xH6*)%aJ)D;# zK@>S8Uy&n40!3b_k;6r|S0cX&f#fc(k{4NJDTx?g!LuH(Gv8@Lr%|DxNrx_emDq*# zL&C;&u5~%G2-yYETsFm-DU?H@Tnde&P#%TGcSXi53Q<~&lolhU#Ykx}Qd*3Z79*v_ zNNF)rT1=D{6Q#vOX)#e+Oq3QArNu;PF;QAflok`EC7aTcO=-!dv}99SvMDXul$LBN zdp4ENOyx6E`OH*4GnLOwWiV5_HIsY+kBT1NMuK*QBx+0rZ_O0=%1Ta=qy1xvoGmho z9I~#)?gGi802?rNCmS$!0CpH#NB&Ld$iE34`HQ9_|CV&*-;$2}CDf7s57d#rph2V= zTSxwa>WI>!8C&NlEt;`)j?$tTTjwY(nz4hNW^5f%S~O$p990+1*g8kmMKiX}QFYOb zt#edeG-C%j&Dc7k>Y^E2=cu}9#@0D1yJqYlrx{yE)ZR5?>m0Rr&Dc6eRbDf8Cl@ew z7f5yy|G3lGBJUD;;&@lNgbFXmt#sQst54v(RjmIdfk|M%DPYDbKrDi6ECds- zhH_j54jc}>um^I>;q9a6DFb$>^K5aa0vjWKqLZ8z@89>6CeYp z!#H%oQtS;8I0MGxAn1m3p#Xb9I2J=54uu~0CQQQu$ig&8#Q9K!Mo2{-=HYA58yCY2 zOoi?^4+?PzB;!Juiv1xLXTxNi2qV!A%Wwe1VJR?}3?Vobaxe#mq7&Z4To{JS;Vm2p z@i+%8m7G}X>SSJ z%e}m)#R)bGQ6ApK2~w3JhYG~9;dUP?+<_j*?PBu2IfqcUQ8a#7R8Ck)m55`yt*H zoYoG}KpSLqWZC#%I#lH2ftR1>AT8?trIsYtwXB8nLN4hQu-9*N2ubnKy8jK>d zI{Ps)C)8?GHrG@ubCnSgCWow5N=iy*yd)p(3k;HCm18+UaIa#?o618f+`mJamW3r1 zE_YS(E{U~PNxY~)qR$%XU;gr?A*6OrM>}bdBW!No!78|~qaVcmSckuY5OBV$V7;d4 z*K(*Mud9+t|3?WPtieP66k#O(#?meEGZSK(UYy!>r#SpcUw;4a8?Vy9#H2*U*2I0G7Jh#v;*ab8q6X$id@*d%&xRjR=hx-` z;@#h!Wa_Kd^mZM1!JOG~@tdVf&oPN%GZn*%c+0tI+h_f);H3KXoI|Zm*B+{4F0|E+ zjrf6?*IE{Fso@smC|+>K=eWmI|J*sZu%($fVJ_WKQ+GyPzbCKP^2eb~sj&FK*@w^6 z6`zNu{%L&^qqy6$ib~F?iN|j=l$SnZPK;SG`TUkAL0xADn}4!>>UJix=CUVw?E|Jy zQHwm~*uLOCKfK?rJhrW1`ohUA`QJ7(d*&>9_CtM4Q(#|#-_e_9uT0&4PHpUcW&fz! zhw909E*EjpH`SGv)}#B{{u|7ik`CWylEM$JZ#n)r$S>K=O*p#I z(DZge>5oRXR}+8ftBJjDJ__<5?9I=;k<`kxe4DZL_UI(bn&-=QMm673=M`7~;n0O< z=Eq*k{(7@0#InbGCTILF-(#F9PwI|Uo@GuQ`THl;-M(h7$BT|*PtU8LH=YRV)^;`+ zcZSeDBl28}+I~Lc!ttqBnWD6;>Ql=UChz?tsq;U5k6HfPr30^SxXNsrwRcq9`YY;Z zwgqMNXKtu#+i(45?=XYq>dwWppKZOt^lV9uIC>z_lJ?od>-HTXmU~-1ZB_qqJ($OI zMKN?zo_@9@Uq{ef(>02ArAsNZddkVrWyDv_)Uprw4);A~Rdbj9x&CH+w zW!zb{L1egHM{YjY^@s`7J>mK3kKRfBj=4D4v*}=;_nGQiM^?(Hd%=8--PMLVA++hc z+4F|i7vEM7-2NcEuCYzMJB?lN{KFP?`utCBewk!wiho>I&@Sv&lcIL`gl$imfoXT! zuWh))Ogemae!S(rdYZdbu>so{&!H0^HTHg>N&_nIj1+oWn!}!*ym$AOx;;L9<6=y1 z8rME7J!4yxCD+){x?}7HwKl6$sT`}{ov$3#O@V{j5Ilql+A$A)Wo>zz*>?GbT01)s vFUqA|pRb<#U@&s(oo4;iqdz6p0fn_Qi>qOQA6R+q`7G%_#?8(S$ZD=v2hdVnpzMv@6HZRS{0ELGlXJR^~ zhX<;%xF9vzaB?2A!Q{2f`jcNVYfWCqB0c#!3;$#fR$f7{$|8uF5S8w1R`ojG(i!^R zavAd8d>L}yycv4lvKhMGG8uy23>iY+j2R-{%oz&a{27Yg0vXEQLK%|Y92pwk;u+%J zY#D0aq8Vb|tQo4_A{kQNoEe(l5*f1IJQ)(+>>29bVj0rjTp7aNOc`3J&EEy`^!lgX|@tZX`f*2X)Cs%W3Gulml&Y8r?_a6!-dvQrg2WU1o z?Ju;|%bUdC+`50N0aR-bS7u&GYEg1(K}r0S479*&g#}$k1}xa%fei_Bm;}a17G(`iLS~4e3" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import pandas as pd\n", "import numpy as np\n", "\n", - "jmdict_basic.fit(X_train, y_train)\n", + "jmdict_basic.fit(X, y)\n", "pd.DataFrame(\n", - " np.exp(jmdict_basic.ranker.model.coef_), \n", + " jmdict_basic.ranker.model.coef_, \n", " columns=jmdict_basic.ranker.vec.get_feature_names_out()\n", ").T\\\n", " .sort_values(by=0, ascending=False)\\\n", - " .plot(kind='barh', figsize=(5, 7), title='Basic Ranker Coefficients')" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 0.00000000e+00, -2.90281631e-02, -4.90913157e-01,\n", - " -1.05428237e-01, 0.00000000e+00, 4.19182183e-01,\n", - " 0.00000000e+00, 2.78118162e+00, 0.00000000e+00,\n", - " 0.00000000e+00, 0.00000000e+00, 9.07715233e-01,\n", - " 0.00000000e+00, -1.38683637e+00, 0.00000000e+00,\n", - " 0.00000000e+00, -1.75750801e+00, 0.00000000e+00,\n", - " 0.00000000e+00, 0.00000000e+00, -3.07991482e+00,\n", - " 0.00000000e+00, 1.35786622e-01, 1.13208954e+00,\n", - " -1.01917693e-04, -2.07167330e-01, -8.86978453e-01,\n", - " 0.00000000e+00, 1.14477566e+00, 0.00000000e+00,\n", - " 2.50980163e-01, 0.00000000e+00, 0.00000000e+00,\n", - " 0.00000000e+00, 1.43010440e+00, 0.00000000e+00,\n", - " -4.00766634e-02, 0.00000000e+00, 0.00000000e+00,\n", - " -6.04083083e-01, 0.00000000e+00, 0.00000000e+00,\n", - " 0.00000000e+00, 5.86520815e+00, -6.61320415e+00,\n", - " 3.93590717e+00, 2.00444485e-01]])" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "jmdict_basic.ranker.model.coef_" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([False, True])" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "jmdict_basic.ranker.model.classes_" + " .plot(kind='barh', figsize=(5, 14), title='Basic Ranker Coefficients')" ] }, { @@ -224,7 +95,9 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "jmdict_basic.ranker.save('../data/jmdict_basic_ranker.joblib')" + ] } ], "metadata": { diff --git a/wsd/models/dictionary.py b/wsd/models/dictionary.py index 2f8a8d5..f593e74 100644 --- a/wsd/models/dictionary.py +++ b/wsd/models/dictionary.py @@ -207,6 +207,24 @@ def __init__(self, retriever='local', ranker='dummy', file=None, *args, **kwargs else: raise ValueError(f"Invalid ranker: {ranker}") super().__init__(retriever, ranker, *args, **kwargs) + + def get(self, ent_seq: str) -> Entry: + """Get an entry by its `ent_seq`. + + Parameters + ---------- + ent_seq : str + The `ent_seq` of the entry to get + + Returns + ------- + Entry + The entry with the given `ent_seq`. + """ + for entry in self.retriever.entries: + if entry.ent_seq == ent_seq: + return entry + return None def save(self, path: str): """Save the dictionary to a file.""" diff --git a/wsd/models/rankers.py b/wsd/models/rankers.py index 0bead21..cef0320 100644 --- a/wsd/models/rankers.py +++ b/wsd/models/rankers.py @@ -83,10 +83,9 @@ def _preprocess(self, X: list[list[Candidate]], y: list[list[str]]): flat_y : list[bool] Indicates whether the candidate is the best definition or not. """ - for sentence, labels in zip(X, y): - flat_X = [] - flat_y = [] - for candidates, label in zip(sentence, labels): + flat_X, flat_y = [], [] + for doc, labels in zip(X, y): + for candidates, label in zip(doc, labels): for candidate in candidates: feat = self._create_features( candidate.entry, candidate.token)