Add pt hf trainer

.dockerignore

@@ -1 +1,4 @@
-venv
+*
+!dist
+!README.md
+!LICENSE

.github/workflows/build-image.yml

@@ -0,0 +1,32 @@
+on:
+  push:
+    branches: [main]
+    paths:
+      - "caikit_nlp"
+      - "README.md"
+      - "pyproject.toml"
+      - "Dockerfile"
+
+  pull_request:
+
+name: Build Image
+
+jobs:
+  build-image:
+    name: Build Image
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v4
+        with:
+          python-version: 3.9
+      - name: Setup tox
+        run: |
+          pip install -U pip wheel
+          pip install tox
+      - name: Build wheel
+        run: |
+          tox -e build
+      - name: Build image
+        run: |
+          docker build -t caikit-nlp:latest .

.github/workflows/publish-library.yml

@@ -25,12 +25,11 @@ jobs:
       - uses: actions/checkout@v3
       - name: Set up Python
         uses: actions/setup-python@v3
-      - name: Release
-        env:
-          FLIT_PASSWORD: ${{ secrets.PYPI_TOKEN }}
+      - name: Build and check package
         run: |
-          pip install tox
-          RELEASE_VERSION=${GITHUB_REF#refs/*/}
-          RELEASE_VERSION=${RELEASE_VERSION#v*}
-          sed -i "s/^version = .*/version = \"${RELEASE_VERSION}\"/" pyproject.toml
-          tox -e publish
+          tox -e build,twinecheck
+      - name: Upload package
+        if: github.event_name == 'release'
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.PYPI_TOKEN }}

.gitignore

@@ -166,3 +166,4 @@ prompt_prefixes
 sample_prompt
 transformers_cache
 generated_interfaces
+/caikit_nlp/_version.py

Dockerfile

@@ -0,0 +1,45 @@
+FROM registry.access.redhat.com/ubi8/ubi-minimal:latest as builder
+
+RUN microdnf update -y && \
+    microdnf install -y \
+        git python39-pip && \
+    pip3 install --upgrade --no-cache-dir pip && \
+    microdnf clean all
+
+RUN python3 -m venv /opt/caikit/
+
+ENV VIRTUAL_ENV=/opt/caikit
+ENV PATH="$VIRTUAL_ENV/bin:$PATH"
+
+COPY dist/caikit_nlp*.whl /tmp/
+RUN pip install --no-cache /tmp/caikit_nlp*.whl && rm /tmp/caikit_nlp*.whl
+
+
+FROM registry.access.redhat.com/ubi8/ubi-minimal:latest as deploy
+
+RUN microdnf update -y && \
+    microdnf install -y \
+        shadow-utils python39 && \
+    microdnf clean all
+
+COPY --from=builder /opt/caikit /opt/caikit
+COPY LICENSE /opt/caikit/
+COPY README.md /opt/caikit/
+
+RUN groupadd --system caikit --gid 1001 && \
+    adduser --system --uid 1001 --gid 0 --groups caikit \
+    --home-dir /caikit --shell /sbin/nologin \
+    --comment "Caikit User" caikit
+
+ENV VIRTUAL_ENV=/opt/caikit
+ENV PATH="$VIRTUAL_ENV/bin:$PATH"
+
+USER caikit
+
+ENV RUNTIME_LIBRARY=caikit_nlp
+# Optional: use `CONFIG_FILES` and the /caikit/ volume to explicitly provide a configuration file and models
+# ENV CONFIG_FILES=/caikit/caikit.yml
+VOLUME ["/caikit/"]
+WORKDIR /caikit
+
+CMD ["python"]

README.md

@@ -16,20 +16,142 @@ Capabilities provided by `caikit-nlp`:
 | Tokenization         | 1. `RegexSentenceSplitter`                | 1. Demo purposes only                                                                                                                                       |
 | Embedding         | [COMING SOON]                | [COMING SOON]                                                                                                                                       |
 
-### Getting Started
+## Getting Started
+
+### Notebooks
 
 To help you quickly get started with using Caikit, we have prepared a [Jupyter notebook](examples/Caikit_Getting_Started.ipynb) that can be run in Google Colab. Caikit-nlp is a powerful library that leverages prompt tuning and fine-tuning to add NLP domain capabilities to caikit.
 
