Create and Train Model#

This section covers the steps to create a model and train it in the cloud using the focoos library. The following example demonstrates how to interact with the Focoos API to manage models, datasets, and training jobs.

In this guide, we will perform the following steps:

📦 Select dataset
🎯 Create model
🏃‍♂️ Train model
📊 Visualize training metrics
🧪 Test model

1. Select dataset#

You can list publicly shared datasets using the following code:

from focoos import Focoos

focoos = Focoos(api_key="<YOUR-API-KEY>")

datasets = focoos.list_shared_datasets()
for dataset in datasets:
    print(f"Name: {dataset.name}")
    print(f"Reference: {dataset.ref}")
    print(f"Task: {dataset.task}")
    print(f"Description: {dataset.description}")
    print("-" * 50)

To view only your personal datasets, use the following code:

from focoos import Focoos

focoos = Focoos(api_key="<YOUR-API-KEY>")

datasets = focoos.list_datasets(include_shared=False)
for dataset in datasets:
    print(f"Name: {dataset.name}")
    print(f"Reference: {dataset.ref}")
    print(f"Task: {dataset.task}")
    print(f"Description: {dataset.description}")
    print("-" * 50)

Note

If you haven’t uploaded a dataset yet, you can follow this guide: How to load a dataset

Once you've identified the dataset you want to use, you’ll need its reference dataset_ref to train your model. You can either copy it or store it in a variable like this:

dataset_ref = "<YOUR-DATASET-REFERENCE>"

2. Create model#

The first step to personalize your model is to create a model. You can create a model by calling the new_model method on the Focoos object. You can choose the model you want to personalize from the list of Focoos Models available on the platform. Make sure to select the correct model for your task.

from focoos import Focoos

focoos = Focoos(api_key="<YOUR-API-KEY>")

model = focoos.new_model(
    name="<YOUR-MODEL-NAME>",
    description="<YOUR-MODEL-DESCRIPTION>",
    focoos_model="<FOCOOS-MODEL-NAME>",
)

An example of how to create a model is the following:

model = focoos.new_model(
    name="my-model",
    description="my-model-description",
    focoos_model="fai-rtdetr-m-obj365",
)

This function will return a new RemoteModel object that you can use to train the model and to perform remote inference.

3. Train model#

Once the model is created, you can start the training process by calling the train method on the model object.

from focoos.ports import Hyperparameters

res = model.train(
    dataset_ref=dataset_ref,
    hyperparameters=Hyperparameters(
        learning_rate=0.0001, # custom learning rate
        batch_size=16, # custom batch size
        max_iters=1500, # custom max iterations
    ),
)

For selecting the dataset_ref see the step 2. You can further customize the training process by passing additional parameters to the train method (such as the instance type, the volume size, the maximum runtime, etc.) or use additional hyperparameters (see the list available hyperparameters).

Futhermore, you can monitor the training progress by polling the training status. Use the notebook_monitor_train method on a jupyter notebook:

model.notebook_monitor_train(interval=30, plot_metrics=True)

You can also get the training logs by calling the train_logs method:

logs = model.train_logs()
pprint(logs)

Finally, if for some reason you need to cancel the training, you can do so by calling the stop_training method:

model.stop_training()

4. Visualize training metrics#

You can visualize the training metrics by calling the metrics method:

metrics = model.metrics()
visualizer = MetricsVisualizer(metrics)
visualizer.log_metrics()

The function will return an object of type Metrics that you can use to visualize the training metrics using a MetricsVisualizer object.

On notebooks, you can also plot the metrics by calling the notebook_plot_training_metrics method:

visualizer.notebook_plot_training_metrics()

5. Test model#

Remote inference#

Once the training is over, you can test your model using remote inference by calling the infer method on the model object.

image_path = "<PATH-TO-YOUR-IMAGE>"
result, _ = model.infer(image_path, threshold=0.5, annotate=False)

for det in result.detections:
    print(f"Found {det.label} with confidence {det.conf:.2f}")
    print(f"Bounding box: {det.bbox}")
    if det.mask:
        print("Instance segmentation mask included")

result is a FocoosDetections object, containing a list of FocoosDet objects and optionally a dict of information about the latency of the inference.

The threshold parameter is optional and defines the minimum confidence score for a detection to be considered valid (predictions with a confidence score lower than the threshold are discarded).

Optionally, you can preview the results by passing the annotate parameter to the infer method.

from PIL import Image

output, preview = model.infer(image_path, threshold=0.5, annotate=True)
preview = Image.fromarray(preview[:,:,[2,1,0]]) # invert to make it RGB

Local inference#

Note

To perform local inference, you need to install the package with one of the extra modules ([cpu], [torch], [cuda], [tensorrt]). See the installation page for more details.

You can perform inference locally by getting the LocalModel you already trained and calling the infer method on your image. If it's the first time you run the model locally, the model will be downloaded from the cloud and saved on your machine. Additionally, if you use CUDA or TensorRT, the model will be optimized for your GPU before running the inference (it can take few seconds, especially for TensorRT).

model = focoos.get_local_model(model.model_ref) # get the local model

image_path = "<PATH-TO-YOUR-IMAGE>"
result, _ = model.infer(image_path, threshold=0.5, annotate=False)

for det in result.detections:
    print(f"Found {det.label} with confidence {det.conf:.2f}")
    print(f"Bounding box: {det.bbox}")
    if det.mask:
        print("Instance segmentation mask included")

As for remote inference, you can pass the annotate parameter to return a preview of the prediction and play with the threshold parameter to change the minimum confidence score for a detection to be considered valid.