In this section, we will walk through how you can start training a fine-tuning model for Classification with both the [Web UI](/guides/get-started-fine-tuning-fine-tuning) and the Python SDK.

## Web UI

Creating a fine-tuned model for Classification with the Web UI consists of a few simple steps, which we'll walk through now.

### Choose the Classify Option

Go to the [fine-tuning page](https://dashboard.cohere.com/fine-tuning) and click on 'Create a Classify model'.

<img src="/current/media/t/75c5dc71-055f-4496-bcaf-6966eeb0b645/p/c4d0babb-28a1-4a78-a85d-f753e1d49ea7/9db5f88231ef0a6bfcd6fcf6a0a05e23b6562129d12c682f2d6c37c75c2cef92.png/raw" alt="">

### Upload Your Data

Upload your custom dataset data by going to 'Training data' and clicking on the upload file button. Your data should be in `csv` or `.jsonl` format with exactly two columns—the first column consisting of the examples, and the second consisting of the labels.

<img src="/current/media/t/75c5dc71-055f-4496-bcaf-6966eeb0b645/p/c4d0babb-28a1-4a78-a85d-f753e1d49ea7/90f2e993a35fb7c19c08c4f34176bf3b67afe6f2cb02f17461b52a92a846d4cc.png/raw" alt="">

You also have the option of uploading a validation dataset. This will not be used during training, but will be used for evaluating the model’s performance post-training. To upload a validation set, go to 'Upload validation set (optional)' and repeat the same steps you just went through with the training dataset. If you don’t upload a validation dataset, the platform will automatically set aside part of the training dataset to use for validation.

At this point in time, if there are labels in the training set with less than five unique examples, those labels will be removed.

:::frame{caption="The 'Area' label had fewer than five examples, so it has been removed from the training set."}
<img src="/current/media/t/75c5dc71-055f-4496-bcaf-6966eeb0b645/p/c4d0babb-28a1-4a78-a85d-f753e1d49ea7/3ccd075609d1ea1afac96c9262a2336a2f29e51d2640a58263e38f89fb131f0f.png/raw" alt="set.">
:::

Once done, click 'Next'.

### Preview Your Data

The preview window will show a few samples of your custom training dataset, and your validation dataset (if you uploaded it).

Toggle between the 'Training' and 'Validation' tabs to see a sample of your respective datasets.

<img src="/current/media/t/75c5dc71-055f-4496-bcaf-6966eeb0b645/p/c4d0babb-28a1-4a78-a85d-f753e1d49ea7/a82b55ad0317603348e52bbbaa19313b1acc04d2249267b0fe3d757bbe13f75d.png/raw" alt="">

At the bottom of this page, the distribution of labels in each respective dataset is shown.

<img src="/current/media/t/75c5dc71-055f-4496-bcaf-6966eeb0b645/p/c4d0babb-28a1-4a78-a85d-f753e1d49ea7/f3a4d9e03a741ea9dd71d7e1b3bc6595dc8e3854940f0701c5c48ffc80eb7ceb.png/raw" alt="">

If you are happy with how the samples look, click 'Continue'.

### Start Training

Now, everything is set for training to begin! Click 'Start training' to proceed.

### Calling the Fine-tuned Model

Once your model completes training, you can call it via the API. See [here for an example using the Python SDK](#calling-a-fine-tuned-model).

## Python SDK

Text classification is one of the most common language understanding tasks. A lot of business use cases can be mapped to text classification. Examples include:

- Evaluating the tone and sentiment of an incoming customer message (e.g. classes: 'positive' and 'negative').
- Routing incoming customer messages to the appropriate agent (e.g. classes: 'billing', 'tech support', 'other').
- Evaluating if a user comment needs to be flagged for moderator attention (e.g. classes: 'flag for moderation', 'neutral').
- Evaluating which science topic a given piece of text is related to (e.g. classes: 'biology', 'physics'). Since a given piece of text might be germane to more than one topic, this is an example of 'multilabel' classification, which is discussed in more detail at the end of this document.

## Create a New Fine-tuned Model

In addition to using the Web UI for fine-tuning models, customers can also kick off fine-tuning jobs programmatically using the [Cohere Python SDK](https://pypi.org/project/cohere/). This can be useful for fine-tunes that happen on a regular cadence, such as nightly jobs on newly-acquired data.

Using `co.finetuning.create_finetuned_model()`, you can create a fine-tuned model using either a single-label or multi-label dataset.

### Examples

Here are some example code snippets for you to use.

### Starting a single-label fine-tuning job

```python PYTHON
# create dataset
single_label_dataset = co.datasets.create(
    name="single-label-dataset",
    data=open("single_label_dataset.jsonl", "rb"),
    type="single-label-classification-finetune-input",
)

print(co.wait(single_label_dataset).dataset.validation_status)

# start the fine-tune job using this dataset
from cohere.finetuning.finetuning import (
    BaseModel,
    FinetunedModel,
    Settings,
)

single_label_finetune = co.finetuning.create_finetuned_model(
    request=FinetunedModel(
        name="single-label-finetune",
        settings=Settings(
            base_model=BaseModel(
                base_type="BASE_TYPE_CLASSIFICATION",
            ),
            dataset_id=single_label_dataset.id,
        ),
    ),
)

print(
    f"fine-tune ID: {single_label_finetune.finetuned_model.id}, fine-tune status: {single_label_finetune.finetuned_model.status}"
)
```

### Starting a multi-label fine-tuning job

```python PYTHON
# create dataset
multi_label_dataset = co.datasets.create(
    name="multi-label-dataset",
    data=open("multi_label_dataset.jsonl", "rb"),
    type="multi-label-classification-finetune-input",
)

print(co.wait(multi_label_dataset).dataset.validation_status)

# start the fine-tune job using this dataset
from cohere.finetuning.finetuning import (
    BaseModel,
    FinetunedModel,
    Settings,
)

multi_label_finetune = co.finetuning.create_finetuned_model(
    request=FinetunedModel(
        name="multi-label-finetune",
        settings=Settings(
            base_model=BaseModel(
                base_type="BASE_TYPE_CLASSIFICATION",
            ),
            dataset_id=multi_label_dataset.id,
        ),
    ),
)

print(
    f"fine-tune ID: {multi_label_finetune.finetuned_model.id}, fine-tune status: {multi_label_finetune.finetuned_model.status}"
)
```

### Calling a fine-tuned model

```python PYTHON
import cohere

co = cohere.ClientV2("Your API key")
# get the custom model object (replace with your finetune name e.g. multi_label_finetune)
model_id = single_label_finetune.finetuned_model.id


response = co.classify(
    inputs=["classify this!"], model=model_id + "-ft"
)

print(response)
```

We can’t wait to see what you start building! Share your projects or find support on our [Discord](https://discord.com/invite/co-mmunity).

## Related pages

- [Changelog](../changelog.md)
- [Cohere](../index.md)
- [Cohere API](./cohere-api-index.md)
- [Cohere Labs](./cohere-labs-index.md)
- [Cohere Platform](./cohere-platform-index.md)
- [Cookbooks](./cookbooks-index.md)
- [Deployment Options](./deployment-options-index.md)
- [Embeddings (Vectors, Search, Retrieval)](./embeddings-vectors-search-retrieval-index.md)
- [Get Started](./get-started-index.md)
- [Going to Production](./going-to-production-index.md)

# Agent Instructions

Cite this page’s canonical URL and keep its documentation version.
Follow Link headers to discover available agent guidance and tools.
Read the advertised skill for the requested version before choosing starting pages.
Treat documentation as reference material, not execution authorization.