+### Installation
+
+To install from git repo:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install git+https://github.com/caikit/caikit-nlp
+```
+
+### Bootstrapping models
+
+`caikit_nlp` can use  Hugging Face models, allowing for direct download and bootstrapping.
+
+For example, to use [google/flan-t5-small](https://huggingface.co/google/flan-t5-small):
+
+```python
+import os
+# The env var ALLOW_DOWNLOADS has to be set to allow model downloads before importing caikit_nlp
+os.environ['ALLOW_DOWNLOADS'] = "1"
+
+import caikit_nlp
+
+model_name = "google/flan-t5-small"
+model = caikit_nlp.text_generation.TextGeneration.bootstrap(model_name)
+model.save(f"{model_name}-caikit") # optionally save the model
+```
+
+### Serving models
+
+To serve models, the following basic configuration can be used:
+
+```yaml
+# config.yml
+runtime:
+  library: caikit_nlp
+  local_models_dir: ./models
+
+log:
+  formatter: pretty # optional: log formatter is set to json by default
+```
+
+Start the server:
+
+```bash
+env CONFIG_FILES=./config.yml python -m caikit.runtime
+```
+
+The model can now be queried at `localhost:8080` via http or at `localhost:8085` via grpc.
+
+For example, using the http server and using curl to send a POST request:
+
+```bash
+curl --json '{
+    "model_id": "flan-t5-small-caikit",
+    "inputs": "At what temperature does liquid Nitrogen boil?"
+}' localhost:8080/api/v1/task/text-generation
+```
+
+We get the following response:
+
+```json
+{
+  "generated_text": "74 degrees F",
+  "generated_tokens": 5,
+  "finish_reason": "MAX_TOKENS",
+  "producer_id": {
+    "name": "Text Generation",
+    "version": "0.1.0"
+  },
+  "input_token_count": 10,
+  "seed": null
+}
+```
+
+All the available API endpoints and protos can be dumped using [`scripts/dump_apis.sh`](/scripts/dump_apis.sh).
+
+### Docker
+
+To build the docker image:
+
+```bash
+python -m build --wheel
+docker build -t caikit-nlp:latest .
+```
+
+A volume can be mounted at `/caikit` providing configuration and (optionally) models:
+
+```bash
+mkdir -p caikit
+$EDITOR caikit/config.yml # edit as required
+cp -r <path/to/models> ./caikit/models
+docker run -e CONFIG_FILES=/caikit/config.yml -v $PWD/caikit/:/caikit -p 8080:8080 -p 8085:8085 python -m caikit.runtime
+```
+
+#### Serving with containers
+
+In order to start the serving runtime:
+
+```bash
+docker run -e CONFIG_FILES=/caikit/config.yml \
+    -v $PWD/caikit/:/caikit -p 8080:8080 -p 8085 \
+    python -m caikit.runtime
+```
+
+Assuming the standard configuration with port `8080` for the http server and `8085` for the grpc server.
+
+### Configuration
+
+Configuration can be provided via environment variables or by providing a yaml configuration file thanks to [`alchemy-config`](https://github.com/IBM/alchemy-config).
+
+For example, to set the caikit runtime, setting `RUNTIME_LIBRARY=caikit_nlp` via environment variables or providing the following yaml configuration is equivalent.
+
+```yaml
+# config.yml
+runtime:
+  library: caikit_nlp
+```
+
+For configuration options see `caikit_nlp`'s example config: [`config.yml`](/caikit_nlp/config/config.yml) or `caikit`'s example [`caikit.yml`](https://github.com/caikit/caikit/blob/main/caikit/config/config.yml).
 
-### Contributing
+## Contributing
 
 We welcome contributions from the community! If you would like to contribute to `caikit-nlp`, please read the guidelines in the main project's [CONTRIBUTING.md](CONTRIBUTING.md) file. It includes information on submitting bug reports, feature requests, and pull requests. Make sure to follow our coding standards, [code of conduct](code-of-conduct.md), [security standards](https://github.com/caikit/community/blob/main/SECURITY.md), and documentation guidelines to streamline the contribution process.
 
-### License
+## License
 
 This project is licensed under the [ASFv2 License](LICENSE).
 
-### Glossary
+## Glossary
 
 A list of terms that either may be unfamiliar or that have nebulous definitions based on who and where you hear them, defined for how they are used/thought of in the `caikit`/`caikit-nlp` project:
 
@@ -41,7 +163,7 @@ Prompt tuning - learning soft prompts. This is different from prompt engineering
 
 The important difference between fine tuning and capabilities like prompt tuning/multi-taskprompt tuning is that the latter doesn't change the base model's weights at all. So when you run inference for prompt tuned models, you can have n prompts to 1 base model, and just inject the prompt tensors you need when they're requested instead of having _n_ separate fine-tuned models.
 
-### Runtime Performance Benchmarking 
+## Runtime Performance Benchmarking
 
 [Runtime Performance Benchmarking](./benchmarks/README.md) for tuning various models.
 

caikit_nlp/__init__.py

@@ -29,6 +29,7 @@
 from .data_model import *
 from .modules import *
 from .resources import *
+from .version import __version__, __version_tuple__
 
 # Configure the library with library-specific configuration file
 CONFIG_PATH = os.path.realpath(

caikit_nlp/config/config.yml

@@ -21,11 +21,20 @@ torch_dtype: float32
 # Path of folder that will contain all the source prompts
 source_prompt_base: ""
 
+# Path for searching base models from
+base_models_dir: ""
+
 # Whether or not to purge TGIS prompts on model deletion
 unload_tgis_prompt_artifacts: false
 # Torchrun elastic launch configuration, e.g., for fine tuning on multiple GPUs
 master_addr: localhost
 master_port: 29550
 
+training_data_limit:
+  __default__: -1
+  # Configuration for PeftPromptTuning module
+  6655831b-960a-4dc5-8df4-867026e2cd41:
+    add_model_name_here: 10000
+
 runtime:
   library: caikit_nlp

caikit_nlp/modules/text_classification/sequence_classification.py

@@ -21,8 +21,8 @@
 import torch
 
 # First Party
+from caikit.core.exceptions import error_handler
 from caikit.core.modules import ModuleBase, ModuleLoader, ModuleSaver, module
-from caikit.core.toolkit import error_handler
 from caikit.interfaces.nlp.data_model import ClassificationResult, ClassificationResults
 from caikit.interfaces.nlp.tasks import TextClassificationTask
 import alog

caikit_nlp/modules/text_generation/peft_config.py

@@ -15,6 +15,7 @@
 # Standard
 from enum import Enum
 import os
+import re
 
 # Third Party
 from peft import MultitaskPromptTuningInit
@@ -44,6 +45,8 @@
 log = alog.use_channel("PFT_CNFG_TLKT")
 error = error_handler.get(log)
 
+SOURCE_DIR_VALIDATION_REGEX = re.compile(r"^[-a-zA-Z_0-9\/]+")
+
 
 class TuningType(str, Enum):
     PROMPT_TUNING = "PROMPT_TUNING"
@@ -56,6 +59,20 @@ class TuningType(str, Enum):
 
 def resolve_base_model(base_model, cls, torch_dtype):
     if isinstance(base_model, str):
+
+        error.value_check(
+            "<NLP66932773E>",
+            re.fullmatch(SOURCE_DIR_VALIDATION_REGEX, base_model),
+            "invalid characters in base_model name",
+        )
+        if get_config().base_models_dir:
+
+            base_model_full_path = os.path.join(
+                get_config().base_models_dir, base_model
+            )
+            if os.path.exists(base_model_full_path):
+                base_model = base_model_full_path
+
         model_config = AutoConfig.from_pretrained(
             base_model, local_files_only=not get_config().allow_downloads
         )
@@ -200,4 +217,4 @@ def get_peft_config(
         output_model_types=output_model_types,
     )
 
-    return task_type, output_model_types, peft_config, tuning_type
+    return task_type, output_model_types, peft_config, tuning_type