clarifai 9.10.2__py3-none-any.whl → 9.10.3__py3-none-any.whl

clarifai/datasets/upload/loaders/README.md

@@ -1,49 +0,0 @@
-## Dataset Loaders
-
-A collection of data preprocessing modules for popular public datasets to allow for compatible upload into Clarifai user app datasets.
-
-## Usage
-
-If a dataset module exists in the zoo, uploading the specific dataset can be easily done by simply creating a python script (or via commandline) and specifying the dataset module name in the `dataset_loader` parameter of the  `Dataset` class, `upload_dataset` method .i.e.
-
-```python
-from clarifai.client.app import App
-
-app = App(app_id="", user_id="")
-# Create a dataset in Clarifai App
-dataset = app.create_dataset(dataset_id="")
-# execute data upload to Clarifai app dataset
-dataset.upload_dataset(task='visual_segmentation', split="train", dataset_loader='coco_segmentation')
-```
-
-## Dataset Loaders
-
- | dataset name | task | module name (.py) | splits |
- | --- | --- | --- | --- |
- | [COCO 2017](https://cocodataset.org/#download) | Detection | `coco_detection` | `train`, `val` |
- |        | Segmentation | `coco_segmentation` | `train`, `val` |
- |       | Captions | `coco_captions` | `train`, `val` |
- |[xVIEW](http://xviewdataset.org/)  | Detection | `xview_detection` | `train`
- | [ImageNet](https://www.image-net.org/)  | Classification | `imagenet_classification` | `train`
-## Contributing Modules
-
-A dataloader (preprocessing) module is a python script that contains a dataloader class which implements data download (to download the dataloader from a source to local disk dir) & extraction and dataloader methods.
-
-The class naming convention is `<datasetname>DataLoader`. The dataset class must accept `split` as the only argument in the `__init__` method and the `__getitem__` method must return either of `VisualClassificationFeatures()`, `VisualDetectionFeatures()`, `VisualSegmentationFeatures()` or `TextFeatures()` as defined in [clarifai/datasets/upload/features.py](../features.py). Other methods can be added as seen fit but must be inherited from parent `ClarifaiDataLoader` base class [clarifai/datasets/upload/base.py](../base.py).
-Reference can be taken from the existing dataset modules in the zoo for development.
-
-## Notes
-
-* Dataloaders in the zoo by default first create a `data` directory in the zoo directory then download the data into this `data` directory, preprocess the data and finally execute upload to a Clarifai app dataset. For instance with the COCO dataset modules above, the coco2017 dataset is by default downloaded first into a `data` directory, extracted and then preprocessing is performed on it and finally uploaded to Clarifai.
-
-* Taking the above into consideration, to avoid the scripts re-downloading data you already have locally, create a `data` directory in the loaders directory and move your extracted data there. **Ensure that the extracted folder/file names and file structure MATCH those when the downloaded zips are extracted.**
-
-* COCO Format: To reuse the coco modules above on your coco format data, ensure the criteria in the two points above is adhered to first. If so, pass the coco module name from any of the above in the loaders to the `dataset_loader=` parameter in `upload_dataset()`.
-
-* xVIEW Dataset: To upload, you have to register and download images,label from [xviewdataset](http://xviewdataset.org/#dataset) follow the above mentioned steps to place extracted folder in `data` directory. Finally pass the xview module name to `dataset_loader=` parameter in `upload_dataset()`.
-
-* ImageNet Dataset: ImageNet Dataset should be downloaded and placed in the 'data' folder along with the [label mapping file](https://www.kaggle.com/competitions/imagenet-object-localization-challenge/data?select=LOC_synset_mapping.txt).
-
-		<data>/
-      	├── train/
-      	├── LOC_synset_mapping.txt

clarifai/models/model_serving/README.md

@@ -1,155 +0,0 @@
-## Clarifai Model Serving: Deploy Your Machine Learning Models to Clarifai.
-
-Build and easily deploy machine learning models to Clarifai for inference using the [Nvidia Triton Inference Server](https://github.com/triton-inference-server/server).
-
-## QuickStart Guide: Build a deployment ready model.
-
-A step by step guide to building your own triton inference model and deploying it into a Clarifai app.
-
-1. Generate a triton model repository via commandline.
-```console
-clarifai-model-upload-init --model_name <Your model name> \
-		--model_type <select model type from available ones> \
-		--repo_dir <directory in which to create your model repository>
-```
-2.  1. Edit the `requirements.txt` file with dependencies needed to run inference on your model and the `labels.txt` (if available in dir) with the labels your model is to predict.
-    2.  Add your model loading and inference code inside `inference.py` script of the generated model repository under the `setup()` and `predict()` functions respectively. Refer to  The [Inference Script section]() for a description of this file.
-    3. Inference parameters (optional): you can define some inference parameters that can be adjusted on model view of Clarifai platform when making prediction. Follow [this doc](./docs/inference_parameters.md) to build the json file.
-3. Testing (Recommend) your implementation locally by running `<your_triton_folder>/1/test.py` with basic predefined tests.
-To avoid missing dependencies when deploying, recommend to use conda to create clean environment. Then install everything in `requirements.txt`. Follow instruction inside [test.py](./models/test.py) for implementing custom tests.
-  * Create conda env and install requirements:
-```bash
-# create env (note: only python version 3.8 is supported currently)
-conda create -n <your_env> python=3.8
-# activate it
-conda activate <your_env>
-# install dependencies
-pip install -r <your_triton_folder>/requirements.txt
-```
-* Then run the test by using pytest:
-
-```bash
-  # Run the test
-  pytest ./your_triton_folder/1/test.py
-  # to see std output
-  pytest --log-cli-level=INFO  -s ./your_triton_folder/1/test.py
-```
-4. Generate a zip of your triton model for deployment via commandline.
-```console
-clarifai-triton-zip --triton_model_repository <path to triton model repository to be compressed> \
-    --zipfile_name <name of the triton model zip> (Recommended to use 	  <model_name>_<model-type> convention for naming)
-```
-5. Upload the generated zip to a public file storage service to get a URL to the zip. This URL must be publicly accessible and downloadable as it's necessary for the last step: uploading the model to a Clarifai app.
-6. Set your Clarifai auth credentials as environment variables.
-```console
-export CLARIFAI_USER_ID=<your clarifai user_id>
-export CLARIFAI_APP_ID=<your clarifai app_id>
-export CLARIFAI_PAT=<your clarifai PAT>
-```
-7. Upload your model to Clarifai. Please ensure that your configuration field maps adhere to [this](https://github.com/Clarifai/clarifai-python-utils/blob/main/clarifai/models/model_serving/model_config/deploy.py)
-```console
-clarifai-upload-model --url <URL to your model zip. Your zip file name is expected to have "zipfile_name" format (in clarifai-triton-zip), if not you need to specify your model_id and model_type> \
-    --model_id <Your model ID on the platform> \
-    --model_type <Clarifai model types> \
-    --desc <A description of your model> \
-    --update_version <Optional. Add new version of existing model>  \
-    --infer_param <Optional. Path to json file contains inference parameters>
-```
-
-* Finally, navigate to your Clarifai app models and check that the deployed model appears. Click it on the model name to go the model versions table to track the status of the model deployment.
-
-## Triton Model Repository
-```diff
-    <model_name>/
-    ├── config.pbtx
-    ├── requirements.txt
-    ├── labels.txt (If applicable for given model-type)
--   ├── triton_conda.yaml
-    └── 1/
-        ├── __init__.py
-        ├── inference.py
-        ├── test.py
-        └── model.py
-```
-
-A generated triton model repository looks as illustrated in the directory tree above. Any additional files such as model checkpoints and folders needed at inference time must all be placed under the `1/` directory.
-
-- File Descriptions
-
-| Filename | Description & Use |
-| --- | --- |
-| `config.pbtxt` | Contains the triton model configuration used by the triton inference server to guide inference requests processing. |
-| `requirements.txt` | Contains dependencies needed by a user model to successfully make predictions.|
-| `labels.txt` | Contains labels listed one per line, a model is trained to predict. The order of labels should match the model predicted class indexes. |
-| `triton_conda.yaml` | Contains dependencies available in pre-configured execution environment. |
-| `1/inference.py` | The inference script where users write their inference code. |
-| `1/model.py` | The triton python backend model file run to serve inference requests. |
-| `1/test.py` | Contains some predefined tests in order to test inference implementation and dependencies locally. |
-
-## Inference Script
-
-An `inference.py` script with template code is generated during the triton model repository generation.
-**This is the script where users write their inference code**.
-This script is composed of a single class that contains a default init method and the `get_predictions()` method whose names mustn't be changed.
-
-```python
-"""User model inference script."""
-
-import os
-from pathlib import Path
-from typing import Callable
-
-class InferenceModel:
-  """User model inference class."""
-
-  def __init__(self) -> None:
-    """
-    Load inference time artifacts that are called frequently .e.g. models, tokenizers, etc.
-    in this method so they are loaded only once for faster inference.
-    """
-    self.base_path: Path = os.path.dirname(__file__)
-    ## sample model loading code:
-    #self.checkpoint_path: Path = os.path.join(self.base_path, "your checkpoint filename/path")
-    #self.model: Callable = <load_your_model_here from checkpoint or folder>
-
-  #Add relevant model type decorator to the method below (see docs/model_types for ref.)
-  def get_predictions(self, input_data, **kwargs):
-    """
-    Main model inference method.
-
-    Args:
-    -----
-      input_data: A single input data item to predict on.
-        Input data can be an image or text, etc depending on the model type.
-
-    Returns:
-    --------
-      One of the clarifai.models.model_serving.models.output types. Refer to the README/docs
-    """
-    # Delete/Comment out line below and add your inference code
-    raise NotImplementedError()
-```
-
-- `__init__()` used for one-time loading of inference time artifacts such as models, tokenizers, etc that are frequently called during inference to improve inference speed.
-
-- `get_predictions()` takes an input data item whose type depends on the task the model solves, & returns predictions for an input data item.
-
-`get_predictions()` should return any of the output types defined under [output](docs/output.md) and the predict function MUST be decorated with a task corresponding [model type decorator](docs/model_types.md). The model type decorators are responsible for passing input request batches for prediction and formatting the resultant predictions into triton inference responses.
-
-Additional methods can be added to this script's `Infer` class by the user as deemed necessary for their model inference provided they are invoked inside `get_predictions()` if used at inference time.
-
-## Next steps
-
-- [Model types docs](docs/model_types.md)
-- [Model Output types docs](docs/output.md)
-- [Dependencies](docs/dependencies.md)
-- [Examples](examples/)
-- [Custom Configs](docs/custom_config.md/)
-
-## Prerequisites
-
-* For deployment to Clarifai, you need a [Clarifai account](https://clarifai.com/signup).
-
-## Testing
-
-* Please see https://github.com/Clarifai/clarifai-python/blob/master/clarifai/models/model_serving/models/test.py

clarifai/models/model_serving/docs/custom_config.md

@@ -1,33 +0,0 @@
-## Custom Triton Configurations
-
-The commandline triton model repository generation utils do work with default values for the various triton configurations but a few of these config values can be modified to suit different task specific needs.
-
-* For vision models for instance, different input shapes for the `Height (H)` and `Width (W)` are supported and can be set via the commandline too.i.e.
-```console
-$ clarifai-model-upload-init --model_name <Your model name> \
-		--model_type <select model type from available ones> \
-		--image_shape "H, W"
-		--repo_dir <directory in which to create your model repository>
-```
-`H` and `W` each have a maximum value of 1024.
-`--image_shape` accepts both `"H, W"` and `"[H, W]"` format input.
-
-
-## Generating the triton model repository without the commandline
-
-The triton model repository can be generated via a python script specifying the same values as required in the commandline. Below is a sample of how the code would be structured with `visual_classifier`.
-
-```python
-from clarifai.models.model_serving.model_config import get_model_config, ModelTypes, TritonModelConfig
-from clarifai.models.model_serving.pb_model_repository import TritonModelRepository
-
-model_type = ModelTypes.visual_classifier
-model_config: TritonModelConfig = get_model_config(model_type).make_triton_model_config(
-	model_name="<model_name>",
-	model_version="1",
-	image_shape=<[H,W]>, # 0 < [H,W] <= 1024
-)
-
-triton_repo = TritonModelRepository(model_config)
-triton_repo.build_repository("<dir>")
-```

clarifai/models/model_serving/docs/dependencies.md

@@ -1,11 +0,0 @@
-## Inference Execution Environments
-
-Each model built for inference with triton requires certain dependencies & dependency versions be installed for successful inference execution.
-An execution environment is created for each model to be deployed on Clarifai and all necessary dependencies as listed in the `requirements.txt` file are installed there.
-
-## Supported python and torch versions
-
-Currently, models must use python 3.8 (any 3.8.x).  Supported torch versions are 1.13.1 and 2.0.1.
-If your model depends on torch, torch must be listed in your requirements.txt file (even if it is
-already a dependency of another package).  An appropriate supported torch version will be selected
-based on your requirements.txt.

clarifai/models/model_serving/docs/inference_parameters.md

@@ -1,134 +0,0 @@
-## Inference paramaters
-
-When making prediction, you may need to change some paramaters to adjust the result. Those paramaters will be passed through `paramaters()` of a request in triton python model.
-
-In order to send it to `**kwargs` of `get_predictions` in `inference.py`, you can define some parameters and they will be visible and adjustable on Clarifai model view.
-
-This document helps you to create your inference parameters that can be visibale and adjustable easily on Clarifai platform. The defined parameters will be sent as `json` file when you use `clarifai-upload-model` cli.
-
-### JSON file structure:
-The file contains a list of object has 4 fields:
-* `path` (str): name of your parameter, it must be valid as python variable
-* `field_type` (int): the parameter data type is one of {1,2,21,3}, it means {boolean, string, encrypted_string, number} respectively. `Number` means `int` or `float`. "Encrypted_string is a string that can be used to store your secrets, like API key. The API will not return the values for this as plaintext.
-* `default_value`: a default value of the parameter.
-* `description` (str): short sentence describes what the parameter does
-
-An example of 4 parameters:
-```json
-[
-  {
-    "path": "boolean_var",
-    "field_type": 1,
-    "default_value": true,
-    "description": "a boolean variable"
-  },
-  {
-    "path": "string_var",
-    "field_type": 2,
-    "default_value": "string_1",
-    "description": "a string variable"
-  },
-  {
-    "path": "number_var",
-    "field_type": 3,
-    "default_value": 9.9,
-    "description": "a float number variable"
-  },
-  {
-    "path": "secret_string_var",
-    "field_type": 21,
-    "default_value": "API_KEY",
-    "description": "a string variable contains secret like API key"
-  },
-]
-```
-
-### Generate JSON file
-1. Manually create the file based on above structure
-2. By code:
-
-#### 2.1. Fully setup
-```python
-from clarifai.models.model_serving.model_config.inference_parameter import InferParamManager, InferParam, InferParamType
-
-params = [
-  InferParam(
-    path="boolean_var",
-    field_type=InferParamType.BOOL,
-    default_value=True,
-    description="a boolean varaiabe"
-  ),
-  InferParam(
-    path="string_var",
-    field_type=InferParamType.STRING,
-    default_value="string_1",
-    description="a string varaiabe"
-  ),
-  InferParam(
-    path="number_var",
-    field_type=InferParamType.NUMBER,
-    default_value=9.9,
-    description="a float number varaiabe"
-  ),
-  InferParam(
-    path=secret_string_var",
-    field_type=InferParamType.ENCRYPTED_STRING,
-    default_value="API_KEY",
-    description="a string variable contains secret like API key"
-  ),
-]
-
-ipm = InferParamManager(params=params)
-ipm.export("your_file.json")
-```
-
-##### 2.2. Shorten
-`NOTE`: in this way `description` field will be set as empty aka "".
-*You need to modify* `description` in order to be able to upload the settings to Clarifai.
-
-`NOTE`: in this way `ENCRYPTED_STRING` type must be defined with "_" prefix
-
-```python
-params = dict(boolean_var=True, string_var="string_1", number_var=9.9, _secret_string_var="YOUR_KEY")
-ipm = InferParamManager.from_kwargs(**params)
-ipm.export("your_file.json")
-
-```
-
-3. In `test.py`. You can define your paramaters like `2.2. Shorten` in `inference_parameters` attribute of `CustomTestInferenceModel`, the file will be generated when you run the test. Keep in mind to change `description`
-
-### Usage
-Your defined parameters will be passed through `kwargs` of `InferenceModel.get_predictions` method
-in `inference.py`
-```python
-class InferenceModel:
-  def __init__():
-    # initialization
-    self.model = YourModel()
-
-  @some_wrapper_function
-  def get_predictions(self, input_data, **kwargs):
-    # `kwargs` contains your inference parameters
-
-    # get a value from kwargs
-    number_var = kwargs.get("number_var", 9.9)
-
-    # pass everything to a function
-    output = self.model.predict(input_data, **kwargs)
-
-    return SomeOutputType(output)
-
-```
-
-in `test.py`
-```python
-class CustomTestInferenceModel:
-  inference_parameters = "" # input a path of json file from `2.1` or a dict from `2.2`
-
-  ...
-
-  def test_something(self):
-    input = ...
-    output = self.triton_get_predictions(input, number_var=1, string_var="test", _secret="KEY")
-    self.assert(...)
-```

clarifai/models/model_serving/docs/model_types.md

@@ -1,20 +0,0 @@
-## Clarifai Model Types
-
-Models on the clarifai platform are deployed using the [Triton Inference Server Python Backend](https://github.com/triton-inference-server/python_backend) to allow for pre and post processing of data to and from the model.
-
-Inputs into the models are passed as numpy arrays and the predictions are similarly returned as numpy arrays.
-The predictions from user defined models in the [inference script](../README.md#the-inference-script) file have to match certain formats and shapes for the models to be upload compatible.
-
-Clarifai [model types](../models/model_types.py) are decorator functions that are responsible for passing input batch requests to user defined inference models to get predictions and format the resultant predictions into Triton Inference responses that are sent by the server for each client inference request.
-
-## Supported Model Types Wrapper Functions:
-
-- visual_detector
-- visual_classifier
-- text_classifier
-- text_to_text
-- text_embedder
-- text_to_image
-- visual_embedder
-- visual_segmenter
-- multimodal_embedder

clarifai/models/model_serving/docs/output.md

@@ -1,28 +0,0 @@
-## Clarifai Model Prediction Output Formats.
-
-Different models return different types of predictions and Clarifai output dataclasses aim at standardizing the output formats per model type for compatibility with the Clarifai API.
-
-Each machine learning modality supported by the Clarifai API has a predefined dataclass output format with all attributes being of numpy ndarray type.
-
-## Supported Formats
-
-Usage:
-```python
-from clarifai.models.model_serving.models.output import VisualDetectorOutput
-```
-| Output Type (dataclass) | Attributes | Attribute Data Type| Attribute Shapes | Description |
-| --- | --- | --- | --- | --- |
-| [VisualDetectorOutput](../models/output.py) | `predicted_bboxes` | float32 | [-1, 4] | A 2D detected bounding boxes array of any length with each element array having a length of exactly 4. All bbox coordinates MUST be normalized between 0 & 1. |
-| | `predicted_labels` | int32 | [-1, 1] | A 2D detected labels array of length equal to that of predicted_bboxes with each element array having a length of exactly 1.
-| | `predicted_scores` | float32 | [-1, 1] | A 2D detection scores array of length equal to that of predicted_bboxes & predicted_labels with each element array having a length of exactly 1.
-| | | | | |
-| [ClassifierOutput](../models/output.py) | `predicted_scores` | float32 | [-1] | The softmax of the model's predictions. The index of each predicted probability as returned by the model must correspond to the label index in the labels.txt file |
-| | | | | |
-| [TextOutput](../models/output.py) | `predicted_text` | string | [1] | Predicted text from a model |
-| | | | | |
-| [EmbeddingOutput](../models/output.py) | `embedding_vector` | float32 | [-1] | The embedding vector (image or text embedding) returned by a model |
-| | | | | |
-| [MasksOutput](../models/output.py) | `predicted_mask` | int64 | [-1, -1] | The model predicted image mask. The predicted class indices must be assigned to the corresponding image pixels in the mask where that class is predicted by the model. |
-| | | | | |
-| [ImageOutput](../models/output.py) | `image` | unint8 | [-1, -1, 3] | The model predicted/generated image |
-| | | | | |

clarifai/models/model_serving/examples/README.md

@@ -1,7 +0,0 @@
-## Clarifai Model Upload Examples
-
-A collection of pre-built triton models for different tasks.
-To run inference locally using any of the examples here, you need to have the [Triton Inference Server](https://github.com/triton-inference-server/server/blob/main/docs/customization_guide/build.md#building-with-docker) installed.
-
-Additionally some models may require other files such as checkpoints be downloaded before testing and/or deployment to Clarifai as they are ommitted here due to github file size limits.
-See the Readme files under each model to see if there any additional files required and where to place them.

clarifai/models/model_serving/examples/image_classification/README.md

@@ -1,9 +0,0 @@
-## Image Classification Triton Model Examples
-
-These can be used on the fly with minimal or no changes to test deploy image classification models to the Clarifai platform. See the required files section for each model below.
-
-* ### [VIT Age Classifier](./age_vit/)
-
-	Required files to run tests locally:
-
-	* Download the [model checkpoint from huggingface](https://huggingface.co/nateraw/vit-age-classifier/tree/main) and store it under `age_vit/1/vit-age-classifier/`

clarifai/models/model_serving/examples/image_classification/age_vit/1/vit-age-classifier/README.md

@@ -1,11 +0,0 @@
----
-tags:
-- image-classification
-- pytorch
-datasets:
-- fairface
----
-
-## ViT For Age Classification
-
-A vision transformer finetuned to classify the age of a given person's face.

clarifai/models/model_serving/examples/image_classification/age_vit/1/vit-age-classifier/config.json

@@ -1,42 +0,0 @@
-{
-  "_name_or_path": "google/vit-base-patch16-224-in21k",
-  "architectures": [
-    "ViTForImageClassification"
-  ],
-  "attention_probs_dropout_prob": 0.0,
-  "hidden_act": "gelu",
-  "hidden_dropout_prob": 0.0,
-  "hidden_size": 768,
-  "id2label": {
-    "0": "0-2",
-    "1": "3-9",
-    "2": "10-19",
-    "3": "20-29",
-    "4": "30-39",
-    "5": "40-49",
-    "6": "50-59",
-    "7": "60-69",
-    "8": "more than 70"
-  },
-  "image_size": 224,
-  "initializer_range": 0.02,
-  "intermediate_size": 3072,
-  "label2id": {
-    "0-2": 0,
-    "3-9": 1,
-    "10-19": 2,
-    "20-29": 3,
-    "30-39": 4,
-    "40-49": 5,
-    "50-59": 6,
-    "60-69": 7,
-    "more than 70": 8
-  },
-  "layer_norm_eps": 1e-12,
-  "model_type": "vit",
-  "num_attention_heads": 12,
-  "num_channels": 3,
-  "num_hidden_layers": 12,
-  "patch_size": 16,
-  "transformers_version": "4.5.0.dev0"
-}

clarifai/models/model_serving/examples/image_classification/age_vit/1/vit-age-classifier/preprocessor_config.json

@@ -1,15 +0,0 @@
-{
-    "do_normalize": true,
-    "do_resize": true,
-    "image_mean": [
-        0.5,
-        0.5,
-        0.5
-    ],
-    "image_std": [
-        0.5,
-        0.5,
-        0.5
-    ],
-    "size": 224
-}

clarifai/models/model_serving/examples/image_classification/age_vit/config.pbtxt

@@ -1,23 +0,0 @@
-name: "age_vit"
-max_batch_size: 1
-input {
-  name: "image"
-  data_type: TYPE_UINT8
-  dims: -1
-  dims: -1
-  dims: 3
-}
-output {
-  name: "softmax_predictions"
-  data_type: TYPE_FP32
-  dims: -1
-  label_filename: "labels.txt"
-}
-instance_group {
-  count: 1
-  kind: KIND_GPU
-}
-dynamic_batching {
-  max_queue_delay_microseconds: 500
-}
-backend: "python"

clarifai/models/model_serving/examples/image_classification/age_vit/labels.txt

@@ -1,9 +0,0 @@
-0-2
-3-9
-10-19
-20-29
-30-39
-40-49
-50-59
-60-69
-more than 70

clarifai/models/model_serving/examples/image_classification/age_vit/requirements.txt

@@ -1,7 +0,0 @@
-clarifai>9.5.3 # for model upload features
-tritonclient[all]
-torch==1.13.1
-transformers==4.30.2
-scipy==1.10.1
-sentencepiece==0.1.99
-protobuf<4.21.3

clarifai/models/model_serving/examples/text_classification/README.md

@@ -1,9 +0,0 @@
-## Text Classification Triton Model Examples
-
-These can be used on the fly with minimal or no changes to test deploy text classification models to the Clarifai platform. See the required files section for each model below.
-
-* ### [XLM-Roberta Tweet Sentiment Classifier](./xlm-roberta/)
-
-	Required files to run tests locally:
-
-	* Download the [model checkpoint & sentencepiece bpe model from huggingface](https://huggingface.co/cardiffnlp/twitter-xlm-roberta-base-sentiment/tree/main) and store it under `xlm-roberta/1/twitter-xlm-roberta-base-sentiment/`

clarifai/models/model_serving/examples/text_classification/xlm-roberta/1/twitter-xlm-roberta-base-sentiment/README.md

@@ -1,12 +0,0 @@
----
-language: multilingual
----
-
-
-## Twitter xlm-roberta-base for sentiment analysis
-
-This is a multilingual XLM-roBERTa-base model trained on ~198M tweets and finetuned for sentiment analysis. The sentiment fine-tuning was done on 8 languages (Ar, En, Fr, De, Hi, It, Sp, Pt) but it can be used for more languages (see paper for details).
-
-- Paper: [XLM-T: A Multilingual Language Model Toolkit for Twitter](https://arxiv.org/abs/2104.12250).
-- Official Github Repository: [XLM-T official repository](https://github.com/cardiffnlp/xlm-t).
-- Sentiment Classes: Negative, Neutral, Positive

clarifai/models/model_serving/examples/text_classification/xlm-roberta/1/twitter-xlm-roberta-base-sentiment/config.json

@@ -1,34 +0,0 @@
-{
-  "_name_or_path": "/home/jupyter/misc/tweeteval/TweetEval_models/xlm-twitter/local-twitter-xlm-roberta-base-sentiment/",
-  "architectures": [
-    "XLMRobertaForSequenceClassification"
-  ],
-  "attention_probs_dropout_prob": 0.1,
-  "bos_token_id": 0,
-  "eos_token_id": 2,
-  "gradient_checkpointing": false,
-  "hidden_act": "gelu",
-  "hidden_dropout_prob": 0.1,
-  "hidden_size": 768,
-  "id2label": {
-    "0": "negative",
-    "1": "neutral",
-    "2": "positive"
-  },
-  "initializer_range": 0.02,
-  "intermediate_size": 3072,
-  "label2id": {
-    "negative": 0,
-    "neutral": 1,
-    "positive": 2
-  },
-  "layer_norm_eps": 1e-05,
-  "max_position_embeddings": 514,
-  "model_type": "xlm-roberta",
-  "num_attention_heads": 12,
-  "num_hidden_layers": 12,
-  "output_past": true,
-  "pad_token_id": 1,
-  "type_vocab_size": 1,
-  "vocab_size": 250002
-}

clarifai/models/model_serving/examples/text_classification/xlm-roberta/1/twitter-xlm-roberta-base-sentiment/special_tokens_map.json

@@ -1 +0,0 @@
-{"bos_token": "<s>", "eos_token": "</s>", "unk_token": "<unk>", "sep_token": "</s>", "pad_token": "<pad>", "cls_token": "<s>", "mask_token": "<mask>"}

clarifai/models/model_serving/examples/text_classification/xlm-roberta/config.pbtxt

@@ -1,21 +0,0 @@
-name: "xlm-roberta"
-max_batch_size: 1
-input {
-  name: "text"
-  data_type: TYPE_STRING
-  dims: 1
-}
-output {
-  name: "softmax_predictions"
-  data_type: TYPE_FP32
-  dims: -1
-  label_filename: "labels.txt"
-}
-instance_group {
-  count: 1
-  kind: KIND_GPU
-}
-dynamic_batching {
-  max_queue_delay_microseconds: 500
-}
-backend: "python"

clarifai/models/model_serving/examples/text_classification/xlm-roberta/labels.txt

@@ -1,3 +0,0 @@
-Negative
-Neutral
-Positive