micm-nlp 0.1.0__tar.gz

micm_nlp-0.1.0/.env.example

@@ -0,0 +1,6 @@
+PACKAGE_NAME=nlpka
+APP_NAME=${PACKAGE_NAME}
+APP_ENV=local
+SHOW_LOCALS=0
+WANDB_API_KEY=
+HF_TOKEN=

micm_nlp-0.1.0/.gitignore

@@ -0,0 +1,28 @@
+.env
+.cursorignore
+.venv/
+.vscode/
+.claude/
+
+.DS_Store
+*.DS_Store
+
+__pycache__
+.ipynb_checkpoints
+
+!__init__.py
+
+**cache*
+!*cache.py
+
+artefacts/
+runtime/
+exp/
+
+dist/
+build/
+*.egg-info/
+wandb/
+logs/
+docs/internal/
+docs/superpowers/

micm_nlp-0.1.0/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+All notable changes to micm-nlp will be documented here.
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-04-30
+
+### Added
+- Initial public release of the micm-nlp toolkit.
+- Config-driven pipeline (tokenization → preprocessing → training → evaluation).
+- Example: HuggingFace Hub dataset loading + decoder-only tokenization (`examples/preprocess_dataset.py` + `examples/configs/xsc_preprocess.yml`).
+- Example: PEFT fine-tuning + evaluation using Cross-Prompt Encoder (XPE) on a decoder-only LM (`examples/run_model.py` + `examples/configs/xsc_finetune.yml`).
+- WandB experiment tracking integration.

micm_nlp-0.1.0/CLAUDE.md

@@ -0,0 +1,131 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+**nlpka** is an NLP research toolkit built on HuggingFace Transformers, supporting tokenization, pretraining, fine-tuning, and PEFT across encoder-only, decoder-only, and encoder-decoder architectures. It has been used in two peer-reviewed publications covering BERT-like pretraining/fine-tuning for text and token classification, and parameter-efficient soft prompt tuning across 200 languages (SIB-200 topic classification) with cross-prompt encoders on XLM-RoBERTa-large. The most recent work — **Cross-Prompt Encoder (XPE)** — is accepted at *Findings of IJCNLP–AACL 2025* ([arXiv:2508.10352](https://arxiv.org/abs/2508.10352)). The toolkit is expanding to decoder-only models and includes T5 encoder-decoder pipelines for fine-tuning and evaluation.
+
+## Setup
+
+```bash
+cp .env.example .env  # add WANDB_API_KEY to .env
+
+# Docker (recommended)
+docker build -t xpe .
+docker run --gpus all -it --rm -v $(pwd):/xpe_runner -w /xpe_runner xpe bash
+
+# Local
+pip install -e ".[dev]"
+```
+
+## Common Commands
+
+**Download dataset:**
+```bash
+python -m micm_nlp.datasets.scripts.sib200.download_tokenized
+```
+
+**Run experiment (main entrypoint):**
+```bash
+python -m micm_nlp.models.scripts.peft.xpe.run \
+  --config xlmr/finetune/peft/sib200_hybrid.xpe \
+  --supervision_regime=<0|1> <source_dataset> <setup_id>
+```
+
+- `--supervision_regime`: `0` = Zero-Shot XLT, `1` = Fully Supervised XLT
+- `<source_dataset>`: `sib200_enarzho`, `sib200_joshi5`, `sib200_xlmr_seen` (zero-shot) or `sib200_joshi5_divers_24` (supervised)
+- `<setup_id>`: `1`=SPT, `2`=D30 (30% XPE hybrid), `3`=D70 (70% XPE hybrid), `4`=XPE
+
+**Collect hidden states:**
+```bash
+python -m micm_nlp.models.scripts.peft.xpe.collect_hs_v
+```
+
+**Evaluate AYA on Belebele:**
+```bash
+python -m micm_nlp.evaluations.scripts.eval_aya_belebele
+```
+
+**Visualize / quantitative analysis:**
+```bash
+python -m micm_nlp.evaluations.scripts.plot
+python -m micm_nlp.evaluations.scripts.quant
+```
+
+**Lint & format:**
+```bash
+ruff check src/
+ruff format src/
+```
+
+## Project Structure
+
+```
+ExpXPE/
+├── pyproject.toml              # Package metadata, dependencies, ruff config
+├── dockerfile
+├── .env.example
+├── config/                     # YAML experiment configs
+├── examples/                   # Simple usage demos for the package API
+├── experiments/                # Research-specific code (XPE, SIB-200, evals)
+│   ├── config/                 # Experiment config utilities (xpe_utils, etc.)
+│   ├── datasets/               # Dataset prep (SIB-200, Belebele, xStory, etc.)
+│   ├── models/                 # Experiment runners (XPE train, collect HS, etc.)
+│   └── evals/                  # Plots, quantitative analysis, eval scripts
+├── artefacts/                  # Generated outputs
+└── src/micm_nlp/               # Package source (standard src layout)
+    ├── pipeline.py             # High-level wiring: load_dataset, load_model, run
+    ├── env.py                  # Loads .env, exposes os.environ as `env`
+    ├── setup.py                # Runtime init (Rich pretty-printing + traceback)
+    ├── utils.py                # Pure helpers, JSON/YAML/pickle I/O, SimpleNamespace utils
+    ├── path.py                 # Project path resolution, directory traversal
+    ├── enums.py                # StrEnum definitions for all categorical choices
+    ├── config.py               # Config loader (YAML → SimpleNamespace)
+    ├── datasets/               # Dataset loading/preprocessing
+    ├── tokenizers/             # Tokenizer factory (XLM-R, BERT, T5, etc.)
+    ├── models/                 # Model, PEFT, XPE, trainers, callbacks
+    └── evals/                  # Metrics, confusion matrices, plots
+```
+
+## Architecture
+
+All core logic follows a class-based, config-driven pattern:
+
+```
+CONFIG (YAML) → TOKENIZER → DATASET → MODEL → PEFT → Trainer → EVALUATE
+```
+
+| Class | File | Role |
+|-------|------|------|
+| `CONFIG` | `src/nlpka/config/config.py` | Loads YAML configs from `config/language_model/` |
+| `TOKENIZER` | `src/nlpka/tokenizers/tokenizer.py` | Tokenizer factory for XLM-R, BERT, T5, etc. |
+| `DATASET` | `src/nlpka/datasets/dataset.py` | Loads/preprocesses HuggingFace, CSV, or TXT datasets |
+| `MODEL` | `src/nlpka/models/model.py` | Wraps HuggingFace model + Trainer, WandB logging |
+| `PEFT` | `src/nlpka/models/peft.py` | Attaches LoRA / Prefix / P-Tuning / XPE to base model |
+| `CrossPromptEncoder` | `src/nlpka/models/xpe.py` | The XPE module (based on NeMo's prompt encoder) |
+| `EVALUATE` | `src/nlpka/evals/eval.py` | Metrics (accuracy, F1), confusion matrices, t-SNE plots |
+
+**PEFT dispatch**: `PEFT.setup_model()` checks `is_xpe_config()` to route between standard PEFT methods and the custom XPE path (`get_xpe_model()`, which instantiates `XPEPeftModelForSequenceClassification`). `PEFT.from_pretrained()` peeks at `adapter_config.json` via `is_xpe_adapter_dir()` and dispatches to `load_xpe_pretrained()` — this preserves loading of paper-era checkpoints saved with `peft_type='P_TUNING' + encoder_ratio`.
+
+**Enums** in `src/nlpka/enums.py` define all categorical choices (`ModelArchSE`, `TaskCatSE`, etc.) using `StrEnum` — check here before adding new method/task types.
+
+**Foundational modules** (no circular dependencies):
+
+| Module | Role | Depends on |
+|--------|------|------------|
+| `env.py` | Loads `.env`, exposes `env` | stdlib only |
+| `utils.py` | Pure helpers, file I/O | stdlib + numpy/rich/tqdm/yaml |
+| `path.py` | Path resolution, directory ops | `env` |
+| `setup.py` | Runtime init (`init()`): Rich pretty + traceback | stdlib + rich |
+| `enums.py` | All `StrEnum` types | stdlib only |
+
+**Runtime init**: Call `micm_nlp.setup.init()` at the top of entrypoint scripts to activate Rich pretty-printing and tracebacks. This is not triggered on import.
+
+## Key Conventions
+
+- All experiments are tracked via **WandB** (`WANDB_API_KEY` in `.env`).
+- HuggingFace token (`HF_TOKEN`) is needed for gated models/datasets.
+- Model/dataset/tokenizer artifacts are cached under their respective `storage/` subdirectories.
+- GPU training only (CPU supported for small-scale debugging); no non-NVIDIA GPU support.
+- Package uses standard `src` layout — `pip install -e .` makes `from micm_nlp.X import Y` work.

micm_nlp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Beso Mikaberidze
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

micm_nlp-0.1.0/PKG-INFO

@@ -0,0 +1,208 @@
+Metadata-Version: 2.4
+Name: micm-nlp
+Version: 0.1.0
+Summary: NLP research toolkit built on HuggingFace Transformers
+Project-URL: Homepage, https://github.com/bmikaberidze/micm-nlp
+Project-URL: Repository, https://github.com/bmikaberidze/micm-nlp
+Project-URL: Issues, https://github.com/bmikaberidze/micm-nlp/issues
+Author-email: Beso Mikaberidze <beso.mikaberidze@gmail.com>
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: accelerate
+Requires-Dist: aenum
+Requires-Dist: datasets
+Requires-Dist: datasketch
+Requires-Dist: evaluate
+Requires-Dist: lightning
+Requires-Dist: matplotlib
+Requires-Dist: nltk
+Requires-Dist: numpy
+Requires-Dist: nvidia-ml-py3
+Requires-Dist: opentsne
+Requires-Dist: pandas
+Requires-Dist: peft==0.14.0
+Requires-Dist: pydantic-settings>=2.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: python-dotenv
+Requires-Dist: pyyaml
+Requires-Dist: requests
+Requires-Dist: rich
+Requires-Dist: scikit-learn
+Requires-Dist: sentencepiece
+Requires-Dist: seqeval
+Requires-Dist: spacy
+Requires-Dist: tqdm
+Requires-Dist: transformers==4.49.0
+Requires-Dist: wandb
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# micm-nlp
+
+[![PyPI](https://img.shields.io/pypi/v/micm-nlp.svg)](https://pypi.org/project/micm-nlp/)
+[![Python](https://img.shields.io/pypi/pyversions/micm-nlp.svg)](https://pypi.org/project/micm-nlp/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+NLP research toolkit for tokenization, pretraining, fine-tuning, and PEFT across encoder-only, decoder-only, and encoder-decoder architectures. Built on top of HuggingFace `transformers`, `peft`, and `datasets`.
+
+## About
+
+`micm-nlp` is a config-driven research toolkit for multilingual NLP work. It wraps the HuggingFace stack with a small set of high-level building blocks — `CONFIG`, `TOKENIZER`, `DATASET`, `MODEL`, and a unified `TRAINER` — that compose into reproducible training, fine-tuning, and evaluation pipelines. 
+The toolkit was used in the *Cross-Prompt Encoder for Low-Performing Languages* paper (Findings of IJCNLP–AACL 2025; [ACL Anthology](https://aclanthology.org/2025.findings-ijcnlp.144/)) and in *A Comparison of Different Tokenization Methods for the Georgian Language* (ICNLSP 2024; [ACL Anthology](https://aclanthology.org/2024.icnlsp-1.22/))
+
+This v0.1.0 release ships **two examples** that exercise a single use case end-to-end: preprocessing and decoder-only PEFT fine-tuning (XPE) on an FTP-reframed multilingual dataset hosted on the HuggingFace Hub. The toolkit's underlying surface is broader than these two examples demonstrate.
+
+Additional examples covering encoder-only text classification, encoder-decoder seq2seq, and MLM pretraining will land in subsequent releases. Contributions and issue reports are welcome.
+
+## Install
+
+From PyPI:
+
+```bash
+pip install micm-nlp
+```
+
+From source (development):
+
+```bash
+git clone https://github.com/bmikaberidze/micm-nlp.git
+cd micm-nlp
+pip install -e ".[dev]"
+```
+
+Docker (recommended for reproducibility on GPU machines):
+
+```bash
+docker build -t micm-nlp .
+docker run --gpus all -it --rm -v $(pwd):/app -w /app micm-nlp bash
+```
+
+You will also want a `.env` file for HuggingFace and Weights & Biases credentials:
+
+```bash
+cp .env.example .env
+# Then add WANDB_API_KEY and (if needed) HF_TOKEN.
+```
+
+## Quickstart
+
+```python
+import micm_nlp
+from micm_nlp.config import CONFIG
+from micm_nlp.pipeline import run
+
+micm_nlp.init()  # Rich pretty-printing + traceback formatting
+
+config = CONFIG.from_yaml("examples/configs/xsc_finetune.yml")
+model, test_output = run(config)
+```
+
+`run(config)` chains: load tokenizer → load and preprocess dataset → load model (with PEFT if configured) → train → evaluate. Every stage is configured by YAML; no plumbing code required.
+
+## Package tour
+
+```
+micm_nlp/
+├── pipeline.py     # Top-level wiring: load_dataset, preprocess_dataset, load_model, run
+├── config.py       # CONFIG.from_yaml; resolves nested namespaces
+├── tokenizers/     # Tokenizer factory (XLM-R, BERT, BLOOM, T5, ...)
+├── datasets/       # DATASET class — local + HF Hub + HF saved + CSV/TXT/JSON
+├── models/         # MODEL wrapper, PEFT dispatch, XPE module, training callbacks
+├── training/       # TRAINER — wraps HF Trainer with custom callbacks + WandB
+└── evals/          # Metrics, confusion matrices, plotting helpers
+```
+
+The five-stage flow:
+
+```python
+from micm_nlp.config import CONFIG
+from micm_nlp.tokenizers.tokenizer import load as load_tokenizer
+from micm_nlp.datasets.dataset import DATASET
+from micm_nlp.models.model import MODEL
+from micm_nlp.training.runner import TRAINER
+
+config = CONFIG.from_yaml("path/to/config.yml")
+tokenizer = load_tokenizer(config)
+dataset = DATASET(config)
+dataset.preprocess(tokenizer)
+model = MODEL(config)
+trainer = TRAINER(model, dataset, tokenizer)
+test_output = trainer.run()
+```
+
+## Examples
+
+| Example | Config | Description |
+|---|---|---|
+| `examples/preprocess_dataset.py` | `examples/configs/xsc_preprocess.yml` | Loads FTP-reframed XStoryCloze (English split) directly from the HuggingFace Hub and tokenizes it for BLOOM-560M; saves tokenized output locally. |
+| `examples/run_model.py` | `examples/configs/xsc_finetune.yml` | Fine-tunes BLOOM-560M with XPE PEFT on the Arabic split of FTP-reframed XStoryCloze, then evaluates. |
+
+More examples — encoder-only text classification, encoder-decoder seq2seq, MLM pretraining, additional PEFT methods (LoRA, Prefix, P-Tuning) — are planned for subsequent releases.
+
+## Supported architectures
+
+| Architecture | Toolkit support | Demonstrated by example in v0.1.0 |
+|---|---|---|
+| Decoder-only (BLOOM, AYA) | ✅ | ✅ |
+| Encoder-only (BERT, XLM-R) | ✅ | ⏳ planned |
+| Encoder-decoder (T5) | ✅ | ⏳ planned |
+
+PEFT methods supported by the toolkit: LoRA, Prefix Tuning, P-Tuning (SPT), Cross-Prompt Encoder (XPE). v0.1.0 examples demonstrate XPE only.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+ruff check src/
+ruff format src/
+pytest
+```
+
+## Contributing
+
+Pull requests are welcome. For non-trivial changes, please open an issue first to discuss the proposed change. A `CONTRIBUTORS.md` will be added with the first external contribution.
+
+## Acknowledgements
+
+`micm-nlp` was developed at the Muskhelishvili Institute of Computational Mathematics (MICM, Georgian Technical University), in close research collaboration with Teimuraz Saghinadze (MICM), Simon Ostermann (DFKI / CERTAIN), and Philipp Müller (Max Planck Institute for Intelligent Systems), whose joint work on the Cross-Prompt Encoder (XPE) drove much of the toolkit's design and validation.
+
+This work was partially supported by the European Union under Horizon Europe project "GAIN" (GA #101078950) and by the German Federal Ministry of Research, Technology and Space (BMFTR) as part of the project TRAILS (01IW24005).
+
+## Citation
+
+If you use `micm-nlp` in your research, please cite the package and (if relevant to your work) the XPE paper that drove its design:
+
+```bibtex
+@software{micm_nlp,
+  author = {Mikaberidze, Beso},
+  title = {micm-nlp: NLP research toolkit for multilingual fine-tuning and PEFT},
+  url = {https://github.com/bmikaberidze/micm-nlp},
+  version = {0.1.0},
+  year = {2026},
+}
+
+@misc{mikaberidze2025crosspromptencoderlowperforminglanguages,
+  title         = {Cross-Prompt Encoder for Low-Performing Languages},
+  author        = {Beso Mikaberidze and Teimuraz Saghinadze and Simon Ostermann and Philipp Muller},
+  year          = {2026},
+  eprint        = {2508.10352},
+  archivePrefix = {arXiv},
+  primaryClass  = {cs.CL},
+  url           = {https://arxiv.org/abs/2508.10352},
+}
+```
+
+## Contact
+
+`beso.mikaberidze@gmail.com`

micm_nlp-0.1.0/README.md

@@ -0,0 +1,158 @@
+# micm-nlp
+
+[![PyPI](https://img.shields.io/pypi/v/micm-nlp.svg)](https://pypi.org/project/micm-nlp/)
+[![Python](https://img.shields.io/pypi/pyversions/micm-nlp.svg)](https://pypi.org/project/micm-nlp/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+NLP research toolkit for tokenization, pretraining, fine-tuning, and PEFT across encoder-only, decoder-only, and encoder-decoder architectures. Built on top of HuggingFace `transformers`, `peft`, and `datasets`.
+
+## About
+
+`micm-nlp` is a config-driven research toolkit for multilingual NLP work. It wraps the HuggingFace stack with a small set of high-level building blocks — `CONFIG`, `TOKENIZER`, `DATASET`, `MODEL`, and a unified `TRAINER` — that compose into reproducible training, fine-tuning, and evaluation pipelines. 
+The toolkit was used in the *Cross-Prompt Encoder for Low-Performing Languages* paper (Findings of IJCNLP–AACL 2025; [ACL Anthology](https://aclanthology.org/2025.findings-ijcnlp.144/)) and in *A Comparison of Different Tokenization Methods for the Georgian Language* (ICNLSP 2024; [ACL Anthology](https://aclanthology.org/2024.icnlsp-1.22/))
+
+This v0.1.0 release ships **two examples** that exercise a single use case end-to-end: preprocessing and decoder-only PEFT fine-tuning (XPE) on an FTP-reframed multilingual dataset hosted on the HuggingFace Hub. The toolkit's underlying surface is broader than these two examples demonstrate.
+
+Additional examples covering encoder-only text classification, encoder-decoder seq2seq, and MLM pretraining will land in subsequent releases. Contributions and issue reports are welcome.
+
+## Install
+
+From PyPI:
+
+```bash
+pip install micm-nlp
+```
+
+From source (development):
+
+```bash
+git clone https://github.com/bmikaberidze/micm-nlp.git
+cd micm-nlp
+pip install -e ".[dev]"
+```
+
+Docker (recommended for reproducibility on GPU machines):
+
+```bash
+docker build -t micm-nlp .
+docker run --gpus all -it --rm -v $(pwd):/app -w /app micm-nlp bash
+```
+
+You will also want a `.env` file for HuggingFace and Weights & Biases credentials:
+
+```bash
+cp .env.example .env
+# Then add WANDB_API_KEY and (if needed) HF_TOKEN.
+```
+
+## Quickstart
+
+```python
+import micm_nlp
+from micm_nlp.config import CONFIG
+from micm_nlp.pipeline import run
+
+micm_nlp.init()  # Rich pretty-printing + traceback formatting
+
+config = CONFIG.from_yaml("examples/configs/xsc_finetune.yml")
+model, test_output = run(config)
+```
+
+`run(config)` chains: load tokenizer → load and preprocess dataset → load model (with PEFT if configured) → train → evaluate. Every stage is configured by YAML; no plumbing code required.
+
+## Package tour
+
+```
+micm_nlp/
+├── pipeline.py     # Top-level wiring: load_dataset, preprocess_dataset, load_model, run
+├── config.py       # CONFIG.from_yaml; resolves nested namespaces
+├── tokenizers/     # Tokenizer factory (XLM-R, BERT, BLOOM, T5, ...)
+├── datasets/       # DATASET class — local + HF Hub + HF saved + CSV/TXT/JSON
+├── models/         # MODEL wrapper, PEFT dispatch, XPE module, training callbacks
+├── training/       # TRAINER — wraps HF Trainer with custom callbacks + WandB
+└── evals/          # Metrics, confusion matrices, plotting helpers
+```
+
+The five-stage flow:
+
+```python
+from micm_nlp.config import CONFIG
+from micm_nlp.tokenizers.tokenizer import load as load_tokenizer
+from micm_nlp.datasets.dataset import DATASET
+from micm_nlp.models.model import MODEL
+from micm_nlp.training.runner import TRAINER
+
+config = CONFIG.from_yaml("path/to/config.yml")
+tokenizer = load_tokenizer(config)
+dataset = DATASET(config)
+dataset.preprocess(tokenizer)
+model = MODEL(config)
+trainer = TRAINER(model, dataset, tokenizer)
+test_output = trainer.run()
+```
+
+## Examples
+
+| Example | Config | Description |
+|---|---|---|
+| `examples/preprocess_dataset.py` | `examples/configs/xsc_preprocess.yml` | Loads FTP-reframed XStoryCloze (English split) directly from the HuggingFace Hub and tokenizes it for BLOOM-560M; saves tokenized output locally. |
+| `examples/run_model.py` | `examples/configs/xsc_finetune.yml` | Fine-tunes BLOOM-560M with XPE PEFT on the Arabic split of FTP-reframed XStoryCloze, then evaluates. |
+
+More examples — encoder-only text classification, encoder-decoder seq2seq, MLM pretraining, additional PEFT methods (LoRA, Prefix, P-Tuning) — are planned for subsequent releases.
+
+## Supported architectures
+
+| Architecture | Toolkit support | Demonstrated by example in v0.1.0 |
+|---|---|---|
+| Decoder-only (BLOOM, AYA) | ✅ | ✅ |
+| Encoder-only (BERT, XLM-R) | ✅ | ⏳ planned |
+| Encoder-decoder (T5) | ✅ | ⏳ planned |
+
+PEFT methods supported by the toolkit: LoRA, Prefix Tuning, P-Tuning (SPT), Cross-Prompt Encoder (XPE). v0.1.0 examples demonstrate XPE only.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+ruff check src/
+ruff format src/
+pytest
+```
+
+## Contributing
+
+Pull requests are welcome. For non-trivial changes, please open an issue first to discuss the proposed change. A `CONTRIBUTORS.md` will be added with the first external contribution.
+
+## Acknowledgements
+
+`micm-nlp` was developed at the Muskhelishvili Institute of Computational Mathematics (MICM, Georgian Technical University), in close research collaboration with Teimuraz Saghinadze (MICM), Simon Ostermann (DFKI / CERTAIN), and Philipp Müller (Max Planck Institute for Intelligent Systems), whose joint work on the Cross-Prompt Encoder (XPE) drove much of the toolkit's design and validation.
+
+This work was partially supported by the European Union under Horizon Europe project "GAIN" (GA #101078950) and by the German Federal Ministry of Research, Technology and Space (BMFTR) as part of the project TRAILS (01IW24005).
+
+## Citation
+
+If you use `micm-nlp` in your research, please cite the package and (if relevant to your work) the XPE paper that drove its design:
+
+```bibtex
+@software{micm_nlp,
+  author = {Mikaberidze, Beso},
+  title = {micm-nlp: NLP research toolkit for multilingual fine-tuning and PEFT},
+  url = {https://github.com/bmikaberidze/micm-nlp},
+  version = {0.1.0},
+  year = {2026},
+}
+
+@misc{mikaberidze2025crosspromptencoderlowperforminglanguages,
+  title         = {Cross-Prompt Encoder for Low-Performing Languages},
+  author        = {Beso Mikaberidze and Teimuraz Saghinadze and Simon Ostermann and Philipp Muller},
+  year          = {2026},
+  eprint        = {2508.10352},
+  archivePrefix = {arXiv},
+  primaryClass  = {cs.CL},
+  url           = {https://arxiv.org/abs/2508.10352},
+}
+```
+
+## Contact
+
+`beso.mikaberidze@gmail.com`

micm_nlp-0.1.0/dockerfile

@@ -0,0 +1,25 @@
+# nvidia-smi
+# nvidia-container-toolkit --version
+FROM pytorch/pytorch:2.0.1-cuda11.7-cudnn8-devel
+
+# Create working directory
+ENV WORKDIR=/app
+WORKDIR ${WORKDIR}
+
+# Install system packages (git needed for GitPython; strace for debugging)
+RUN apt-get update -y && \
+    apt-get install -y --no-install-recommends \
+        git \
+        strace \
+        apt-transport-https \
+        ca-certificates && \
+    apt-get clean && rm -rf /var/lib/apt/lists/*
+
+# Install package
+RUN pip install --upgrade pip
+COPY pyproject.toml .
+COPY src/ src/
+RUN pip install -e ".[dev]"
+
+# Check if CUDA is available:
+CMD [ "/bin/bash", "-c",  "python -c \"import torch; print(f'CUDA is available: {torch.cuda.is_available()}')\"" ]